topologicpy 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

topologicpy/Graph.py

@@ -173,7 +173,7 @@ class _DrawTree(object):
 
 class Graph:
     @staticmethod
-    def AdjacencyMatrix(graph, edgeKeyFwd=None, edgeKeyBwd=None, bidirKey=None, bidirectional=True, useEdgeIndex=False, useEdgeLength=False, tolerance=0.0001):
+    def AdjacencyMatrix(graph, vertexKey=None, reverse=False, edgeKeyFwd=None, edgeKeyBwd=None, bidirKey=None, bidirectional=True, useEdgeIndex=False, useEdgeLength=False, tolerance=0.0001):
         """
         Returns the adjacency matrix of the input Graph. See https://en.wikipedia.org/wiki/Adjacency_matrix.
 
@@ -181,6 +181,10 @@ class Graph:
         ----------
         graph : topologic.Graph
             The input graph.
+        vertexKey : str , optional
+            If set, the returned list of vertices is sorted according to the dicitonary values stored under this key. The default is None.
+        reverse : bool , optional
+            If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. The default is False.
         edgeKeyFwd : str , optional
             If set, the value at this key in the connecting edge from start vertex to end verrtex (forward) will be used instead of the value 1. The default is None. useEdgeIndex and useEdgeLength override this setting.
         edgeKeyBwd : str , optional
@@ -205,12 +209,24 @@ class Graph:
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
 
         if not isinstance(graph, topologic.Graph):
             print("Graph.AdjacencyMatrix - Error: The input graph is not a valid graph. Returning None.")
             return None
         
         vertices = Graph.Vertices(graph)
+        if not vertexKey == None:
+            sorting_values = []
+            for v in vertices:
+                d = Topology.Dictionary(v)
+                value = Dictionary.ValueAtKey(d, vertexKey)
+                sorting_values.append(value)
+            vertices = Helper.Sort(vertices, sorting_values)
+            if reverse == True:
+                vertices.reverse()
+
         edges = Graph.Edges(graph)
         order = len(vertices)
         matrix = []
@@ -256,7 +272,7 @@ class Graph:
         return matrix
     
     @staticmethod
-    def AdjacencyList(graph, tolerance=0.0001):
+    def AdjacencyList(graph, vertexKey=None, reverse=True, tolerance=0.0001):
         """
         Returns the adjacency list of the input Graph. See https://en.wikipedia.org/wiki/Adjacency_list.
 
@@ -264,6 +280,10 @@ class Graph:
         ----------
         graph : topologic.Graph
             The input graph.
+        vertexKey : str , optional
+            If set, the returned list of vertices is sorted according to the dicitonary values stored under this key. The default is None.
+        reverse : bool , optional
+            If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. The default is False.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -274,10 +294,21 @@ class Graph:
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+
         if not isinstance(graph, topologic.Graph):
             print("Graph.AdjacencyList - Error: The input graph is not a valid graph. Returning None.")
             return None
         vertices = Graph.Vertices(graph)
+        if not vertexKey == None:
+            sorting_values = []
+            for v in vertices:
+                d = Topology.Dictionary(v)
+                value = Dictionary.ValueAtKey(d, vertexKey)
+                sorting_values.append(value)
+            vertices = Helper.Sort(vertices, sorting_values)
+            if reverse == True:
+                vertices.reverse()
         order = len(vertices)
         adjList = []
         for i in range(order):
@@ -533,6 +564,7 @@ class Graph:
                 bidirectional=False,
                 includeAttributes=False,
                 includeLabel=False,
+                includeGeometry=False,
                 siteLabel = "Site_0001",
                 siteDictionary = None,
                 buildingLabel = "Building_0001",
@@ -541,11 +573,7 @@ class Graph:
                 floorLevels =[],
                 labelKey="label",
                 typeKey="type",
-                sourceKey="source",
-                targetKey="target",
-                xKey = "x",
-                yKey = "y",
-                zKey = "z",
+                geometryKey="brep",
                 spaceType = "space",
                 wallType = "wall",
                 slabType = "slab",
@@ -566,6 +594,8 @@ class Graph:
             If set to True, the attributes associated with vertices in the graph are written out. Otherwise, they are not. The default is False.
         includeLabel : bool , optional
             If set to True, a label is attached to each node. Otherwise, it is not. The default is False.
+        includeGeometry : bool , optional
+            If set to True, the geometry associated with vertices in the graph are written out. Otherwise, they are not. The default is False.
         siteLabel : str , optional
             The desired site label. The default is "Site_0001".
         siteDictionary : dict , optional
@@ -578,33 +608,25 @@ class Graph:
             The desired prefixed to use for each building storey. The default is "Storey".
         floorLevels : list , optional
             The list of floor levels. This should be a numeric list, sorted from lowest to highest.
-            If not provided, floorLevels will be computed automatically based on the nodes' 'z' attribute.
-        typeKey : str , optional
-            The dictionary key to use to look up the type of the node. The default is "type".
+            If not provided, floorLevels will be computed automatically based on the vertices' 'z' attribute.
         labelKey : str , optional
             The dictionary key to use to look up the label of the node. The default is "label".
-        sourceKey : str , optional
-            The desired dictionary key to use to store the source vertex. The default is "source".
-        targetKey : str , optional
-            The desired dictionary key to use to store the target vertex. The default is "target".
-        xKey : str , optional
-            The dictionary key to use to look up the x-coordinate of the node. The default is "x".
-        yKey : str , optional
-            The dictionary key to use to look up the y-coordinate of the node. The default is "y".
-        zKey : str , optional
-            The dictionary key to use to look up the z-coordinate of the node. The default is "z".
+        typeKey : str , optional
+            The dictionary key to use to look up the type of the node. The default is "type".
+        geometryKey : str , optional
+            The dictionary key to use to look up the geometry of the node. The default is "brep".
         spaceType : str , optional
-            The dictionary string value to use to look up nodes of type "space". The default is "space".
+            The dictionary string value to use to look up vertices of type "space". The default is "space".
         wallType : str , optional
-            The dictionary string value to use to look up nodes of type "wall". The default is "wall".
+            The dictionary string value to use to look up vertices of type "wall". The default is "wall".
         slabType : str , optional
-            The dictionary string value to use to look up nodes of type "slab". The default is "slab".
+            The dictionary string value to use to look up vertices of type "slab". The default is "slab".
         doorType : str , optional
-            The dictionary string value to use to look up nodes of type "door". The default is "door".
+            The dictionary string value to use to look up vertices of type "door". The default is "door".
         windowType : str , optional
-            The dictionary string value to use to look up nodes of type "window". The default is "window".
+            The dictionary string value to use to look up vertices of type "window". The default is "window".
         contentType : str , optional
-            The dictionary string value to use to look up nodes of type "content". The default is "contents".
+            The dictionary string value to use to look up vertices of type "content". The default is "contents".
 
         Returns
         -------
@@ -639,135 +661,131 @@ class Graph:
             floorLevels = []
         json_data = Graph.JSONData(graph, vertexLabelKey=labelKey)
         # Create an empty RDF graph
-        rdf_graph = RDFGraph()
+        bot_graph = RDFGraph()
         
         # Define namespaces
         rdf = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
-        rdfs = Namespace("http://www.w3.org/2000/01/rdf-schema#")
         bot = Namespace("https://w3id.org/bot#")
         
         # Define a custom prefix mapping
-        rdf_graph.namespace_manager.bind("bot", bot)
+        bot_graph.namespace_manager.bind("bot", bot)
         
         # Add site
         site_uri = URIRef(siteLabel)
-        rdf_graph.add((site_uri, rdf.type, bot.Site))
+        bot_graph.add((site_uri, rdf.type, bot.Site))
         if includeLabel:
-            rdf_graph.add((site_uri, RDFS.label, Literal("Site_0001")))
+            bot_graph.add((site_uri, RDFS.label, Literal(siteLabel)))
         if isinstance(siteDictionary, topologic.Dictionary):
             keys = Dictionary.Keys(siteDictionary)
             for key in keys:
                 value = Dictionary.ValueAtKey(siteDictionary, key)
-                if key == labelKey:
-                    if includeLabel:
-                        rdf_graph.add((site_uri, RDFS.label, Literal(value)))
-                    elif key != typeKey:
-                        rdf_graph.add((site_uri, bot[key], Literal(value)))
+                if not (key == labelKey) and not (key == typeKey):
+                    bot_graph.add((site_uri, bot[key], Literal(value)))
         # Add building
         building_uri = URIRef(buildingLabel)
-        rdf_graph.add((building_uri, rdf.type, bot.Building))
+        bot_graph.add((building_uri, rdf.type, bot.Building))
         if includeLabel:
-            rdf_graph.add((building_uri, RDFS.label, Literal(buildingLabel)))
+            bot_graph.add((building_uri, RDFS.label, Literal(buildingLabel)))
         if isinstance(buildingDictionary, topologic.Dictionary):
             keys = Dictionary.Keys(buildingDictionary)
             for key in keys:
                 value = Dictionary.ValueAtKey(buildingDictionary, key)
                 if key == labelKey:
                     if includeLabel:
-                        rdf_graph.add((building_uri, RDFS.label, Literal(value)))
+                        bot_graph.add((building_uri, RDFS.label, Literal(value)))
                     elif key != typeKey:
-                        rdf_graph.add((building_uri, bot[key], Literal(value)))
+                        bot_graph.add((building_uri, bot[key], Literal(value)))
         # Add stories
         # if floor levels are not given, then need to be computed
         if len(floorLevels) == 0:
-            for node, attributes in json_data['nodes'].items():
+            for node, attributes in json_data['vertices'].items():
                 if slabType.lower() in attributes[typeKey].lower():
-                    floorLevels.append(attributes[zKey])
+                    floorLevels.append(attributes["z"])
             floorLevels = list(set(floorLevels))
             floorLevels.sort()
+            floorLevels = floorLevels[:-1]
         storey_uris = []
         n = max(len(str(len(floorLevels))),4)
         for i, floor_level in enumerate(floorLevels):
             storey_uri = URIRef(storeyPrefix+"_"+str(i+1).zfill(n))
-            rdf_graph.add((storey_uri, rdf.type, bot.Storey))
+            bot_graph.add((storey_uri, rdf.type, bot.Storey))
             if includeLabel:
-                rdf_graph.add((storey_uri, RDFS.label, Literal(storeyPrefix+"_"+str(i+1).zfill(n))))
+                bot_graph.add((storey_uri, RDFS.label, Literal(storeyPrefix+"_"+str(i+1).zfill(n))))
             storey_uris.append(storey_uri)
 
         # Add triples to relate building to site and stories to building
-        rdf_graph.add((site_uri, bot.hasBuilding, building_uri))
+        bot_graph.add((site_uri, bot.hasBuilding, building_uri))
         if bidirectional:
-            rdf_graph.add((building_uri, bot.isPartOf, site_uri)) # might not be needed
+            bot_graph.add((building_uri, bot.isPartOf, site_uri)) # might not be needed
 
         for storey_uri in storey_uris:
-            rdf_graph.add((building_uri, bot.hasStorey, storey_uri))
+            bot_graph.add((building_uri, bot.hasStorey, storey_uri))
             if bidirectional:
-                rdf_graph.add((storey_uri, bot.isPartOf, building_uri)) # might not be needed
+                bot_graph.add((storey_uri, bot.isPartOf, building_uri)) # might not be needed
         
         # Add vertices as RDF resources
-        for node, attributes in json_data['nodes'].items():
+        for node, attributes in json_data['vertices'].items():
             node_uri = URIRef(node)
             if spaceType.lower() in attributes[typeKey].lower():
-                rdf_graph.add((node_uri, rdf.type, bot.Space))
+                bot_graph.add((node_uri, rdf.type, bot.Space))
                 # Find the storey it is on
-                z = attributes[zKey]
+                z = attributes["z"]
                 level = Helper.Position(z, floorLevels)
                 if level > len(storey_uris):
                     level = len(storey_uris)
                 storey_uri = storey_uris[level-1]
-                rdf_graph.add((storey_uri, bot.hasSpace, node_uri))
+                bot_graph.add((storey_uri, bot.hasSpace, node_uri))
                 if bidirectional:
-                    rdf_graph.add((node_uri, bot.isPartOf, storey_uri)) # might not be needed
+                    bot_graph.add((node_uri, bot.isPartOf, storey_uri)) # might not be needed
             elif windowType.lower() in attributes[typeKey].lower():
-                rdf_graph.add((node_uri, rdf.type, bot.Window))
+                bot_graph.add((node_uri, rdf.type, bot.Window))
             elif doorType.lower() in attributes[typeKey].lower():
-                rdf_graph.add((node_uri, rdf.type, bot.Door))
+                bot_graph.add((node_uri, rdf.type, bot.Door))
             elif wallType.lower() in attributes[typeKey].lower():
-                rdf_graph.add((node_uri, rdf.type, bot.Wall))
+                bot_graph.add((node_uri, rdf.type, bot.Wall))
             elif slabType.lower() in attributes[typeKey].lower():
-                rdf_graph.add((node_uri, rdf.type, bot.Slab))
+                bot_graph.add((node_uri, rdf.type, bot.Slab))
             else:
-                rdf_graph.add((node_uri, rdf.type, bot.Element))
+                bot_graph.add((node_uri, rdf.type, bot.Element))
             
             if includeAttributes:
                 for key, value in attributes.items():
+                    if key == geometryKey:
+                        if includeGeometry:
+                            bot_graph.add((node_uri, bot.hasSimpleGeometry, Literal(value)))
                     if key == labelKey:
                         if includeLabel:
-                            rdf_graph.add((node_uri, RDFS.label, Literal(value)))
-                    elif key != typeKey:
-                        rdf_graph.add((node_uri, bot[key], Literal(value)))
+                            bot_graph.add((node_uri, RDFS.label, Literal(value)))
+                    elif key != typeKey and key != geometryKey:
+                        bot_graph.add((node_uri, bot[key], Literal(value)))
             if includeLabel:
                 for key, value in attributes.items():
                     if key == labelKey:
-                        rdf_graph.add((node_uri, RDFS.label, Literal(value)))
+                        bot_graph.add((node_uri, RDFS.label, Literal(value)))
         
         # Add edges as RDF triples
         for edge, attributes in json_data['edges'].items():
-            source = attributes[sourceKey]
-            target = attributes[targetKey]
+            source = attributes["source"]
+            target = attributes["target"]
             source_uri = URIRef(source)
             target_uri = URIRef(target)
-            if spaceType.lower() in json_data['nodes'][source][typeKey].lower() and spaceType.lower() in json_data['nodes'][target][typeKey].lower():
-                rdf_graph.add((source_uri, bot.adjacentTo, target_uri))
+            if spaceType.lower() in json_data['vertices'][source][typeKey].lower() and spaceType.lower() in json_data['vertices'][target][typeKey].lower():
+                bot_graph.add((source_uri, bot.adjacentTo, target_uri))
                 if bidirectional:
-                    rdf_graph.add((target_uri, bot.adjacentTo, source_uri))
-            elif spaceType.lower() in json_data['nodes'][source][typeKey].lower() and wallType.lower() in json_data['nodes'][target][typeKey].lower():
-                rdf_graph.add((target_uri, bot.interfaceOf, source_uri))
-            elif spaceType.lower() in json_data['nodes'][source][typeKey].lower() and slabType.lower() in json_data['nodes'][target][typeKey].lower():
-                rdf_graph.add((target_uri, bot.interfaceOf, source_uri))
-            elif spaceType.lower() in json_data['nodes'][source][typeKey].lower() and contentType.lower() in json_data['nodes'][target][typeKey].lower():
-                rdf_graph.add((source_uri, bot.containsElement, target_uri))
+                    bot_graph.add((target_uri, bot.adjacentTo, source_uri))
+            elif spaceType.lower() in json_data['vertices'][source][typeKey].lower() and wallType.lower() in json_data['vertices'][target][typeKey].lower():
+                bot_graph.add((target_uri, bot.interfaceOf, source_uri))
+            elif spaceType.lower() in json_data['vertices'][source][typeKey].lower() and slabType.lower() in json_data['vertices'][target][typeKey].lower():
+                bot_graph.add((target_uri, bot.interfaceOf, source_uri))
+            elif spaceType.lower() in json_data['vertices'][source][typeKey].lower() and contentType.lower() in json_data['vertices'][target][typeKey].lower():
+                bot_graph.add((source_uri, bot.containsElement, target_uri))
                 if bidirectional:
-                    rdf_graph.add((target_uri, bot.isPartOf, source_uri))
+                    bot_graph.add((target_uri, bot.isPartOf, source_uri))
             else:
-                rdf_graph.add((source_uri, bot.connectsTo, target_uri))
+                bot_graph.add((source_uri, bot.connectsTo, target_uri))
                 if bidirectional:
-                    rdf_graph.add((target_uri, bot.connectsTo, source_uri))
-            #for key, value in attributes.items():
-                #rdf_graph.add((source_uri, bot[key], Literal(value)))
-        # Return serialized  RDF graph
-        #rdf_serialized = rdf_graph.serialize(format=format)
-        return rdf_graph
+                    bot_graph.add((target_uri, bot.connectsTo, source_uri))
+        return bot_graph
 
     @staticmethod
     def BOTString(graph,
@@ -775,6 +793,7 @@ class Graph:
                 bidirectional=False,
                 includeAttributes=False,
                 includeLabel=False,
+                includeGeometry=False,
                 siteLabel = "Site_0001",
                 siteDictionary = None,
                 buildingLabel = "Building_0001",
@@ -783,11 +802,7 @@ class Graph:
                 floorLevels =[],
                 labelKey="label",
                 typeKey="type",
-                sourceKey="source",
-                targetKey="target",
-                xKey = "x",
-                yKey = "y",
-                zKey = "z",
+                geometryKey="brep",
                 spaceType = "space",
                 wallType = "wall",
                 slabType = "slab",
@@ -819,6 +834,8 @@ class Graph:
             If set to True, the attributes associated with vertices in the graph are written out. Otherwise, they are not. The default is False.
         includeLabel : bool , optional
             If set to True, a label is attached to each node. Otherwise, it is not. The default is False.
+        includeGeometry : bool , optional
+            If set to True, the geometry associated with vertices in the graph are written out. Otherwise, they are not. The default is False.
         siteLabel : str , optional
             The desired site label. The default is "Site_0001".
         siteDictionary : dict , optional
@@ -831,33 +848,23 @@ class Graph:
             The desired prefixed to use for each building storey. The default is "Storey".
         floorLevels : list , optional
             The list of floor levels. This should be a numeric list, sorted from lowest to highest.
-            If not provided, floorLevels will be computed automatically based on the nodes' 'z' attribute.
+            If not provided, floorLevels will be computed automatically based on the vertices' 'z' attribute.
         typeKey : str , optional
             The dictionary key to use to look up the type of the node. The default is "type".
         labelKey : str , optional
             The dictionary key to use to look up the label of the node. The default is "label".
-        sourceKey : str , optional
-            The desired dictionary key to use to store the source vertex. The default is "source".
-        targetKey : str , optional
-            The desired dictionary key to use to store the target vertex. The default is "target".
-        xKey : str , optional
-            The dictionary key to use to look up the x-coordinate of the node. The default is "x".
-        yKey : str , optional
-            The dictionary key to use to look up the y-coordinate of the node. The default is "y".
-        zKey : str , optional
-            The dictionary key to use to look up the z-coordinate of the node. The default is "z".
         spaceType : str , optional
-            The dictionary string value to use to look up nodes of type "space". The default is "space".
+            The dictionary string value to use to look up vertices of type "space". The default is "space".
         wallType : str , optional
-            The dictionary string value to use to look up nodes of type "wall". The default is "wall".
+            The dictionary string value to use to look up vertices of type "wall". The default is "wall".
         slabType : str , optional
-            The dictionary string value to use to look up nodes of type "slab". The default is "slab".
+            The dictionary string value to use to look up vertices of type "slab". The default is "slab".
         doorType : str , optional
-            The dictionary string value to use to look up nodes of type "door". The default is "door".
+            The dictionary string value to use to look up vertices of type "door". The default is "door".
         windowType : str , optional
-            The dictionary string value to use to look up nodes of type "window". The default is "window".
+            The dictionary string value to use to look up vertices of type "window". The default is "window".
         contentType : str , optional
-            The dictionary string value to use to look up nodes of type "content". The default is "contents".
+            The dictionary string value to use to look up vertices of type "content". The default is "contents".
 
         
         Returns
@@ -870,6 +877,7 @@ class Graph:
                             bidirectional=bidirectional,
                             includeAttributes=includeAttributes,
                             includeLabel=includeLabel,
+                            includeGeometry=includeGeometry,
                             siteLabel=siteLabel,
                             siteDictionary=siteDictionary,
                             buildingLabel=buildingLabel,
@@ -878,11 +886,7 @@ class Graph:
                             floorLevels=floorLevels,
                             labelKey=labelKey,
                             typeKey=typeKey,
-                            sourceKey=sourceKey,
-                            targetKey=targetKey,
-                            xKey=xKey,
-                            yKey=yKey,
-                            zKey=zKey,
+                            geometryKey=geometryKey,
                             spaceType = spaceType,
                             wallType = wallType,
                             slabType = slabType,
@@ -1048,21 +1052,189 @@ class Graph:
             x, y, z = random.uniform(xMin,xMax), random.uniform(yMin,yMax), random.uniform(zMin,zMax)
             vertices.append(Vertex.ByCoordinates(x, y, z))
 
-        # Add edges based on the adjacency matrix
-        edges = []
-        for i in range(len(adjacencyMatrix)):
-            for j in range(i + 1, len(adjacencyMatrix[i])):
-                if adjacencyMatrix[i][j] == 1:
-                    edges.append(Edge.ByVertices([vertices[i], vertices[j]]))
-
         # Create the graph using vertices and edges
         if len(vertices) == 0:
             print("Graph.ByAdjacencyMatrix - Error: The graph does not contain any vertices. Returning None.")
             return None
         
+        # Add edges based on the adjacency matrix
+        edges = []
+        for i in range(len(adjacencyMatrix)):
+            for j in range(i+1, len(adjacencyMatrix)):
+                if not adjacencyMatrix[i][j] == 0:
+                    edges.append(Edge.ByVertices([vertices[i], vertices[j]]))
+        
         return Graph.ByVerticesEdges(vertices, edges)
 
     @staticmethod
+    def ByBOTGraph(botGraph,
+                   includeContext = False,
+                   xMin = -0.5,
+                   xMax = 0.5,
+                   yMin = -0.5,
+                   yMax = 0.5,
+                   zMin = -0.5,
+                   zMax = 0.5,
+                   tolerance = 0.0001
+                ):
+
+        def value_by_string(s):
+            if s.lower() == "true":
+                return True
+            if s.lower() == "false":
+                return False
+            vt = "str"
+            s2 = s.strip("-")
+            if s2.isnumeric():
+                vt = "int"
+            else:
+                try:
+                    s3 = s2.split(".")[0]
+                    s4 = s2.split(".")[1]
+                    if (s3.isnumeric() or s4.isnumeric()):
+                        vt = "float"
+                except:
+                    vt = "str"
+            if vt == "str":
+                return s
+            elif vt == "int":
+                return int(s)
+            elif vt == "float":
+                return float(s)
+
+        def collect_nodes_by_type(rdf_graph, node_type=None):
+            results = set()
+
+            if node_type is not None:
+                for subj, pred, obj in rdf_graph.triples((None, None, None)):
+                    if "type" in pred.lower():
+                        if node_type.lower() in obj.lower():
+                            results.add(subj)
+            return list(results)
+
+        def collect_attributes_for_subject(rdf_graph, subject):
+            attributes = {}
+
+            for subj, pred, obj in rdf_graph.triples((subject, None, None)):
+                predicate_str = str(pred)
+                object_str = str(obj)
+                attributes[predicate_str] = object_str
+
+            return attributes
+
+        def get_triples_by_predicate_type(rdf_graph, predicate_type):
+            triples = []
+
+            for subj, pred, obj in rdf_graph:
+                if pred.split('#')[-1].lower() == predicate_type.lower():
+                    triples.append((str(subj), str(pred), str(obj)))
+
+            return triples
+
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Graph import Graph
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+
+        import rdflib
+        import random
+        predicates = ['adjacentto', 'interfaceof', 'containselement', 'connectsto']
+        bot_types = ['Space', 'Wall', 'Slab', 'Door', 'Window', 'Element']
+
+        if includeContext:
+            predicates += ['hasspace', 'hasbuilding', 'hasstorey']
+            bot_types += ['Site', 'Building', 'Storey']
+
+
+        namespaces = botGraph.namespaces()
+
+        for ns in namespaces:
+            if 'bot' in ns[0].lower():
+                bot_namespace = ns
+                break
+
+        ref = bot_namespace[1]
+
+        nodes = []
+        for bot_type in bot_types:
+            node_type = rdflib.term.URIRef(ref+bot_type)
+            nodes +=collect_nodes_by_type(botGraph, node_type=node_type)
+
+        vertices = []
+        dic = {}
+        for node in nodes:
+            x, y, z = random.uniform(xMin,xMax), random.uniform(yMin,yMax), random.uniform(zMin,zMax)
+            d_keys = ["bot_id"]
+            d_values = [str(node)]
+            attributes = collect_attributes_for_subject(botGraph, node)
+            keys = attributes.keys()
+            for key in keys:
+                key_type = key.split('#')[-1]
+                if key_type.lower() not in predicates:
+                    if 'x' == key_type.lower():
+                        x = value_by_string(attributes[key])
+                        d_keys.append('x')
+                        d_values.append(x)
+                    elif 'y' == key_type.lower():
+                        y = value_by_string(attributes[key])
+                        d_keys.append('y')
+                        d_values.append(y)
+                    elif 'z' == key_type.lower():
+                        z = value_by_string(attributes[key])
+                        d_keys.append('z')
+                        d_values.append(z)
+                    else:
+                        d_keys.append(key_type.lower())
+                        d_values.append(value_by_string(attributes[key].split("#")[-1]))
+
+            d = Dictionary.ByKeysValues(d_keys, d_values)
+            v = Vertex.ByCoordinates(x,y,z)
+            v = Topology.SetDictionary(v, d)
+            dic[str(node)] = v
+            vertices.append(v)
+
+        edges = []
+        for predicate in predicates:
+            triples = get_triples_by_predicate_type(botGraph, predicate)
+            for triple in triples:
+                subj = triple[0]
+                obj = triple[2]
+                sv = dic[subj]
+                ev = dic[obj]
+                e = Edge.ByVertices([sv,ev], tolerance=tolerance)
+                d = Dictionary.ByKeyValue("type", predicate)
+                e = Topology.SetDictionary(e, d)
+                edges.append(e)
+
+        return Graph.ByVerticesEdges(vertices, edges)
+
+    @staticmethod
+    def ByBOTPath(path,
+                  includeContext = False,
+                  xMin = -0.5,
+                  xMax = 0.5,
+                  yMin = -0.5,
+                  yMax = 0.5,
+                  zMin = -0.5,
+                  zMax = 0.5,
+                  tolerance = 0.0001
+                  ):
+        
+        from rdflib import Graph as RDFGraph
+        bot_graph = RDFGraph()
+        bot_graph.parse(path)
+        return Graph.ByBOTGraph(bot_graph,
+                                includeContext = includeContext,
+                                xMin = xMin,
+                                xMax = xMax,
+                                yMin = yMin,
+                                yMax = yMax,
+                                zMin = zMin,
+                                zMax = zMax,
+                                tolerance = tolerance
+                                )
+    @staticmethod
     def ByCSVPath(path,
                   graphIDHeader="graph_id", graphLabelHeader="label", graphFeaturesHeader="feat", graphFeaturesKeys=[],
                   edgeSRCHeader="src_id", edgeDSTHeader="dst_id", edgeLabelHeader="label", edgeTrainMaskHeader="train_mask", 
@@ -1788,7 +1960,7 @@ class Graph:
         return Graph.ByVerticesEdges(g_vertices, g_edges)
     
     @staticmethod
-    def ByTopology(topology, direct=True, directApertures=False, viaSharedTopologies=False, viaSharedApertures=False, toExteriorTopologies=False, toExteriorApertures=False, toContents=False, toOutposts=False, idKey="TOPOLOGIC_ID", outpostsKey="outposts", useInternalVertex=True, storeBRep=False, tolerance=0.0001):
+    def ByTopology(topology, direct=True, directApertures=False, viaSharedTopologies=False, viaSharedApertures=False, toExteriorTopologies=False, toExteriorApertures=False, toContents=False, toOutposts=False, idKey="TOPOLOGIC_ID", outpostsKey="outposts", useInternalVertex=True, storeBREP=False, tolerance=0.0001):
         """
         Creates a graph.See https://en.wikipedia.org/wiki/Graph_(discrete_mathematics).
 
@@ -1818,7 +1990,7 @@ class Graph:
             The key to use to find the list of outposts. It is case insensitive. The default is "outposts".
         useInternalVertex : bool , optional
             If set to True, use an internal vertex to represent the subtopology. Otherwise, use its centroid. The default is False.
-        storeBRep : bool , optional
+        storeBREP : bool , optional
             If set to True, store the BRep of the subtopology in its representative vertex. The default is False.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
@@ -1937,7 +2109,7 @@ class Graph:
             return returnList
                 
         def processCellComplex(item):
-            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBRep, tolerance = item
+            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             edges = []
             vertices = []
             cellmat = []
@@ -2037,7 +2209,7 @@ class Graph:
                         vop = Topology.CenterOfMass(outpost)
                         vcc = Topology.CenterOfMass(topology)
                     d1 = Topology.Dictionary(vcc)
-                    if storeBRep:
+                    if storeBREP:
                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(topology), Topology.Type(topology), Topology.TypeAsString(topology)])
                         d3 = mergeDictionaries2([d1, d2])
                         _ = vcc.SetDictionary(d3)
@@ -2059,7 +2231,7 @@ class Graph:
                     else:
                         vCell = aCell.CenterOfMass()
                     d1 = aCell.GetDictionary()
-                    if storeBRep:
+                    if storeBREP:
                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(aCell), Topology.Type(aCell), Topology.TypeAsString(aCell)])
                         d3 = mergeDictionaries2([d1, d2])
                         _ = vCell.SetDictionary(d3)
@@ -2097,7 +2269,7 @@ class Graph:
                             else:
                                 vst = sharedTopology.CenterOfMass()
                             d1 = sharedTopology.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedTopology), Topology.Type(sharedTopology), Topology.TypeAsString(sharedTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -2120,7 +2292,7 @@ class Graph:
                                         vst2 = content.CenterOfMass()
                                     d1 = content.GetDictionary()
                                     vst2 = topologic.Vertex.ByCoordinates(vst2.X(), vst2.Y(), vst2.Z())
-                                    if storeBRep:
+                                    if storeBREP:
                                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                         d3 = mergeDictionaries2([d1, d2])
                                         _ = vst2.SetDictionary(d3)
@@ -2140,8 +2312,8 @@ class Graph:
                                 vsa = sharedAp.CenterOfMass()
                             d1 = sharedAp.GetDictionary()
                             vsa = topologic.Vertex.ByCoordinates(vsa.X()+(tolerance*100), vsa.Y()+(tolerance*100), vsa.Z()+(tolerance*100))
-                            if storeBRep:
-                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedAperture), Topology.Type(sharedAperture), Topology.TypeAsString(sharedAperture)])
+                            if storeBREP:
+                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedAp), Topology.Type(sharedAp), Topology.TypeAsString(sharedAp)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vsa.SetDictionary(d3)
                             else:
@@ -2159,7 +2331,7 @@ class Graph:
                                 vet = exteriorTopology.CenterOfMass()
                             _ = vet.SetDictionary(exteriorTopology.GetDictionary())
                             d1 = exteriorTopology.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTopology), Topology.Type(exteriorTopology), Topology.TypeAsString(exteriorTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vet.SetDictionary(d3)
@@ -2182,7 +2354,7 @@ class Graph:
                                         vst2 = content.CenterOfMass()
                                     d1 = content.GetDictionary()
                                     vst2 = topologic.Vertex.ByCoordinates(vst2.X()+(tolerance*100), vst2.Y()+(tolerance*100), vst2.Z()+(tolerance*100))
-                                    if storeBRep:
+                                    if storeBREP:
                                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                         d3 = mergeDictionaries2([d1, d2])
                                         _ = vst2.SetDictionary(d3)
@@ -2195,15 +2367,15 @@ class Graph:
                                     edges.append(tempe)
                     if toExteriorApertures:
                         for exteriorAperture in exteriorApertures:
-                            extTop = exteriorAperture.Topology()
+                            exTop = exteriorAperture.Topology()
                             if useInternalVertex == True:
-                                vea = Topology.InternalVertex(extTop, tolerance)
+                                vea = Topology.InternalVertex(exTop, tolerance)
                             else:
-                                vea = exteriorAperture.Topology().CenterOfMass()
-                            d1 = exteriorAperture.Topology().GetDictionary()
+                                vea = exTop.CenterOfMass()
+                            d1 = exTop.GetDictionary()
                             vea = topologic.Vertex.ByCoordinates(vea.X()+(tolerance*100), vea.Y()+(tolerance*100), vea.Z()+(tolerance*100))
-                            if storeBRep:
-                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorAperture), Topology.Type(exteriorAperture), Topology.TypeAsString(exteriorAperture)])
+                            if storeBREP:
+                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exTop), Topology.Type(exTop), Topology.TypeAsString(exTop)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vea.SetDictionary(d3)
                             else:
@@ -2225,7 +2397,7 @@ class Graph:
                                 vcn = content.CenterOfMass()
                             vcn = topologic.Vertex.ByCoordinates(vcn.X()+(tolerance*100), vcn.Y()+(tolerance*100), vcn.Z()+(tolerance*100))
                             d1 = content.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vcn.SetDictionary(d3)
@@ -2243,7 +2415,7 @@ class Graph:
                 else:
                     vCell = aCell.CenterOfMass()
                 d1 = aCell.GetDictionary()
-                if storeBRep:
+                if storeBREP:
                     d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(aCell), Topology.Type(aCell), Topology.TypeAsString(aCell)])
                     d3 = mergeDictionaries2([d1, d2])
                     _ = vCell.SetDictionary(d3)
@@ -2253,7 +2425,7 @@ class Graph:
             return [vertices,edges]
 
         def processCell(item):
-            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBRep, tolerance = item
+            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             vertices = []
             edges = []
             if useInternalVertex == True:
@@ -2261,7 +2433,7 @@ class Graph:
             else:
                 vCell = topology.CenterOfMass()
             d1 = topology.GetDictionary()
-            if storeBRep:
+            if storeBREP:
                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(topology), Topology.Type(topology), Topology.TypeAsString(topology)])
                 d3 = mergeDictionaries2([d1, d2])
                 _ = vCell.SetDictionary(d3)
@@ -2308,7 +2480,7 @@ class Graph:
                             else:
                                 vst = exteriorTopology.CenterOfMass()
                             d1 = exteriorTopology.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTopology), Topology.Type(exteriorTopology), Topology.TypeAsString(exteriorTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -2331,7 +2503,7 @@ class Graph:
                                         vst2 = content.CenterOfMass()
                                     vst2 = topologic.Vertex.ByCoordinates(vst2.X()+(tolerance*100), vst2.Y()+(tolerance*100), vst2.Z()+(tolerance*100))
                                     d1 = content.GetDictionary()
-                                    if storeBRep:
+                                    if storeBREP:
                                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                         d3 = mergeDictionaries2([d1, d2])
                                         _ = vst2.SetDictionary(d3)
@@ -2344,15 +2516,15 @@ class Graph:
                                     edges.append(tempe)
                     if toExteriorApertures:
                         for exteriorAperture in exteriorApertures:
-                            extTop = exteriorAperture.Topology()
+                            exTop = exteriorAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(extTop, tolerance)
+                                vst = Topology.InternalVertex(exTop, tolerance)
                             else:
-                                vst = exteriorAperture.Topology().CenterOfMass()
-                            d1 = exteriorAperture.Topology().GetDictionary()
+                                vst = exTop.CenterOfMass()
+                            d1 = exTop.GetDictionary()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
-                            if storeBRep:
-                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(Aperture.Topology(exteriorAperture)), Topology.Type(Aperture.Topology(exteriorAperture)), Topology.TypeAsString(Aperture.Topology(exteriorAperture))])
+                            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:
@@ -2374,7 +2546,7 @@ class Graph:
                                 vst = content.CenterOfMass()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
                             d1 = content.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -2389,7 +2561,7 @@ class Graph:
 
         def processShell(item):
             from topologicpy.Face import Face
-            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBRep, tolerance = item
+            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             graph = None
             edges = []
             vertices = []
@@ -2506,7 +2678,7 @@ class Graph:
                             else:
                                 vst = sharedTopology.CenterOfMass()
                             d1 = sharedTopology.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedTopology), Topology.Type(sharedTopology), Topology.TypeAsString(sharedTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -2529,7 +2701,7 @@ class Graph:
                                         vst2 = content.CenterOfMass()
                                     vst2 = topologic.Vertex.ByCoordinates(vst2.X()+(tolerance*100), vst2.Y()+(tolerance*100), vst2.Z()+(tolerance*100))
                                     d1 = content.GetDictionary()
-                                    if storeBRep:
+                                    if storeBREP:
                                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                         d3 = mergeDictionaries2([d1, d2])
                                         _ = vst2.SetDictionary(d3)
@@ -2542,14 +2714,15 @@ class Graph:
                                     edges.append(tempe)
                     if viaSharedApertures:
                         for sharedAperture in sharedApertures:
+                            sharedAp = Aperture.Topology(sharedAperture)
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(sharedAperture.Topology(), tolerance)
+                                vst = Topology.InternalVertex(sharedAp, tolerance)
                             else:
-                                vst = sharedAperture.Topology().CenterOfMass()
-                            d1 = sharedAperture.Topology().GetDictionary()
+                                vst = sharedAp.CenterOfMass()
+                            d1 = sharedAp.GetDictionary()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
-                            if storeBRep:
-                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(Aperture.Topology(sharedAperture)), Topology.Type(Aperture.Topology(sharedAperture)), Topology.TypeAsString(Aperture.Topology(sharedAperture))])
+                            if storeBREP:
+                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedAp), Topology.Type(sharedAp), Topology.TypeAsString(sharedAp)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
                             else:
@@ -2566,7 +2739,7 @@ class Graph:
                             else:
                                 vst = exteriorTopology.CenterOfMass()
                             d1 = exteriorTopology.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTopology), Topology.Type(exteriorTopology), Topology.TypeAsString(exteriorTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -2589,7 +2762,7 @@ class Graph:
                                         vst2 = content.CenterOfMass()
                                     vst2 = topologic.Vertex.ByCoordinates(vst2.X()+(tolerance*100), vst2.Y()+(tolerance*100), vst2.Z()+(tolerance*100))
                                     d1 = content.GetDictionary()
-                                    if storeBRep:
+                                    if storeBREP:
                                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                         d3 = mergeDictionaries2([d1, d2])
                                         _ = vst2.SetDictionary(d3)
@@ -2602,15 +2775,15 @@ class Graph:
                                     edges.append(tempe)
                     if toExteriorApertures:
                         for exteriorAperture in exteriorApertures:
-                            extTop = exteriorAperture.Topology()
+                            exTop = exteriorAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(extTop, tolerance)
+                                vst = Topology.InternalVertex(exTop, tolerance)
                             else:
-                                vst = exteriorAperture.Topology().CenterOfMass()
-                            d1 = exteriorAperture.Topology().GetDictionary()
+                                vst = exTop.CenterOfMass()
+                            d1 = exTop.GetDictionary()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
-                            if storeBRep:
-                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(Aperture.Topology(exteriorAperture)), Topology.Type(Aperture.Topology(exteriorAperture)), Topology.TypeAsString(Aperture.Topology(exteriorAperture))])
+                            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:
@@ -2632,7 +2805,7 @@ class Graph:
                                 vst = content.CenterOfMass()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
                             d1 = content.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -2650,7 +2823,7 @@ class Graph:
                 else:
                     vFace = aFace.CenterOfMass()
                 d1 = aFace.GetDictionary()
-                if storeBRep:
+                if storeBREP:
                     d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(aFace), Topology.Type(aFace), Topology.TypeAsString(aFace)])
                     d3 = mergeDictionaries2([d1, d2])
                     _ = vFace.SetDictionary(d3)
@@ -2680,7 +2853,7 @@ class Graph:
                         vop = Topology.CenterOfMass(outpost)
                         vcc = Topology.CenterOfMass(topology)
                     d1 = Topology.Dictionary(vcc)
-                    if storeBRep:
+                    if storeBREP:
                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(topology), Topology.Type(topology), Topology.TypeAsString(topology)])
                         d3 = mergeDictionaries2([d1, d2])
                         _ = vcc.SetDictionary(d3)
@@ -2695,7 +2868,7 @@ class Graph:
 
         def processFace(item):
             from topologicpy.Face import Face
-            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBRep, tolerance = item
+            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             graph = None
             vertices = []
             edges = []
@@ -2705,7 +2878,7 @@ class Graph:
             else:
                 vFace = topology.CenterOfMass()
             d1 = topology.GetDictionary()
-            if storeBRep:
+            if storeBREP:
                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(topology), Topology.Type(topology), Topology.TypeAsString(topology)])
                 d3 = mergeDictionaries2([d1, d2])
                 _ = vFace.SetDictionary(d3)
@@ -2755,7 +2928,7 @@ class Graph:
                             else:
                                 vst = exteriorTopology.CenterOfMass()
                             d1 = exteriorTopology.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTopology), Topology.Type(exteriorTopology), Topology.TypeAsString(exteriorTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -2778,7 +2951,7 @@ class Graph:
                                         vst2 = content.CenterOfMass()
                                     vst2 = topologic.Vertex.ByCoordinates(vst2.X()+(tolerance*100), vst2.Y()+(tolerance*100), vst2.Z()+(tolerance*100))
                                     d1 = content.GetDictionary()
-                                    if storeBRep:
+                                    if storeBREP:
                                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                         d3 = mergeDictionaries2([d1, d2])
                                         _ = vst2.SetDictionary(d3)
@@ -2791,15 +2964,15 @@ class Graph:
                                     edges.append(tempe)
                     if toExteriorApertures:
                         for exteriorAperture in exteriorApertures:
-                            extTop = exteriorAperture.Topology()
+                            exTop = exteriorAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(extTop, tolerance)
+                                vst = Topology.InternalVertex(exTop, tolerance)
                             else:
-                                vst = exteriorAperture.Topology().CenterOfMass()
-                            d1 = exteriorAperture.Topology().GetDictionary()
+                                vst = exTop.CenterOfMass()
+                            d1 = exTop.GetDictionary()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
-                            if storeBRep:
-                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(Aperture.Topology(exteriorAperture)), Topology.Type(Aperture.Topology(exteriorAperture)), Topology.TypeAsString(Aperture.Topology(exteriorAperture))])
+                            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:
@@ -2821,7 +2994,7 @@ class Graph:
                                 vst = content.CenterOfMass()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
                             d1 = content.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -2835,7 +3008,7 @@ class Graph:
             return [vertices, edges]
 
         def processWire(item):
-            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBRep, tolerance = item
+            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             graph = None
             edges = []
             vertices = []
@@ -2927,7 +3100,7 @@ class Graph:
                     except:
                         vEdge = anEdge.CenterOfMass()
                     d1 = anEdge.GetDictionary()
-                    if storeBRep:
+                    if storeBREP:
                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(anEdge), Topology.Type(anEdge), Topology.TypeAsString(anEdge)])
                         d3 = mergeDictionaries2([d1, d2])
                         _ = vEdge.SetDictionary(d3)
@@ -2961,7 +3134,7 @@ class Graph:
                         for sharedTopology in sharedTopologies:
                             vst = sharedTopology.CenterOfMass()
                             d1 = sharedTopology.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedTopology), Topology.Type(sharedTopology), Topology.TypeAsString(sharedTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -2984,7 +3157,7 @@ class Graph:
                                         vst2 = content.CenterOfMass()
                                     vst2 = topologic.Vertex.ByCoordinates(vst2.X()+(tolerance*100), vst2.Y()+(tolerance*100), vst2.Z()+(tolerance*100))
                                     d1 = content.GetDictionary()
-                                    if storeBRep:
+                                    if storeBREP:
                                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                         d3 = mergeDictionaries2([d1, d2])
                                         _ = vst2.SetDictionary(d3)
@@ -2997,15 +3170,15 @@ class Graph:
                                     edges.append(tempe)
                     if viaSharedApertures:
                         for sharedAperture in sharedApertures:
-                            sharedTop = sharedAperture.Topology()
+                            sharedAp = sharedAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(sharedTop, tolerance)
+                                vst = Topology.InternalVertex(sharedAp, tolerance)
                             else:
-                                vst = sharedTop.CenterOfMass()
-                            d1 = sharedTop.GetDictionary()
+                                vst = sharedAp.CenterOfMass()
+                            d1 = sharedAp.GetDictionary()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
-                            if storeBRep:
-                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(Aperture.Topology(sharedAperture)), Topology.Type(Aperture.Topology(sharedAperture)), Topology.TypeAsString(Aperture.Topology(sharedAperture))])
+                            if storeBREP:
+                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedAp), Topology.Type(sharedAp), Topology.TypeAsString(sharedAp)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
                             else:
@@ -3035,7 +3208,7 @@ class Graph:
                                         vst2 = content.CenterOfMass()
                                     vst2 = topologic.Vertex.ByCoordinates(vst2.X()+(tolerance*100), vst2.Y()+(tolerance*100), vst2.Z()+(tolerance*100))
                                     d1 = content.GetDictionary()
-                                    if storeBRep:
+                                    if storeBREP:
                                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                         d3 = mergeDictionaries2([d1, d2])
                                         _ = vst2.SetDictionary(d3)
@@ -3048,15 +3221,15 @@ class Graph:
                                     edges.append(tempe)
                     if toExteriorApertures:
                         for exteriorAperture in exteriorApertures:
-                            extTop = exteriorAperture.Topology()
+                            exTop = exteriorAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(extTop, tolerance)
+                                vst = Topology.InternalVertex(exTop, tolerance)
                             else:
-                                vst = extTop.CenterOfMass()
-                            d1 = extTop.GetDictionary()
+                                vst = exTop.CenterOfMass()
+                            d1 = exTop.GetDictionary()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
-                            if storeBRep:
-                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(extTop), Topology.Type(extTop), Topology.TypeAsString(extTop)])
+                            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:
@@ -3078,7 +3251,7 @@ class Graph:
                                 vst = content.CenterOfMass()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
                             d1 = content.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -3095,7 +3268,7 @@ class Graph:
                 except:
                     vEdge = anEdge.CenterOfMass()
                 d1 = anEdge.GetDictionary()
-                if storeBRep:
+                if storeBREP:
                     d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(anEdge), Topology.Type(anEdge), Topology.TypeAsString(anEdge)])
                     d3 = mergeDictionaries2([d1, d2])
                     _ = vEdge.SetDictionary(d3)
@@ -3126,7 +3299,7 @@ class Graph:
                         vop = Topology.CenterOfMass(outpost)
                         vcc = Topology.CenterOfMass(topology)
                     d1 = Topology.Dictionary(vcc)
-                    if storeBRep:
+                    if storeBREP:
                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(topology), Topology.Type(topology), Topology.TypeAsString(topology)])
                         d3 = mergeDictionaries2([d1, d2])
                         _ = vcc.SetDictionary(d3)
@@ -3141,7 +3314,7 @@ class Graph:
             return [vertices, edges]
 
         def processEdge(item):
-            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBRep, tolerance = item
+            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             graph = None
             vertices = []
             edges = []
@@ -3155,7 +3328,7 @@ class Graph:
                 vEdge = topology.CenterOfMass()
 
             d1 = vEdge.GetDictionary()
-            if storeBRep:
+            if storeBREP:
                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(topology), Topology.Type(topology), Topology.TypeAsString(topology)])
                 d3 = mergeDictionaries2([d1, d2])
                 _ = vEdge.SetDictionary(d3)
@@ -3207,7 +3380,7 @@ class Graph:
                             else:
                                 vst = exteriorTopology.CenterOfMass()
                             d1 = exteriorTopology.GetDictionary()
-                            if storeBRep:
+                            if storeBREP:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTopology), Topology.Type(exteriorTopology), Topology.TypeAsString(exteriorTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
                                 _ = vst.SetDictionary(d3)
@@ -3230,7 +3403,7 @@ class Graph:
                                         vst2 = content.CenterOfMass()
                                     vst2 = topologic.Vertex.ByCoordinates(vst2.X()+(tolerance*100), vst2.Y()+(tolerance*100), vst2.Z()+(tolerance*100))
                                     d1 = content.GetDictionary()
-                                    if storeBRep:
+                                    if storeBREP:
                                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                         d3 = mergeDictionaries2([d1, d2])
                                         _ = vst2.SetDictionary(d3)
@@ -3243,20 +3416,20 @@ class Graph:
                                     edges.append(tempe)
                     if toExteriorApertures:
                         for exteriorAperture in exteriorApertures:
-                            extTop = exteriorAperture.Topology()
+                            exTop = exteriorAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(extTop, tolerance)
+                                vst = Topology.InternalVertex(exTop, tolerance)
                             else:
-                                vst = exteriorAperture.Topology().CenterOfMass()
-                            d1 = exteriorAperture.Topology().GetDictionary()
+                                vst = exTop.CenterOfMass()
+                            d1 = exTop.GetDictionary()
                             vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
-                            if storeBRep:
-                                d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(Aperture.Topology(exteriorAperture)), Topology.Type(Aperture.Topology(exteriorAperture)), Topology.TypeAsString(Aperture.Topology(exteriorAperture))])
+                            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(exteriorAperture.Topology().GetDictionary())
+                            _ = vst.SetDictionary(exTop.GetDictionary())
                             vertices.append(vst)
                             tempe = Edge.ByStartVertexEndVertex(vEdge, vst, tolerance=tolerance)
                             tempd = Dictionary.ByKeysValues(["relationship"],["To Exterior Apertures"])
@@ -3266,7 +3439,7 @@ class Graph:
             return [vertices, edges]
 
         def processVertex(item):
-            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBRep, tolerance = item
+            topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             vertices = [topology]
             edges = []
 
@@ -3282,7 +3455,7 @@ class Graph:
                         vst = content.CenterOfMass()
                     d1 = content.GetDictionary()
                     vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
-                    if storeBRep:
+                    if storeBREP:
                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                         d3 = mergeDictionaries2([d1, d2])
                         _ = vst.SetDictionary(d3)
@@ -3326,7 +3499,7 @@ class Graph:
             print("Graph.ByTopology - Error: The input topology is not a valid topology. Returning None.")
             return None
         graph = None
-        item = [topology, None, None, None, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, None, useInternalVertex, storeBRep, tolerance]
+        item = [topology, None, None, None, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, None, useInternalVertex, storeBREP, tolerance]
         vertices = []
         edges = []
         if isinstance(topology, topologic.CellComplex):
@@ -3352,7 +3525,7 @@ class Graph:
             c_edges = Cluster.FreeEdges(topology, tolerance=tolerance)
             c_vertices = Cluster.FreeVertices(topology, tolerance=tolerance)
             others = c_cellComplexes+c_cells+c_shells+c_faces+c_wires+c_edges+c_vertices
-            parameters = [others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBRep, tolerance]
+            parameters = [others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance]
 
             for t in c_cellComplexes:
                 v, e = processCellComplex([t]+parameters)
@@ -4102,6 +4275,7 @@ class Graph:
                     bidirectional=False,
                     includeAttributes=False,
                     includeLabel=False,
+                    includeGeometry=False,
                     siteLabel = "Site_0001",
                     siteDictionary = None,
                     buildingLabel = "Building_0001",
@@ -4110,11 +4284,7 @@ class Graph:
                     floorLevels =[],
                     labelKey="label",
                     typeKey="type",
-                    sourceKey="source",
-                    targetKey="target",
-                    xKey = "x",
-                    yKey = "y",
-                    zKey = "z",
+                    geometryKey="brep",
                     spaceType = "space",
                     wallType = "wall",
                     slabType = "slab",
@@ -4150,6 +4320,8 @@ class Graph:
             If set to True, the attributes associated with vertices in the graph are written out. Otherwise, they are not. The default is False.
         includeLabel : bool , optional
             If set to True, a label is attached to each node. Otherwise, it is not. The default is False.
+        includeGeometry : bool , optional
+            If set to True, the geometry associated with vertices in the graph are written out. Otherwise, it is not. The default is False.
         siteLabel : str , optional
             The desired site label. The default is "Site_0001".
         siteDictionary : dict , optional
@@ -4167,16 +4339,8 @@ class Graph:
             The dictionary key to use to look up the type of the node. The default is "type".
         labelKey : str , optional
             The dictionary key to use to look up the label of the node. The default is "label".
-        sourceKey : str , optional
-            The desired dictionary key to use to store the source vertex. The default is "source".
-        targetKey : str , optional
-            The desired dictionary key to use to store the target vertex. The default is "target".
-        xKey : str , optional
-            The dictionary key to use to look up the x-coordinate of the node. The default is "x".
-        yKey : str , optional
-            The dictionary key to use to look up the y-coordinate of the node. The default is "y".
-        zKey : str , optional
-            The dictionary key to use to look up the z-coordinate of the node. The default is "z".
+        geometryKey : str , optional
+            The dictionary key to use to look up the label of the node. The default is "brep".
         spaceType : str , optional
             The dictionary string value to use to look up nodes of type "space". The default is "space".
         wallType : str , optional
@@ -4210,6 +4374,7 @@ class Graph:
                             bidirectional=bidirectional,
                             includeAttributes=includeAttributes,
                             includeLabel=includeLabel,
+                            includeGeometry=includeGeometry,
                             siteLabel=siteLabel,
                             siteDictionary=siteDictionary,
                             buildingLabel=buildingLabel,
@@ -4218,11 +4383,7 @@ class Graph:
                             floorLevels=floorLevels,
                             labelKey=labelKey,
                             typeKey=typeKey,
-                            sourceKey=sourceKey,
-                            targetKey=targetKey,
-                            xKey=xKey,
-                            yKey=yKey,
-                            zKey=zKey,
+                            geometryKey=geometryKey,
                             spaceType = spaceType,
                             wallType = wallType,
                             slabType = slabType,
@@ -4975,7 +5136,7 @@ class Graph:
         return True
 
     @staticmethod
-    def ExportToJSON(graph, path, vertexLabelKey="", edgeLabelKey="", indent=4, sortKeys=False, mantissa=6, overwrite=False):
+    def ExportToJSON(graph, path, verticesKey="vertices", edgesKey="edges", vertexLabelKey="", edgeLabelKey="", xKey="x", yKey="y", zKey="z", indent=4, sortKeys=False, mantissa=6, overwrite=False):
         """
         Exports the input graph to a JSON file.
 
@@ -4985,12 +5146,22 @@ class Graph:
             The input graph.
         path : str
             The path to the JSON file.
+        verticesKey : str , optional
+            The desired key name to call vertices. The default is "vertices".
+        edgesKey : str , optional
+            The desired key name to call edges. The default is "edges".
         vertexLabelKey : str , optional
             If set to a valid string, the vertex label will be set to the value at this key. Otherwise it will be set to Vertex_XXXX where XXXX is a sequential unique number.
             Note: If vertex labels are not unique, they will be forced to be unique.
         edgeLabelKey : str , optional
             If set to a valid string, the edge label will be set to the value at this key. Otherwise it will be set to Edge_XXXX where XXXX is a sequential unique number.
             Note: If edge labels are not unique, they will be forced to be unique.
+        xKey : str , optional
+            The desired key name to use for x-coordinates. The default is "x".
+        yKey : str , optional
+            The desired key name to use for y-coordinates. The default is "y".
+        zKey : str , optional
+            The desired key name to use for z-coordinates. The default is "z".
         indent : int , optional
             The desired amount of indent spaces to use. The default is 4.
         sortKeys : bool , optional
@@ -5024,7 +5195,7 @@ class Graph:
         except:
             raise Exception("Graph.ExportToJSON - Error: Could not create a new file at the following location: "+path)
         if (f):
-            jsondata = Graph.JSONData(graph, vertexLabelKey=vertexLabelKey, edgeLabelKey=edgeLabelKey, mantissa=mantissa)
+            jsondata = Graph.JSONData(graph, verticesKey=verticesKey, edgesKey=edgesKey, vertexLabelKey=vertexLabelKey, edgeLabelKey=edgeLabelKey, xKey=xKey, yKey=yKey, zKey=zKey, mantissa=mantissa)
             if jsondata != None:
                 json.dump(jsondata, f, indent=indent, sort_keys=sortKeys)
                 f.close()
@@ -5679,7 +5850,18 @@ class Graph:
         return vertices
     
     @staticmethod
-    def JSONData(graph, vertexLabelKey="", edgeLabelKey="", sourceKey="source", targetKey="target", mantissa=6):
+    def JSONData(graph,
+                 verticesKey="vertices",
+                 edgesKey="edges",
+                 vertexLabelKey="",
+                 edgeLabelKey="",
+                 sourceKey="source",
+                 targetKey="target",
+                 xKey="x",
+                 yKey="y",
+                 zKey="z",
+                 geometryKey="brep",
+                 mantissa=6):
         """
         Converts the input graph into JSON data.
 
@@ -5687,6 +5869,10 @@ class Graph:
         ----------
         graph : topologic.Graph
             The input graph.
+        verticesKey : str , optional
+            The desired key name to call vertices. The default is "vertices".
+        edgesKey : str , optional
+            The desired key name to call edges. The default is "edges".
         vertexLabelKey : str , optional
             If set to a valid string, the vertex label will be set to the value at this key. Otherwise it will be set to Vertex_XXXX where XXXX is a sequential unique number.
             Note: If vertex labels are not unique, they will be forced to be unique.
@@ -5697,6 +5883,14 @@ class Graph:
             The dictionary key used to store the source vertex. The default is "source".
         targetKey : str , optional
             The dictionary key used to store the target vertex. The default is "source".
+        xKey : str , optional
+            The desired key name to use for x-coordinates. The default is "x".
+        yKey : str , optional
+            The desired key name to use for y-coordinates. The default is "y".
+        zKey : str , optional
+            The desired key name to use for z-coordinates. The default is "z".
+        geometryKey : str , optional
+            The desired key name to use for geometry. The default is "brep".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
 
@@ -5714,16 +5908,21 @@ class Graph:
 
         vertices = Graph.Vertices(graph)
         j_data = {}
-        j_data['nodes'] = {}
-        j_data['edges'] = {}
+        j_data[verticesKey] = {}
+        j_data[edgesKey] = {}
         n = max(len(str(len(vertices))), 4)
         v_labels = []
         v_dicts = []
         for i, v in enumerate(vertices):
             d = Topology.Dictionary(v)
-            d = Dictionary.SetValueAtKey(d, "x", Vertex.X(v, mantissa=mantissa))
-            d = Dictionary.SetValueAtKey(d, "y", Vertex.Y(v, mantissa=mantissa))
-            d = Dictionary.SetValueAtKey(d, "z", Vertex.Z(v, mantissa=mantissa))
+            d = Dictionary.SetValueAtKey(d, xKey, Vertex.X(v, mantissa=mantissa))
+            d = Dictionary.SetValueAtKey(d, yKey, Vertex.Y(v, mantissa=mantissa))
+            d = Dictionary.SetValueAtKey(d, zKey, Vertex.Z(v, mantissa=mantissa))
+            if geometryKey:
+                v_d = Topology.Dictionary(v)
+                brep = Dictionary.ValueAtKey(v_d,"brep")
+                if brep:
+                    d = Dictionary.SetValueAtKey(d, geometryKey, brep)
             v_dict = Dictionary.PythonDictionary(d)
             v_label = Dictionary.ValueAtKey(d, vertexLabelKey)
             if isinstance(v_label, str):
@@ -5734,7 +5933,7 @@ class Graph:
             v_dicts.append(v_dict)
         v_labels = Helper.MakeUnique(v_labels)
         for i, v_label in enumerate(v_labels):
-            j_data['nodes'][v_label] = v_dicts[i]
+            j_data[verticesKey][v_label] = v_dicts[i]
 
         edges = Graph.Edges(graph)
         n = len(str(len(edges)))    
@@ -5761,12 +5960,22 @@ class Graph:
             e_dicts.append(e_dict)
         e_labels = Helper.MakeUnique(e_labels)
         for i, e_label in enumerate(e_labels):
-            j_data['edges'][e_label] = e_dicts[i]
+            j_data[edgesKey][e_label] = e_dicts[i]
 
         return j_data
     
     @staticmethod
-    def JSONString(graph, vertexLabelKey="", edgeLabelKey="", indent=4, sortKeys=False, mantissa=6):
+    def JSONString(graph,
+                   verticesKey="vertices",
+                   edgesKey="edges",
+                   vertexLabelKey="",
+                   edgeLabelKey="",
+                   xKey = "x",
+                   yKey = "y",
+                   zKey = "z",
+                   indent=4,
+                   sortKeys=False,
+                   mantissa=6):
         """
         Converts the input graph into JSON data.
 
@@ -5774,12 +5983,22 @@ class Graph:
         ----------
         graph : topologic.Graph
             The input graph.
+        verticesKey : str , optional
+            The desired key name to call vertices. The default is "vertices".
+        edgesKey : str , optional
+            The desired key name to call edges. The default is "edges".
         vertexLabelKey : str , optional
             If set to a valid string, the vertex label will be set to the value at this key. Otherwise it will be set to Vertex_XXXX where XXXX is a sequential unique number.
             Note: If vertex labels are not unique, they will be forced to be unique.
         edgeLabelKey : str , optional
             If set to a valid string, the edge label will be set to the value at this key. Otherwise it will be set to Edge_XXXX where XXXX is a sequential unique number.
             Note: If edge labels are not unique, they will be forced to be unique.
+        xKey : str , optional
+            The desired key name to use for x-coordinates. The default is "x".
+        yKey : str , optional
+            The desired key name to use for y-coordinates. The default is "y".
+        zKey : str , optional
+            The desired key name to use for z-coordinates. The default is "z".
         indent : int , optional
             The desired amount of indent spaces to use. The default is 4.
         sortKeys : bool , optional
@@ -5794,7 +6013,7 @@ class Graph:
 
         """
         import json
-        json_data = Graph.JSONData(graph, vertexLabelKey=vertexLabelKey, edgeLabelKey=edgeLabelKey, mantissa=mantissa)
+        json_data = Graph.JSONData(graph, verticesKey=verticesKey, edgesKey=edgesKey, vertexLabelKey=vertexLabelKey, edgeLabelKey=edgeLabelKey, xKey=xKey, yKey=yKey, zKey=zKey, mantissa=mantissa)
         json_string = json.dumps(json_data, indent=indent, sort_keys=sortKeys)
         return json_string
     
@@ -7351,7 +7570,7 @@ class Graph:
         return degree
     
     @staticmethod
-    def Vertices(graph):
+    def Vertices(graph, vertexKey=None, reverse=False):
         """
         Returns the list of vertices in the input graph.
 
@@ -7359,13 +7578,19 @@ class Graph:
         ----------
         graph : topologic.Graph
             The input graph.
-
+        vertexKey : str , optional
+            If set, the returned list of vertices is sorted according to the dicitonary values stored under this key. The default is None.
+        reverse : bool , optional
+            If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. The default is False.
         Returns
         -------
         list
             The list of vertices in the input graph.
 
         """
+
+        from topologicpy.Helper import Helper
+
         if not isinstance(graph, topologic.Graph):
             print("Graph.Vertices - Error: The input graph is not a valid graph. Returning None.")
             return None
@@ -7375,6 +7600,15 @@ class Graph:
                 _ = graph.Vertices(vertices)
             except:
                 vertices = []
+        if not vertexKey == None:
+            sorting_values = []
+            for v in vertices:
+                d = Topology.Dictionary(v)
+                value = Dictionary.ValueAtKey(d, vertexKey)
+                sorting_values.append(value)
+            vertices = Helper.Sort(vertices, sorting_values)
+            if reverse == True:
+                vertices.reverse()
         return vertices
 
     @staticmethod