topologicpy 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

topologicpy/Graph.py

@@ -527,6 +527,329 @@ class Graph:
         lcc = Graph.LocalClusteringCoefficient(graph, vertices)
         acc = round(sum(lcc)/float(len(lcc)), mantissa)
         return acc
+    
+    @staticmethod
+    def BOTGraph(graph,
+                bidirectional=False,
+                includeAttributes=False,
+                includeLabel=False,
+                siteLabel = "Site_0001",
+                siteDictionary = None,
+                buildingLabel = "Building_0001",
+                buildingDictionary = None , 
+                storeyPrefix = "Storey",
+                floorLevels =[],
+                labelKey="label",
+                typeKey="type",
+                spaceType = "space",
+                wallType = "wall",
+                slabType = "slab",
+                doorType = "door",
+                windowType = "window",
+                contentType = "content"
+                ):
+        """
+        Creates an RDF graph according to the BOT ontology. See https://w3c-lbd-cg.github.io/bot/.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        bidirectional : bool , optional
+            If set to True, reverse relationships are created wherever possible. Otherwise, they are not. The default is False.
+        includeAttributes : bool , optional
+            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.
+        siteLabel : str , optional
+            The desired site label. The default is "Site_0001".
+        siteDictionary : dict , optional
+            The dictionary of site attributes to include in the output. The default is None.
+        buildingLabel : str , optional
+            The desired building label. The default is "Building_0001".
+        buildingDictionary : dict , optional
+            The dictionary of building attributes to include in the output. The default is None.
+        storeyPrefix : str , optional
+            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 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".
+        spaceType : str , optional
+            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 vertices of type "wall". The default is "wall".
+        slabType : str , optional
+            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 vertices of type "door". The default is "door".
+        windowType : str , optional
+            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 vertices of type "content". The default is "contents".
+
+        Returns
+        -------
+        rdflib.graph.Graph
+            The rdf graph using the BOT ontology.
+        """
+
+        from topologicpy.Helper import Helper
+        import os
+        import warnings
+        
+        try:
+            from rdflib import Graph as RDFGraph
+            from rdflib import URIRef, Literal, Namespace
+            from rdflib.namespace import RDF, RDFS
+        except:
+            print("Graph.BOTGraph - Installing required rdflib library.")
+            try:
+                os.system("pip install rdflib")
+            except:
+                os.system("pip install rdflib --user")
+            try:
+                from rdflib import Graph as RDFGraph
+                from rdflib import URIRef, Literal, Namespace
+                from rdflib.namespace import RDF, RDFS
+                print("Graph.BOTGraph - rdflib library installed correctly.")
+            except:
+                warnings.warn("Graph.BOTGraph - Error: Could not import rdflib. Please try to install rdflib manually. Returning None.")
+                return None
+        
+        if floorLevels == None:
+            floorLevels = []
+        json_data = Graph.JSONData(graph, vertexLabelKey=labelKey)
+        # Create an empty RDF graph
+        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
+        bot_graph.namespace_manager.bind("bot", bot)
+        
+        # Add site
+        site_uri = URIRef(siteLabel)
+        bot_graph.add((site_uri, rdf.type, bot.Site))
+        if includeLabel:
+            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 not (key == labelKey) and not (key == typeKey):
+                    bot_graph.add((site_uri, bot[key], Literal(value)))
+        # Add building
+        building_uri = URIRef(buildingLabel)
+        bot_graph.add((building_uri, rdf.type, bot.Building))
+        if includeLabel:
+            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:
+                        bot_graph.add((building_uri, RDFS.label, Literal(value)))
+                    elif key != typeKey:
+                        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['vertices'].items():
+                if slabType.lower() in attributes[typeKey].lower():
+                    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))
+            bot_graph.add((storey_uri, rdf.type, bot.Storey))
+            if includeLabel:
+                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
+        bot_graph.add((site_uri, bot.hasBuilding, building_uri))
+        if bidirectional:
+            bot_graph.add((building_uri, bot.isPartOf, site_uri)) # might not be needed
+
+        for storey_uri in storey_uris:
+            bot_graph.add((building_uri, bot.hasStorey, storey_uri))
+            if bidirectional:
+                bot_graph.add((storey_uri, bot.isPartOf, building_uri)) # might not be needed
+        
+        # Add vertices as RDF resources
+        for node, attributes in json_data['vertices'].items():
+            node_uri = URIRef(node)
+            if spaceType.lower() in attributes[typeKey].lower():
+                bot_graph.add((node_uri, rdf.type, bot.Space))
+                # Find the storey it is on
+                z = attributes["z"]
+                level = Helper.Position(z, floorLevels)
+                if level > len(storey_uris):
+                    level = len(storey_uris)
+                storey_uri = storey_uris[level-1]
+                bot_graph.add((storey_uri, bot.hasSpace, node_uri))
+                if bidirectional:
+                    bot_graph.add((node_uri, bot.isPartOf, storey_uri)) # might not be needed
+            elif windowType.lower() in attributes[typeKey].lower():
+                bot_graph.add((node_uri, rdf.type, bot.Window))
+            elif doorType.lower() in attributes[typeKey].lower():
+                bot_graph.add((node_uri, rdf.type, bot.Door))
+            elif wallType.lower() in attributes[typeKey].lower():
+                bot_graph.add((node_uri, rdf.type, bot.Wall))
+            elif slabType.lower() in attributes[typeKey].lower():
+                bot_graph.add((node_uri, rdf.type, bot.Slab))
+            else:
+                bot_graph.add((node_uri, rdf.type, bot.Element))
+            
+            if includeAttributes:
+                for key, value in attributes.items():
+                    if key == labelKey:
+                        if includeLabel:
+                            bot_graph.add((node_uri, RDFS.label, Literal(value)))
+                    elif key != typeKey:
+                        bot_graph.add((node_uri, bot[key], Literal(value)))
+            if includeLabel:
+                for key, value in attributes.items():
+                    if key == labelKey:
+                        bot_graph.add((node_uri, RDFS.label, Literal(value)))
+        
+        # Add edges as RDF triples
+        for edge, attributes in json_data['edges'].items():
+            source = attributes["source"]
+            target = attributes["target"]
+            source_uri = URIRef(source)
+            target_uri = URIRef(target)
+            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:
+                    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:
+                    bot_graph.add((target_uri, bot.isPartOf, source_uri))
+            else:
+                bot_graph.add((source_uri, bot.connectsTo, target_uri))
+                if bidirectional:
+                    bot_graph.add((target_uri, bot.connectsTo, source_uri))
+        return bot_graph
+
+    @staticmethod
+    def BOTString(graph,
+                format="turtle",
+                bidirectional=False,
+                includeAttributes=False,
+                includeLabel=False,
+                siteLabel = "Site_0001",
+                siteDictionary = None,
+                buildingLabel = "Building_0001",
+                buildingDictionary = None , 
+                storeyPrefix = "Storey",
+                floorLevels =[],
+                labelKey="label",
+                typeKey="type",
+                spaceType = "space",
+                wallType = "wall",
+                slabType = "slab",
+                doorType = "door",
+                windowType = "window",
+                contentType = "content",
+                ):
+        
+        """
+        Returns an RDF graph serialized string according to the BOT ontology. See https://w3c-lbd-cg.github.io/bot/.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        format : str , optional
+            The desired output format, the options are listed below. Thde default is "turtle".
+            turtle, ttl or turtle2 : Turtle, turtle2 is just turtle with more spacing & linebreaks
+            xml or pretty-xml : RDF/XML, Was the default format, rdflib < 6.0.0
+            json-ld : JSON-LD , There are further options for compact syntax and other JSON-LD variants
+            ntriples, nt or nt11 : N-Triples , nt11 is exactly like nt, only utf8 encoded
+            n3 : Notation-3 , N3 is a superset of Turtle that also caters for rules and a few other things
+            trig : Trig , Turtle-like format for RDF triples + context (RDF quads) and thus multiple graphs
+            trix : Trix , RDF/XML-like format for RDF quads
+            nquads : N-Quads , N-Triples-like format for RDF quads
+        bidirectional : bool , optional
+            If set to True, reverse relationships are created wherever possible. Otherwise, they are not. The default is False.
+        includeAttributes : bool , optional
+            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.
+        siteLabel : str , optional
+            The desired site label. The default is "Site_0001".
+        siteDictionary : dict , optional
+            The dictionary of site attributes to include in the output. The default is None.
+        buildingLabel : str , optional
+            The desired building label. The default is "Building_0001".
+        buildingDictionary : dict , optional
+            The dictionary of building attributes to include in the output. The default is None.
+        storeyPrefix : str , optional
+            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 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".
+        spaceType : str , optional
+            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 vertices of type "wall". The default is "wall".
+        slabType : str , optional
+            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 vertices of type "door". The default is "door".
+        windowType : str , optional
+            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 vertices of type "content". The default is "contents".
+
+        
+        Returns
+        -------
+        str
+            The rdf graph serialized string using the BOT ontology.
+        """
+        
+        bot_graph = Graph.BOTGraph(graph,
+                            bidirectional=bidirectional,
+                            includeAttributes=includeAttributes,
+                            includeLabel=includeLabel,
+                            siteLabel=siteLabel,
+                            siteDictionary=siteDictionary,
+                            buildingLabel=buildingLabel,
+                            buildingDictionary=buildingDictionary, 
+                            storeyPrefix=storeyPrefix,
+                            floorLevels=floorLevels,
+                            labelKey=labelKey,
+                            typeKey=typeKey,
+                            spaceType = spaceType,
+                            wallType = wallType,
+                            slabType = slabType,
+                            doorType = doorType,
+                            windowType = windowType,
+                            contentType = contentType
+                            )
+        return bot_graph.serialize(format=format)
 
     @staticmethod
     def BetweenessCentrality(graph, vertices=None, sources=None, destinations=None, tolerance=0.001):
@@ -1469,6 +1792,7 @@ class Graph:
         from topologicpy.Edge import Edge
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
+        from topologicpy.Aperture import Aperture
 
         def mergeDictionaries(sources):
             if isinstance(sources, list) == False:
@@ -1687,7 +2011,7 @@ class Graph:
 
             cells = []
             _ = topology.Cells(None, cells)
-            if (viaSharedTopologies == True) or (viaSharedApertures == True) or (toExteriorTopologies == True) or (toExteriorApertures == True) or (toContents == True):
+            if any([viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents]):
                 for aCell in cells:
                     if useInternalVertex == True:
                         vCell = Topology.InternalVertex(aCell, tolerance=tolerance)
@@ -1710,9 +2034,9 @@ class Graph:
                     contents = []
                     _ = aCell.Contents(contents)
                     for aFace in faces:
-                        cells = []
-                        _ = aFace.Cells(topology, cells)
-                        if len(cells) > 1:
+                        cells1 = []
+                        _ = aFace.Cells(topology, cells1)
+                        if len(cells1) > 1:
                             sharedTopologies.append(aFace)
                             apertures = []
                             _ = aFace.Apertures(apertures)
@@ -1724,6 +2048,7 @@ class Graph:
                             _ = aFace.Apertures(apertures)
                             for anAperture in apertures:
                                 exteriorApertures.append(anAperture)
+
                     if viaSharedTopologies:
                         for sharedTopology in sharedTopologies:
                             if useInternalVertex == True:
@@ -1746,6 +2071,8 @@ class Graph:
                                 contents = []
                                 _ = sharedTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -1767,38 +2094,38 @@ class Graph:
                         for sharedAperture in sharedApertures:
                             sharedAp = sharedAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(sharedAp, tolerance)
+                                vsa = Topology.InternalVertex(sharedAp, tolerance)
                             else:
-                                vst = sharedAp.CenterOfMass()
+                                vsa = sharedAp.CenterOfMass()
                             d1 = sharedAp.GetDictionary()
-                            vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
+                            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)])
                                 d3 = mergeDictionaries2([d1, d2])
-                                _ = vst.SetDictionary(d3)
+                                _ = vsa.SetDictionary(d3)
                             else:
-                                _ = vst.SetDictionary(d1)
-                            vertices.append(vst)
-                            tempe = Edge.ByStartVertexEndVertex(vCell, vst, tolerance=tolerance)
+                                _ = vsa.SetDictionary(d1)
+                            vertices.append(vsa)
+                            tempe = Edge.ByStartVertexEndVertex(vCell, vsa, tolerance=tolerance)
                             tempd = Dictionary.ByKeysValues(["relationship"],["Via Shared Apertures"])
                             _ = tempe.SetDictionary(tempd)
                             edges.append(tempe)
                     if toExteriorTopologies:
                         for exteriorTopology in exteriorTopologies:
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(exteriorTopology, tolerance)
+                                vet = Topology.InternalVertex(exteriorTopology, tolerance)
                             else:
-                                vst = exteriorTopology.CenterOfMass()
-                            _ = vst.SetDictionary(exteriorTopology.GetDictionary())
+                                vet = exteriorTopology.CenterOfMass()
+                            _ = vet.SetDictionary(exteriorTopology.GetDictionary())
                             d1 = exteriorTopology.GetDictionary()
                             if storeBRep:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTopology), Topology.Type(exteriorTopology), Topology.TypeAsString(exteriorTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
-                                _ = vst.SetDictionary(d3)
+                                _ = vet.SetDictionary(d3)
                             else:
-                                _ = vst.SetDictionary(d1)
-                            vertices.append(vst)
-                            tempe = Edge.ByStartVertexEndVertex(vCell, vst, tolerance=tolerance)
+                                _ = vet.SetDictionary(d1)
+                            vertices.append(vet)
+                            tempe = Edge.ByStartVertexEndVertex(vCell, vet, tolerance=tolerance)
                             tempd = Dictionary.ByKeysValues(["relationship"],["To Exterior Topologies"])
                             _ = tempe.SetDictionary(tempd)
                             edges.append(tempe)
@@ -1806,6 +2133,8 @@ class Graph:
                                 contents = []
                                 _ = exteriorTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -1819,7 +2148,7 @@ class Graph:
                                     else:
                                         _ = vst2.SetDictionary(d1)
                                     vertices.append(vst2)
-                                    tempe = Edge.ByStartVertexEndVertex(vst, vst2, tolerance=tolerance)
+                                    tempe = Edge.ByStartVertexEndVertex(vet, vst2, tolerance=tolerance)
                                     tempd = Dictionary.ByKeysValues(["relationship"],["To Contents"])
                                     _ = tempe.SetDictionary(tempd)
                                     edges.append(tempe)
@@ -1827,19 +2156,19 @@ class Graph:
                         for exteriorAperture in exteriorApertures:
                             extTop = exteriorAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(extTop, tolerance)
+                                vea = Topology.InternalVertex(extTop, tolerance)
                             else:
-                                vst = exteriorAperture.Topology().CenterOfMass()
+                                vea = exteriorAperture.Topology().CenterOfMass()
                             d1 = exteriorAperture.Topology().GetDictionary()
-                            vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
+                            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)])
                                 d3 = mergeDictionaries2([d1, d2])
-                                _ = vst.SetDictionary(d3)
+                                _ = vea.SetDictionary(d3)
                             else:
-                                _ = vst.SetDictionary(d1)
-                            vertices.append(vst)
-                            tempe = Edge.ByStartVertexEndVertex(vCell, vst, tolerance=tolerance)
+                                _ = vea.SetDictionary(d1)
+                            vertices.append(vea)
+                            tempe = Edge.ByStartVertexEndVertex(vCell, vea, tolerance=tolerance)
                             tempd = Dictionary.ByKeysValues(["relationship"],["To Exterior Apertures"])
                             _ = tempe.SetDictionary(tempd)
                             edges.append(tempe)
@@ -1847,20 +2176,22 @@ class Graph:
                         contents = []
                         _ = aCell.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(content, tolerance)
+                                vcn = Topology.InternalVertex(content, tolerance)
                             else:
-                                vst = content.CenterOfMass()
-                            vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
+                                vcn = content.CenterOfMass()
+                            vcn = topologic.Vertex.ByCoordinates(vcn.X()+(tolerance*100), vcn.Y()+(tolerance*100), vcn.Z()+(tolerance*100))
                             d1 = content.GetDictionary()
                             if storeBRep:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                 d3 = mergeDictionaries2([d1, d2])
-                                _ = vst.SetDictionary(d3)
+                                _ = vcn.SetDictionary(d3)
                             else:
-                                _ = vst.SetDictionary(d1)
-                            vertices.append(vst)
-                            tempe = Edge.ByStartVertexEndVertex(vCell, vst, tolerance=tolerance)
+                                _ = vcn.SetDictionary(d1)
+                            vertices.append(vcn)
+                            tempe = Edge.ByStartVertexEndVertex(vCell, vcn, tolerance=tolerance)
                             tempd = Dictionary.ByKeysValues(["relationship"],["To Contents"])
                             _ = tempe.SetDictionary(tempd)
                             edges.append(tempe)
@@ -1885,7 +2216,7 @@ class Graph:
             vertices = []
             edges = []
             if useInternalVertex == True:
-                vCell = Topology.InternalVertex(Topology.Copy(topology), tolerance=tolerance)
+                vCell = Topology.InternalVertex(topology, tolerance=tolerance)
             else:
                 vCell = topology.CenterOfMass()
             d1 = topology.GetDictionary()
@@ -1920,7 +2251,7 @@ class Graph:
                     tempd = Dictionary.ByKeysValues(["relationship"],["To Outposts"])
                     _ = tempe.SetDictionary(tempd)
                     edges.append(tempe)
-            if (toExteriorTopologies == True) or (toExteriorApertures == True) or (toContents == True):
+            if any([toExteriorTopologies, toExteriorApertures, toContents]):
                 faces = Topology.Faces(topology)
                 exteriorTopologies = []
                 exteriorApertures = []
@@ -1951,6 +2282,8 @@ class Graph:
                                 contents = []
                                 _ = exteriorTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -1992,6 +2325,8 @@ class Graph:
                         contents = []
                         _ = topology.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
                                 vst = Topology.InternalVertex(content, tolerance)
                             else:
@@ -2094,7 +2429,7 @@ class Graph:
 
             topFaces = []
             _ = topology.Faces(None, topFaces)
-            if (viaSharedTopologies == True) or (viaSharedApertures == True) or (toExteriorTopologies == True) or (toExteriorApertures == True) or (toContents == True):
+            if any([viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents == True]):
                 for aFace in topFaces:
                     if useInternalVertex == True:
                         vFace = Topology.InternalVertex(aFace, tolerance=tolerance)
@@ -2145,6 +2480,8 @@ class Graph:
                                 contents = []
                                 _ = sharedTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2203,6 +2540,8 @@ class Graph:
                                 contents = []
                                 _ = exteriorTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2244,6 +2583,8 @@ class Graph:
                         contents = []
                         _ = aFace.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
                                 vst = Topology.InternalVertex(content, tolerance)
                             else:
@@ -2388,6 +2729,8 @@ class Graph:
                                 contents = []
                                 _ = exteriorTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2429,6 +2772,8 @@ class Graph:
                         contents = []
                         _ = topology.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
                                 vst = Topology.InternalVertex(content, tolerance)
                             else:
@@ -2590,6 +2935,8 @@ class Graph:
                                 contents = []
                                 _ = sharedTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2639,6 +2986,8 @@ class Graph:
                                 contents = []
                                 _ = vst.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2680,6 +3029,8 @@ class Graph:
                         contents = []
                         _ = anEdge.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
                                 vst = Topology.InternalVertex(content, tolerance)
                             else:
@@ -2830,6 +3181,8 @@ class Graph:
                                 contents = []
                                 _ = vst.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2880,6 +3233,8 @@ class Graph:
                 contents = []
                 _ = topology.Contents(contents)
                 for content in contents:
+                    if isinstance(content, topologic.Aperture):
+                        content = Aperture.Topology(content)
                     if useInternalVertex == True:
                         vst = Topology.InternalVertex(content, tolerance)
                     else:
@@ -2929,7 +3284,6 @@ class Graph:
         if not isinstance(topology, topologic.Topology):
             print("Graph.ByTopology - Error: The input topology is not a valid topology. Returning None.")
             return None
-        topology = Topology.Copy(topology)
         graph = None
         item = [topology, None, None, None, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, None, useInternalVertex, storeBRep, tolerance]
         vertices = []
@@ -3699,6 +4053,159 @@ class Graph:
         except:
             return False
 
+    @staticmethod
+    def ExportToBOT(graph,
+                    path,
+                    format="turtle",
+                    overwrite = False,
+                    bidirectional=False,
+                    includeAttributes=False,
+                    includeLabel=False,
+                    siteLabel = "Site_0001",
+                    siteDictionary = None,
+                    buildingLabel = "Building_0001",
+                    buildingDictionary = None , 
+                    storeyPrefix = "Storey",
+                    floorLevels =[],
+                    labelKey="label",
+                    typeKey="type",
+                    sourceKey="source",
+                    targetKey="target",
+                    spaceType = "space",
+                    wallType = "wall",
+                    slabType = "slab",
+                    doorType = "door",
+                    windowType = "window",
+                    contentType = "content",
+                    ):
+        
+        """
+        Returns an RDF graph serialized string according to the BOT ontology. See https://w3c-lbd-cg.github.io/bot/.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        format : str , optional
+            The desired output format, the options are listed below. Thde default is "turtle".
+            turtle, ttl or turtle2 : Turtle, turtle2 is just turtle with more spacing & linebreaks
+            xml or pretty-xml : RDF/XML, Was the default format, rdflib < 6.0.0
+            json-ld : JSON-LD , There are further options for compact syntax and other JSON-LD variants
+            ntriples, nt or nt11 : N-Triples , nt11 is exactly like nt, only utf8 encoded
+            n3 : Notation-3 , N3 is a superset of Turtle that also caters for rules and a few other things
+            trig : Trig , Turtle-like format for RDF triples + context (RDF quads) and thus multiple graphs
+            trix : Trix , RDF/XML-like format for RDF quads
+            nquads : N-Quads , N-Triples-like format for RDF quads
+        path : str
+            The desired path to where the RDF/BOT file will be saved.
+        overwrite : bool , optional
+            If set to True, any existing file is overwritten. Otherwise, it is not. The default is False.
+        bidirectional : bool , optional
+            If set to True, reverse relationships are created wherever possible. Otherwise, they are not. The default is False.
+        includeAttributes : bool , optional
+            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.
+        siteLabel : str , optional
+            The desired site label. The default is "Site_0001".
+        siteDictionary : dict , optional
+            The dictionary of site attributes to include in the output. The default is None.
+        buildingLabel : str , optional
+            The desired building label. The default is "Building_0001".
+        buildingDictionary : dict , optional
+            The dictionary of building attributes to include in the output. The default is None.
+        storeyPrefix : str , optional
+            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".
+        labelKey : str , optional
+            The dictionary key to use to look up the label of the node. The default is "label".
+        spaceType : str , optional
+            The dictionary string value to use to look up nodes 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".
+        slabType : str , optional
+            The dictionary string value to use to look up nodes 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".
+        windowType : str , optional
+            The dictionary string value to use to look up nodes 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".
+        format : str , optional
+            The desired output format, the options are listed below. Thde default is "turtle".
+            turtle, ttl or turtle2 : Turtle, turtle2 is just turtle with more spacing & linebreaks
+            xml or pretty-xml : RDF/XML, Was the default format, rdflib < 6.0.0
+            json-ld : JSON-LD , There are further options for compact syntax and other JSON-LD variants
+            ntriples, nt or nt11 : N-Triples , nt11 is exactly like nt, only utf8 encoded
+            n3 : Notation-3 , N3 is a superset of Turtle that also caters for rules and a few other things
+            trig : Trig , Turtle-like format for RDF triples + context (RDF quads) and thus multiple graphs
+            trix : Trix , RDF/XML-like format for RDF quads
+            nquads : N-Quads , N-Triples-like format for RDF quads
+        
+        Returns
+        -------
+        str
+            The rdf graph serialized string using the BOT ontology.
+        """
+        from os.path import exists
+        bot_graph = Graph.BOTGraph(graph,
+                            bidirectional=bidirectional,
+                            includeAttributes=includeAttributes,
+                            includeLabel=includeLabel,
+                            siteLabel=siteLabel,
+                            siteDictionary=siteDictionary,
+                            buildingLabel=buildingLabel,
+                            buildingDictionary=buildingDictionary, 
+                            storeyPrefix=storeyPrefix,
+                            floorLevels=floorLevels,
+                            labelKey=labelKey,
+                            typeKey=typeKey,
+                            spaceType = spaceType,
+                            wallType = wallType,
+                            slabType = slabType,
+                            doorType = doorType,
+                            windowType = windowType,
+                            contentType = contentType
+                            )
+        if "turtle" in format.lower() or "ttl" in format.lower() or "turtle2" in format.lower():
+            ext = ".ttl"
+        elif "xml" in format.lower() or "pretty=xml" in format.lower() or "rdf/xml" in format.lower():
+            ext = ".xml"
+        elif "json" in format.lower():
+            ext = ".json"
+        elif "ntriples" in format.lower() or "nt" in format.lower() or "nt11" in format.lower():
+            ext = ".nt"
+        elif "n3" in format.lower() or "notation" in format.lower():
+            ext = ".n3"
+        elif "trig" in format.lower():
+            ext = ".trig"
+        elif "trix" in format.lower():
+            ext = ".trix"
+        elif "nquads" in format.lower():
+            ext = ".nquads"
+        else:
+            format = "turtle"
+            ext = ".ttl"
+        n = len(ext)
+        # Make sure the file extension is .brep
+        ext = path[len(path)-n:len(path)]
+        if ext.lower() != ext:
+            path = path+ext
+        if not overwrite and exists(path):
+            print("Graph.ExportToBOT - Error: a file already exists at the specified path and overwrite is set to False. Returning None.")
+            return None
+        status = False
+        try:
+            bot_graph.serialize(destination=path, format=format)
+            status = True
+        except:
+            status = False
+        return status
+    
     @staticmethod
     def ExportToCSV(graph, path, graphLabel, graphFeatures="",  
                        graphIDHeader="graph_id", graphLabelHeader="label", graphFeaturesHeader="feat",
@@ -4409,7 +4916,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.
 
@@ -4419,12 +4926,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
@@ -4458,7 +4975,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()
@@ -5113,7 +5630,17 @@ class Graph:
         return vertices
     
     @staticmethod
-    def JSONData(graph, vertexLabelKey="", edgeLabelKey="", mantissa=6):
+    def JSONData(graph,
+                 verticesKey="vertices",
+                 edgesKey="edges",
+                 vertexLabelKey="",
+                 edgeLabelKey="",
+                 sourceKey="source",
+                 targetKey="target",
+                 xKey="x",
+                 yKey="y",
+                 zKey="z",
+                 mantissa=6):
         """
         Converts the input graph into JSON data.
 
@@ -5121,12 +5648,26 @@ 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.
+        sourceKey : str , optional
+            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".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
 
@@ -5144,16 +5685,16 @@ 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))
             v_dict = Dictionary.PythonDictionary(d)
             v_label = Dictionary.ValueAtKey(d, vertexLabelKey)
             if isinstance(v_label, str):
@@ -5164,7 +5705,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)))    
@@ -5179,8 +5720,8 @@ class Graph:
             ev_label = v_labels[evi]
             d = Topology.Dictionary(e)
             
-            d = Dictionary.SetValueAtKey(d, "source", sv_label)
-            d = Dictionary.SetValueAtKey(d, "target", ev_label)
+            d = Dictionary.SetValueAtKey(d, sourceKey, sv_label)
+            d = Dictionary.SetValueAtKey(d, targetKey, ev_label)
             e_dict = Dictionary.PythonDictionary(d)
             e_label = Dictionary.ValueAtKey(d, edgeLabelKey)
             if isinstance(e_label, str):
@@ -5191,12 +5732,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.
 
@@ -5204,12 +5755,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
@@ -5224,7 +5785,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