topologicpy 0.7.84__py3-none-any.whl → 0.7.86__py3-none-any.whl

topologicpy/Graph.py

@@ -539,7 +539,7 @@ class Graph:
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
 
-        def addIfUnique(graph_vertices, vertex, tolerance):
+        def addIfUnique(graph_vertices, vertex, tolerance=0.0001):
             unique = True
             returnVertex = vertex
             for gv in graph_vertices:
@@ -574,11 +574,11 @@ class Graph:
                 print("Graph.AddEdge - Error: The input edge is not a valid edge. Returning the input graph.")
             return graph
         graph_vertices = Graph.Vertices(graph)
-        graph_edges = Graph.Edges(graph, graph_vertices, tolerance)
+        graph_edges = Graph.Edges(graph, graph_vertices, tolerance=tolerance)
         vertices = Topology.Vertices(edge)
         new_vertices = []
         for vertex in vertices:
-            graph_vertices, nv = addIfUnique(graph_vertices, vertex, tolerance)
+            graph_vertices, nv = addIfUnique(graph_vertices, vertex, tolerance=tolerance)
             new_vertices.append(nv)
         new_edge = Edge.ByVertices([new_vertices[0], new_vertices[1]], tolerance=tolerance)
         if transferEdgeDictionaries == True:
@@ -2162,6 +2162,8 @@ class Graph:
     @staticmethod
     def ByIFCFile(file, includeTypes: list = [], excludeTypes: list = [],
                   includeRels: list = [], excludeRels: list = [],
+                  transferDictionaries: bool = False, storeBREP: bool = False,
+                  removeCoplanarFaces: bool = False,
                   xMin: float = -0.5, yMin: float = -0.5, zMin: float = -0.5,
                   xMax: float = 0.5, yMax: float = 0.5, zMax: float = 0.5,
                   tolerance: float = 0.0001):
@@ -2180,6 +2182,12 @@ class Graph:
             A list of IFC relationship types to include in the graph. The default is [] which means all relationship types are included.
         excludeRels : list , optional
             A list of IFC relationship types to exclude from the graph. The default is [] which mean no relationship type is excluded.
+        transferDictionaries : bool , optional
+            If set to True, the dictionaries from the IFC file will be transferred to the topology. Otherwise, they won't. The default is False.
+        storeBREP : bool , optional
+            If set to True, store the BRep of the subtopology in its representative vertex. The default is False.
+        removeCoplanarFaces : bool , optional
+            If set to True, coplanar faces are removed. Otherwise they are not. The default is False.
         xMin : float, optional
             The desired minimum value to assign for a vertex's X coordinate. The default is -0.5.
         yMin : float, optional
@@ -2281,6 +2289,126 @@ class Graph:
                     relationships.append(ifc_rel)
             return relationships
 
+        def get_psets(entity):
+            # Initialize the PSET dictionary for this entity
+            psets = {}
+            
+            # Check if the entity has a GlobalId
+            if not hasattr(entity, 'GlobalId'):
+                raise ValueError("The provided entity does not have a GlobalId.")
+            
+            # Get the property sets related to this entity
+            for definition in entity.IsDefinedBy:
+                if definition.is_a('IfcRelDefinesByProperties'):
+                    property_set = definition.RelatingPropertyDefinition
+                    
+                    # Check if it is a property set
+                    if not property_set == None:
+                        if property_set.is_a('IfcPropertySet'):
+                            pset_name = "IFC_"+property_set.Name
+                            
+                            # Dictionary to hold individual properties
+                            properties = {}
+                            
+                            # Iterate over the properties in the PSET
+                            for prop in property_set.HasProperties:
+                                if prop.is_a('IfcPropertySingleValue'):
+                                    # Get the property name and value
+                                    prop_name = "IFC_"+prop.Name
+                                    prop_value = prop.NominalValue.wrappedValue if prop.NominalValue else None
+                                    properties[prop_name] = prop_value
+                            
+                            # Add this PSET to the dictionary for this entity
+                            psets[pset_name] = properties
+            return psets
+        
+        def get_color_transparency_material(entity):
+            import random
+
+            # Set default Material Name and ID
+            material_list = []
+            # Set default transparency based on entity type or material
+            default_transparency = 0.0
+            
+            # Check if the entity is an opening or made of glass
+            is_a = entity.is_a().lower()
+            if "opening" in is_a or "window" in is_a or "door" in is_a or "space" in is_a:
+                default_transparency = 0.7
+            elif "space" in is_a:
+                default_transparency = 0.8
+            
+            # Check if the entity has constituent materials (e.g., glass)
+            else:
+                # Check for associated materials (ConstituentMaterial or direct material assignment)
+                materials_checked = False
+                if hasattr(entity, 'HasAssociations'):
+                    for rel in entity.HasAssociations:
+                        if rel.is_a('IfcRelAssociatesMaterial'):
+                            material = rel.RelatingMaterial
+                            if material.is_a('IfcMaterial') and 'glass' in material.Name.lower():
+                                default_transparency = 0.5
+                                materials_checked = True
+                            elif material.is_a('IfcMaterialLayerSetUsage'):
+                                material_layers = material.ForLayerSet.MaterialLayers
+                                for layer in material_layers:
+                                    material_list.append(layer.Material.Name)
+                                    if 'glass' in layer.Material.Name.lower():
+                                        default_transparency = 0.5
+                                        materials_checked = True
+                                        
+                # Check for ConstituentMaterial if available
+                if hasattr(entity, 'HasAssociations') and not materials_checked:
+                    for rel in entity.HasAssociations:
+                        if rel.is_a('IfcRelAssociatesMaterial'):
+                            material = rel.RelatingMaterial
+                            if material.is_a('IfcMaterialConstituentSet'):
+                                for constituent in material.MaterialConstituents:
+                                    material_list.append(constituent.Material.Name)
+                                    if 'glass' in constituent.Material.Name.lower():
+                                        default_transparency = 0.5
+                                        materials_checked = True
+
+                # Check if the entity has ShapeAspects with associated materials or styles
+                if hasattr(entity, 'HasShapeAspects') and not materials_checked:
+                    for shape_aspect in entity.HasShapeAspects:
+                        if hasattr(shape_aspect, 'StyledByItem') and shape_aspect.StyledByItem:
+                            for styled_item in shape_aspect.StyledByItem:
+                                for style in styled_item.Styles:
+                                    if style.is_a('IfcSurfaceStyle'):
+                                        for surface_style in style.Styles:
+                                            if surface_style.is_a('IfcSurfaceStyleRendering'):
+                                                transparency = getattr(surface_style, 'Transparency', default_transparency)
+                                                if transparency > 0:
+                                                    default_transparency = transparency
+
+            # Try to get the actual color and transparency if defined
+            if hasattr(entity, 'Representation') and entity.Representation:
+                for rep in entity.Representation.Representations:
+                    for item in rep.Items:
+                        if hasattr(item, 'StyledByItem') and item.StyledByItem:
+                            for styled_item in item.StyledByItem:
+                                if hasattr(styled_item, 'Styles'):
+                                    for style in styled_item.Styles:
+                                        if style.is_a('IfcSurfaceStyle'):
+                                            for surface_style in style.Styles:
+                                                if surface_style.is_a('IfcSurfaceStyleRendering'):
+                                                    color = surface_style.SurfaceColour
+                                                    transparency = getattr(surface_style, 'Transparency', default_transparency)
+                                                    return (color.Red*255, color.Green*255, color.Blue*255), transparency, material_list
+            
+            # If no color is defined, return a consistent random color based on the entity type
+            if "wall" in is_a:
+                color = (175, 175, 175)
+            elif "slab" in is_a:
+                color = (200, 200, 200)
+            elif "space" in is_a:
+                color = (250, 250, 250)
+            else:
+                random.seed(hash(is_a))
+                color = (random.random(), random.random(), random.random())
+            
+            return color, default_transparency, material_list
+
         def vertexByIFCObject(ifc_object, object_types, restrict=False):
             settings = ifcopenshell.geom.settings()
             settings.set(settings.USE_WORLD_COORDS,True)
@@ -2318,8 +2446,47 @@ class Graph:
                     y = random.uniform(yMin,yMax)
                     z = random.uniform(zMin,zMax)
                     centroid = Vertex.ByCoordinates(x, y, z)
-                d = Dictionary.ByKeysValues(["id","psets", "type", "type_id", "name", "label"], [obj_id, psets, obj_type, obj_type_id, name, label])
-                centroid = Topology.SetDictionary(centroid, d)
+                
+                # Store relevant information
+                if transferDictionaries == True:
+                    color, transparency, material_list = get_color_transparency_material(ifc_object)
+                    entity_dict = {
+                        "TOPOLOGIC_id": str(Topology.UUID(centroid)),
+                        "TOPOLOGIC_name": getattr(ifc_object, 'Name', "Untitled"),
+                        "TOPOLOGIC_type": Topology.TypeAsString(centroid),
+                        "TOPOLOGIC_color": color,
+                        "TOPOLOGIC_opacity": 1.0 - transparency,
+                        "IFC_global_id": getattr(ifc_object, 'GlobalId', 0),
+                        "IFC_name": getattr(ifc_object, 'Name', "Untitled"),
+                        "IFC_type": ifc_object.is_a(),
+                        "IFC_material_list": material_list,
+                    }
+                    topology_dict = Dictionary.ByPythonDictionary(entity_dict)
+                    # Get PSETs dictionary
+                    pset_python_dict = get_psets(ifc_object)
+                    pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
+                    topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
+                    if storeBREP == True:
+                        shape_topology = None
+                        if hasattr(ifc_object, "Representation") and ifc_object.Representation:
+                            for rep in ifc_object.Representation.Representations:
+                                if rep.is_a("IfcShapeRepresentation"):
+                                    # Generate the geometry for this entity
+                                    shape = ifcopenshell.geom.create_shape(settings, ifc_object)
+                                    # Get grouped vertices and grouped faces     
+                                    grouped_verts = shape.geometry.verts
+                                    verts = [ [grouped_verts[i], grouped_verts[i + 1], grouped_verts[i + 2]] for i in range(0, len(grouped_verts), 3)]
+                                    grouped_edges = shape.geometry.edges
+                                    edges = [[grouped_edges[i], grouped_edges[i + 1]] for i in range(0, len(grouped_edges), 2)]
+                                    grouped_faces = shape.geometry.faces
+                                    faces = [ [grouped_faces[i], grouped_faces[i + 1], grouped_faces[i + 2]] for i in range(0, len(grouped_faces), 3)]
+                                    shape_topology = Topology.ByGeometry(verts, edges, faces, silent=True)
+                                    if not shape_topology == None:
+                                        if removeCoplanarFaces == True:
+                                            shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
+                        if not shape_topology == None:
+                            topology_dict = Dictionary.SetValuesAtKeys(topology_dict, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(shape_topology), Topology.Type(shape_topology), Topology.TypeAsString(shape_topology)])
+                    centroid = Topology.SetDictionary(centroid, topology_dict)
                 return centroid
             return None
 
@@ -2333,52 +2500,57 @@ class Graph:
                 if ifc_rel.is_a("IfcRelConnectsPorts"):
                     source = ifc_rel.RelatingPort
                     destinations = ifc_rel.RelatedPorts
-                if ifc_rel.is_a("IfcRelConnectsPortToElement"):
+                elif ifc_rel.is_a("IfcRelConnectsPortToElement"):
                     source = ifc_rel.RelatingPort
                     destinations = [ifc_rel.RelatedElement]
-                if ifc_rel.is_a("IfcRelAggregates"):
+                elif ifc_rel.is_a("IfcRelAggregates"):
                     source = ifc_rel.RelatingObject
                     destinations = ifc_rel.RelatedObjects
-                if ifc_rel.is_a("IfcRelNests"):
+                elif ifc_rel.is_a("IfcRelNests"):
                     source = ifc_rel.RelatingObject
                     destinations = ifc_rel.RelatedObjects
-                if ifc_rel.is_a("IfcRelAssignsToGroup"):
+                elif ifc_rel.is_a("IfcRelAssignsToGroup"):
                     source = ifc_rel.RelatingGroup
                     destinations = ifc_rel.RelatedObjects
-                if ifc_rel.is_a("IfcRelConnectsPathElements"):
+                elif ifc_rel.is_a("IfcRelConnectsPathElements"):
                     source = ifc_rel.RelatingElement
                     destinations = [ifc_rel.RelatedElement]
-                if ifc_rel.is_a("IfcRelConnectsStructuralMember"):
+                elif ifc_rel.is_a("IfcRelConnectsStructuralMember"):
                     source = ifc_rel.RelatingStructuralMember
                     destinations = [ifc_rel.RelatedStructuralConnection]
-                if ifc_rel.is_a("IfcRelContainedInSpatialStructure"):
+                elif ifc_rel.is_a("IfcRelContainedInSpatialStructure"):
                     source = ifc_rel.RelatingStructure
                     destinations = ifc_rel.RelatedElements
-                if ifc_rel.is_a("IfcRelFillsElement"):
+                elif ifc_rel.is_a("IfcRelFillsElement"):
                     source = ifc_rel.RelatingOpeningElement
                     destinations = [ifc_rel.RelatedBuildingElement]
-                if ifc_rel.is_a("IfcRelSpaceBoundary"):
+                elif ifc_rel.is_a("IfcRelSpaceBoundary"):
                     source = ifc_rel.RelatingSpace
                     destinations = [ifc_rel.RelatedBuildingElement]
-                if ifc_rel.is_a("IfcRelVoidsElement"):
+                elif ifc_rel.is_a("IfcRelVoidsElement"):
                     source = ifc_rel.RelatingBuildingElement
                     destinations = [ifc_rel.RelatedOpeningElement]
+                elif ifc_rel.is_a("IfcRelDefinesByProperties") or ifc_rel.is_a("IfcRelAssociatesMaterial") or ifc_rel.is_a("IfcRelDefinesByType"):
+                    source = None
+                    destinations = None
+                else:
+                    print("Graph.ByIFCFile - Warning: The relationship", ifc_rel, "is not supported. Skipping.")
                 if source:
-                    sv = vertexAtKeyValue(vertices, key="id", value=source.id())
+                    sv = vertexAtKeyValue(vertices, key="IFC_global_id", value=getattr(source, 'GlobalId', 0))
                     if sv:
                         si = Vertex.Index(sv, vertices, tolerance=tolerance)
                         if not si == None:
                             for destination in destinations:
                                 if destination == None:
                                     continue
-                                ev = vertexAtKeyValue(vertices, key="id", value=destination.id())
+                                ev = vertexAtKeyValue(vertices, key="IFC_global_id", value=getattr(destination, 'GlobalId', 0),)
                                 if ev:
                                     ei = Vertex.Index(ev, vertices, tolerance=tolerance)
                                     if not ei == None:
                                         if not([si,ei] in tuples or [ei,si] in tuples):
                                             tuples.append([si,ei])
                                             e = Edge.ByVertices([sv,ev])
-                                            d = Dictionary.ByKeysValues(["id", "name", "type"], [ifc_rel.id(), ifc_rel.Name, ifc_rel.is_a()])
+                                            d = Dictionary.ByKeysValues(["IFC_global_id", "IFC_name", "IFC_type"], [ifc_rel.id(), ifc_rel.Name, ifc_rel.is_a()])
                                             e = Topology.SetDictionary(e, d)
                                             edges.append(e)
             return edges
@@ -2399,7 +2571,7 @@ class Graph:
         return g
 
     @staticmethod
-    def ByIFCPath(path, includeTypes=[], excludeTypes=[], includeRels=[], excludeRels=[], xMin=-0.5, yMin=-0.5, zMin=-0.5, xMax=0.5, yMax=0.5, zMax=0.5):
+    def ByIFCPath(path, includeTypes=[], excludeTypes=[], includeRels=[], excludeRels=[], transferDictionaries=False, storeBREP=False, removeCoplanarFaces=False, xMin=-0.5, yMin=-0.5, zMin=-0.5, xMax=0.5, yMax=0.5, zMax=0.5):
         """
         Create a Graph from an IFC path. This code is partially based on code from Bruno Postle.
 
@@ -2415,6 +2587,12 @@ class Graph:
             A list of IFC relationship types to include in the graph. The default is [] which means all relationship types are included.
         excludeRels : list , optional
             A list of IFC relationship types to exclude from the graph. The default is [] which mean no relationship type is excluded.
+        transferDictionaries : bool , optional
+            If set to True, the dictionaries from the IFC file will be transferred to the topology. Otherwise, they won't. The default is False.
+        storeBREP : bool , optional
+            If set to True, store the BRep of the subtopology in its representative vertex. The default is False.
+        removeCoplanarFaces : bool , optional
+            If set to True, coplanar faces are removed. Otherwise they are not. The default is False.
         xMin : float, optional
             The desired minimum value to assign for a vertex's X coordinate. The default is -0.5.
         yMin : float, optional
@@ -2463,7 +2641,15 @@ class Graph:
         if not ifc_file:
             print("Graph.ByIFCPath - Error: Could not open the IFC file. Returning None.")
             return None
-        return Graph.ByIFCFile(ifc_file, includeTypes=includeTypes, excludeTypes=excludeTypes, includeRels=includeRels, excludeRels=excludeRels, xMin=xMin, yMin=yMin, zMin=zMin, xMax=xMax, yMax=yMax, zMax=zMax)
+        return Graph.ByIFCFile(ifc_file,
+                               includeTypes=includeTypes,
+                               excludeTypes=excludeTypes,
+                               includeRels=includeRels,
+                               excludeRels=excludeRels,
+                               transferDictionaries=transferDictionaries,
+                               storeBREP=storeBREP,
+                               removeCoplanarFaces=removeCoplanarFaces,
+                               xMin=xMin, yMin=yMin, zMin=zMin, xMax=xMax, yMax=yMax, zMax=zMax)
 
     @staticmethod
     def ByMeshData(vertices, edges, vertexDictionaries=None, edgeDictionaries=None, tolerance=0.0001):
@@ -2537,7 +2723,7 @@ class Graph:
                    outpostsKey: str = "outposts",
                    vertexCategoryKey: str = "category",
                    edgeCategoryKey : str = "category",
-                   useInternalVertex: bool =True,
+                   useInternalVertex: bool = False,
                    storeBREP: bool =False,
                    mantissa: int = 6,
                    tolerance: float = 0.0001):
@@ -2613,17 +2799,14 @@ class Graph:
             eds = []
             for sharedTopology in sharedTops:
                 if useInternalVertex == True:
-                    vst = Topology.InternalVertex(sharedTopology, tolerance)
+                    vst = Topology.InternalVertex(sharedTopology, tolerance=tolerance)
                 else:
                     vst = Topology.CenterOfMass(sharedTopology)
                 d1 = Topology.Dictionary(sharedTopology)
                 d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 1) # shared topology
                 if storeBREP:
-                    d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedTopology), Topology.Type(sharedTopology), Topology.TypeAsString(sharedTopology)])
-                    d3 = mergeDictionaries2([d1, d2])
-                    vst = Topology.SetDictionary(vst, d3, silent=True)
-                else:
-                    vst = Topology.SetDictionary(vst, d1, silent=True)
+                    d1 = Dictionary.SetValuesAtKeys(d1, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedTopology), Topology.Type(sharedTopology), Topology.TypeAsString(sharedTopology)])
+                vst = Topology.SetDictionary(vst, d1, silent=True)
                 verts.append(vst)
                 tempe = Edge.ByStartVertexEndVertex(vt, vst, tolerance=tolerance)
                 tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["Via_Shared_Topologies", 1])
@@ -2636,18 +2819,15 @@ class Graph:
             eds = []
             for sharedAp in sharedAps:
                 if useInternalVertex == True:
-                    vsa = Topology.InternalVertex(sharedAp, tolerance)
+                    vsa = Topology.InternalVertex(sharedAp, tolerance=tolerance)
                 else:
                     vsa = Topology.CenterOfMass(sharedAp)
                 d1 = Topology.Dictionary(sharedAp)
                 d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 2) # shared aperture
                 vsa = Vertex.ByCoordinates(Vertex.X(vsa, mantissa=mantissa)+(tolerance*100), Vertex.Y(vsa, mantissa=mantissa)+(tolerance*100), Vertex.Z(vsa, mantissa=mantissa)+(tolerance*100))
                 if storeBREP:
-                    d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedAp), Topology.Type(sharedAp), Topology.TypeAsString(sharedAp)])
-                    d3 = mergeDictionaries2([d1, d2])
-                    vsa = Topology.SetDictionary(vsa, d3, silent=True)
-                else:
-                    vsa = Topology.SetDictionary(vsa, d1, silent=True)
+                    d1 = Dictionary.SetValuesAtKeys(d1, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedAp), Topology.Type(sharedAp), Topology.TypeAsString(sharedAp)])
+                vsa = Topology.SetDictionary(vsa, d1, silent=True)
                 verts.append(vsa)
                 tempe = Edge.ByStartVertexEndVertex(vt, vsa, tolerance=tolerance)
                 tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["Via_Shared_Apertures", 2])
@@ -2658,20 +2838,16 @@ class Graph:
         def _toExteriorTopologies(vt, exteriorTops):
             verts = []
             eds = []
-            for exteriorTop in exteriorTops:
+            for i, exteriorTop in enumerate(exteriorTops):
                 if useInternalVertex == True:
-                    vet = Topology.InternalVertex(exteriorTop, tolerance)
+                    vet = Topology.InternalVertex(exteriorTop, tolerance=tolerance)
                 else:
                     vet = Topology.CenterOfMass(exteriorTop)
-                    vet = Topology.SetDictionary(vet, Topology.Dictionary(exteriorTop), silent=True)
                 d1 = Topology.Dictionary(exteriorTop)
                 d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 3) # exterior topology
                 if storeBREP:
-                    d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTop), Topology.Type(exteriorTop), Topology.TypeAsString(exteriorTop)])
-                    d3 = mergeDictionaries2([d1, d2])
-                    vet = Topology.SetDictionary(vet, d3, silent=True)
-                else:
-                    vet = Topology.SetDictionary(vet, d1, silent=True)
+                    d1 = Dictionary.SetValuesAtKeys(d1, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTop), Topology.Type(exteriorTop), Topology.TypeAsString(exteriorTop)])
+                vet = Topology.SetDictionary(vet, d1, silent=True)
                 verts.append(vet)
                 tempe = Edge.ByStartVertexEndVertex(vt, vet, tolerance=tolerance)
                 tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["To_Exterior_Topologies", 3])
@@ -2684,18 +2860,15 @@ class Graph:
             eds = []
             for exAp in exteriorAps:
                 if useInternalVertex == True:
-                    vea = Topology.InternalVertex(exAp, tolerance)
+                    vea = Topology.InternalVertex(exAp, tolerance=tolerance)
                 else:
                     vea = Topology.CenterOfMass(exAp)
                 d1 = Topology.Dictionary(exAp)
                 d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 4) # exterior aperture
                 vea = Vertex.ByCoordinates(Vertex.X(vea, mantissa=mantissa)+(tolerance*100), Vertex.Y(vea, mantissa=mantissa)+(tolerance*100), Vertex.Z(vea, mantissa=mantissa)+(tolerance*100))
                 if storeBREP:
-                    d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exAp), Topology.Type(exAp), Topology.TypeAsString(exAp)])
-                    d3 = mergeDictionaries2([d1, d2])
-                    vea = Topology.SetDictionary(vea, d3, silent=True)
-                else:
-                    vea = Topology.SetDictionary(vea, d1, silent=True)
+                    d1 = Dictionary.SetValuesAtKeys(d1, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(exAp), Topology.Type(exAp), Topology.TypeAsString(exAp)])
+                vea = Topology.SetDictionary(vea, d1, silent=True)
                 verts.append(vea)
                 tempe = Edge.ByStartVertexEndVertex(vt, vea, tolerance=tolerance)
                 tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["To_Exterior_Apertures", 4])
@@ -2710,18 +2883,15 @@ class Graph:
                 if Topology.IsInstance(content, "Aperture"):
                     content = Aperture.Topology(content)
                 if useInternalVertex == True:
-                    vct = Topology.InternalVertex(content, tolerance)
+                    vct = Topology.InternalVertex(content, tolerance=tolerance)
                 else:
                     vct = Topology.CenterOfMass(content)
                 vct = Vertex.ByCoordinates(Vertex.X(vct, mantissa=mantissa)+(tolerance*100), Vertex.Y(vct, mantissa=mantissa)+(tolerance*100), Vertex.Z(vct, mantissa=mantissa)+(tolerance*100))
                 d1 = Topology.Dictionary(content)
                 d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 5) # content
                 if storeBREP:
-                    d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
-                    d3 = mergeDictionaries2([d1, d2])
-                    vct = Topology.SetDictionary(vct, d3, silent=True)
-                else:
-                    vct = Topology.SetDictionary(vct, d1, silent=True)
+                    d1 = Dictionary.SetValuesAtKeys(d1, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
+                vct = Topology.SetDictionary(vct, d1, silent=True)
                 verts.append(vct)
                 tempe = Edge.ByStartVertexEndVertex(vt, vct, tolerance=tolerance)
                 tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["To_Contents", 5])
@@ -2755,11 +2925,8 @@ class Graph:
                 d1 = Topology.Dictionary(vop)
                 d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 6) # outpost
                 if storeBREP:
-                    d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(outpost), Topology.Type(outpost), Topology.TypeAsString(outpost)])
-                    d3 = mergeDictionaries2([d1, d2])
-                    vop = Topology.SetDictionary(vop, d3, silent=True)
-                else:
-                    vop = Topology.SetDictionary(vop, d1, silent=True)
+                    d1 = Dictionary.SetValuesAtKeys(d1, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(outpost), Topology.Type(outpost), Topology.TypeAsString(outpost)])
+                vop = Topology.SetDictionary(vop, d1, silent=True)
                 verts.append(vop)
                 tempe = Edge.ByStartVertexEndVertex(vt, vop, tolerance=tolerance)
                 tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["To_Outposts", 6])
@@ -2883,11 +3050,8 @@ class Graph:
                 d1 = Topology.Dictionary(cell)
                 d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 0) # main topology
                 if storeBREP:
-                    d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(cell), Topology.Type(cell), Topology.TypeAsString(cell)])
-                    d3 = mergeDictionaries2([d1, d2])
-                    vCell = Topology.SetDictionary(vCell, d3, silent=True)
-                else:
-                    vCell = Topology.SetDictionary(vCell, d1, silent=True)
+                    d1 = Dictionary.SetValuesAtKeys(d1, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(cell), Topology.Type(cell), Topology.TypeAsString(cell)])
+                vCell = Topology.SetDictionary(vCell, d1, silent=True)
                 graph_vertices.append(vCell)
             if direct == True:
                 cells = Topology.Cells(topology)
@@ -2999,7 +3163,7 @@ class Graph:
                         graph_edges += eds
                         for sharedTopology in sharedTopologies:
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(sharedTopology, tolerance)
+                                vst = Topology.InternalVertex(sharedTopology, tolerance=tolerance)
                             else:
                                 vst = Topology.CenterOfMass(sharedTopology)
                             d = Topology.Dictionary(sharedTopology)
@@ -3014,7 +3178,7 @@ class Graph:
                                 graph_vertices += verts
                                 graph_edges += eds
                     if viaSharedApertures:
-                        verts, eds = _viaSharedTopologies(vCell, sharedApertures)
+                        verts, eds = _viaSharedApertures(vCell, sharedApertures)
                         graph_vertices += verts
                         graph_edges += eds
                     if toExteriorTopologies:
@@ -3023,7 +3187,7 @@ class Graph:
                         graph_edges += eds
                         for exteriorTopology in exteriorTopologies:
                             if useInternalVertex == True:
-                                vet = Topology.InternalVertex(exteriorTopology, tolerance)
+                                vet = Topology.InternalVertex(exteriorTopology, tolerance=tolerance)
                             else:
                                 vet = Topology.CenterOfMass(exteriorTopology)
                             d = Topology.Dictionary(exteriorTopology)
@@ -3084,7 +3248,7 @@ class Graph:
                     graph_edges += eds
                     for exteriorTopology in exteriorTopologies:
                         if useInternalVertex == True:
-                            vet = Topology.InternalVertex(exteriorTopology, tolerance)
+                            vet = Topology.InternalVertex(exteriorTopology, tolerance=tolerance)
                         else:
                             vet = Topology.CenterOfMass(exteriorTopology)
                         d = Topology.Dictionary(exteriorTopology)
@@ -3243,7 +3407,7 @@ class Graph:
                         graph_edges += eds
                         for sharedTopology in sharedTopologies:
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(sharedTopology, tolerance)
+                                vst = Topology.InternalVertex(sharedTopology, tolerance=tolerance)
                             else:
                                 vst = Topology.CenterOfMass(sharedTopology)
                             d = Topology.Dictionary(sharedTopology)
@@ -3258,7 +3422,7 @@ class Graph:
                                 graph_vertices += verts
                                 graph_edges += eds
                     if viaSharedApertures:
-                        verts, eds = _viaSharedTopologies(vFace, sharedApertures)
+                        verts, eds = _viaSharedApertures(vFace, sharedApertures)
                         graph_vertices += verts
                         graph_edges += eds
                     if toExteriorTopologies:
@@ -3267,7 +3431,7 @@ class Graph:
                         graph_edges += eds
                         for exteriorTopology in exteriorTopologies:
                             if useInternalVertex == True:
-                                vet = Topology.InternalVertex(exteriorTopology, tolerance)
+                                vet = Topology.InternalVertex(exteriorTopology, tolerance=tolerance)
                             else:
                                 vet = Topology.CenterOfMass(exteriorTopology)
                             d = Topology.Dictionary(exteriorTopology)
@@ -3328,7 +3492,7 @@ class Graph:
                     graph_edges += eds
                     for exteriorTopology in exteriorTopologies:
                         if useInternalVertex == True:
-                            vet = Topology.InternalVertex(exteriorTopology, tolerance)
+                            vet = Topology.InternalVertex(exteriorTopology, tolerance=tolerance)
                         else:
                             vet = Topology.CenterOfMass(exteriorTopology)
                         d = Topology.Dictionary(exteriorTopology)
@@ -3489,7 +3653,7 @@ class Graph:
                         graph_edges += eds
                         for sharedTopology in sharedTopologies:
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(sharedTopology, tolerance)
+                                vst = Topology.InternalVertex(sharedTopology, tolerance=tolerance)
                             else:
                                 vst = Topology.CenterOfMass(sharedTopology)
                             d = Topology.Dictionary(sharedTopology)
@@ -3504,16 +3668,16 @@ class Graph:
                                 graph_vertices += verts
                                 graph_edges += eds
                     if viaSharedApertures:
-                        verts, eds = _viaSharedTopologies(vCell, sharedApertures)
+                        verts, eds = _viaSharedApertures(vEdge, sharedApertures)
                         graph_vertices += verts
                         graph_edges += eds
                     if toExteriorTopologies:
-                        verts, eds = _toExteriorTopologies(vCell, exteriorTopologies)
+                        verts, eds = _toExteriorTopologies(vEdge, exteriorTopologies)
                         graph_vertices += verts
                         graph_edges += eds
                         for exteriorTopology in exteriorTopologies:
                             if useInternalVertex == True:
-                                vet = Topology.InternalVertex(exteriorTopology, tolerance)
+                                vet = Topology.InternalVertex(exteriorTopology, tolerance=tolerance)
                             else:
                                 vet = Topology.CenterOfMass(exteriorTopology)
                             d = Topology.Dictionary(exteriorTopology)
@@ -3541,8 +3705,6 @@ class Graph:
                         graph_edges += eds
             return [graph_vertices, graph_edges]
 
-
-
         def processEdge(item):
             topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             graph_vertices = []
@@ -3576,7 +3738,7 @@ class Graph:
                     graph_edges += eds
                     for exteriorTopology in exteriorTopologies:
                         if useInternalVertex == True:
-                            vet = Topology.InternalVertex(exteriorTopology, tolerance)
+                            vet = Topology.InternalVertex(exteriorTopology, tolerance=tolerance)
                         else:
                             vet = Topology.CenterOfMass(exteriorTopology)
                         d = Topology.Dictionary(exteriorTopology)
@@ -3604,7 +3766,6 @@ class Graph:
                     graph_edges += eds
             return [graph_vertices, graph_edges]
 
-
         def processVertex(item):
             topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             vertices = [topology]
@@ -3616,7 +3777,7 @@ class Graph:
                     if Topology.IsInstance(content, "Aperture"):
                         content = Aperture.Topology(content)
                     if useInternalVertex == True:
-                        vst = Topology.InternalVertex(content, tolerance)
+                        vst = Topology.InternalVertex(content, tolerance=tolerance)
                     else:
                         vst = Topology.CenterOfMass(content)
                     d1 = Topology.Dictionary(content)
@@ -3651,7 +3812,7 @@ class Graph:
                     outposts = []
                 for outpost in outposts:
                     if useInternalVertex == True:
-                        vop = Topology.InternalVertex(outpost, tolerance)
+                        vop = Topology.InternalVertex(outpost, tolerance=tolerance)
                     else:
                         vop = Topology.CenterOfMass(outpost)
                     tempe = Edge.ByStartVertexEndVertex(topology, vop, tolerance=tolerance)
@@ -3661,7 +3822,6 @@ class Graph:
             
             return [vertices, edges]
 
-        
         if not Topology.IsInstance(topology, "Topology"):
             print("Graph.ByTopology - Error: The input topology is not a valid topology. Returning None.")
             return None
@@ -4071,7 +4231,7 @@ class Graph:
                     if Topology.IsSame(va, vb):
                         d = 0
                     else:
-                        d = Graph.TopologicalDistance(graph, va, vb, tolerance)
+                        d = Graph.TopologicalDistance(graph, va, vb, tolerance=tolerance)
                     top_dist += d
                 if top_dist == 0:
                     print("Graph.ClosenessCentrality - Warning: Topological Distance is Zero.")
@@ -4086,7 +4246,7 @@ class Graph:
                     if Topology.IsSame(va, vb):
                         d = 0
                     else:
-                        d = Graph.TopologicalDistance(graph, va, vb, tolerance)
+                        d = Graph.TopologicalDistance(graph, va, vb, tolerance=tolerance)
                     top_dist += d
                 if top_dist == 0:
                     scores.append(0)
@@ -4173,7 +4333,7 @@ class Graph:
         if not Topology.IsInstance(edge, "Edge"):
             print("Graph.ContainsEdge - Error: The input edge is not a valid edge. Returning None.")
             return None
-        return graph.ContainsEdge(edge, tolerance)
+        return graph.ContainsEdge(edge, tolerance) # Hook to Core
     
     @staticmethod
     def ContainsVertex(graph, vertex, tolerance=0.0001):
@@ -4203,7 +4363,7 @@ class Graph:
         if not Topology.IsInstance(vertex, "Vertex"):
             print("Graph.ContainsVertex - Error: The input vertex is not a valid vertex. Returning None.")
             return None
-        return graph.ContainsVertex(vertex, tolerance)
+        return graph.ContainsVertex(vertex, tolerance) # Hook to Core
 
 
     @staticmethod
@@ -4567,7 +4727,7 @@ class Graph:
         if not Topology.IsInstance(vertexB, "Vertex"):
             print("Graph.Edge - Error: The input vertexB is not a valid vertex. Returning None.")
             return None
-        return graph.Edge(vertexA, vertexB, tolerance)
+        return graph.Edge(vertexA, vertexB, tolerance) # Hook to Core
     
     @staticmethod
     def Edges(graph, vertices=None, tolerance=0.0001):
@@ -8183,9 +8343,9 @@ class Graph:
                             group = minVertexGroup
                         if group > maxVertexGroup:
                             group = maxVertexGroup
-                        color = Color.RGBToHex(Color.ByValueInRange(group, minValue=minVertexGroup, maxValue=maxVertexGroup, colorScale=colorScale))
+                        color = Color.AnyToHex(Color.ByValueInRange(group, minValue=minVertexGroup, maxValue=maxVertexGroup, colorScale=colorScale))
                     else:
-                        color = Color.RGBToHex(Color.ByValueInRange(vertexGroups.index(group), minValue=minVertexGroup, maxValue=maxVertexGroup, colorScale=colorScale))
+                        color = Color.AnyToHex(Color.ByValueInRange(vertexGroups.index(group), minValue=minVertexGroup, maxValue=maxVertexGroup, colorScale=colorScale))
                     colors.append(color)
                 except:
                     colors.append(vertexColor)
@@ -8474,28 +8634,32 @@ class Graph:
         return shortestPaths
 
     @staticmethod
-    def Show(graph,
+    def Show(*graphs,
              sagitta = 0,
              absolute = False,
              sides = 8,
              angle = 0,
              vertexColor="black",
              vertexColorKey=None,
-             vertexSize=6,
+             vertexSize=10,
              vertexSizeKey=None,
              vertexLabelKey=None,
              vertexGroupKey=None,
              vertexGroups=[],
+             vertexMinGroup=None,
+             vertexMaxGroup=None,
              showVertices=True,
              showVertexLabel=False,
              showVertexLegend=False,
-             edgeColor="black",
+             edgeColor="red",
              edgeColorKey=None,
              edgeWidth=1,
              edgeWidthKey=None,
              edgeLabelKey=None,
              edgeGroupKey=None,
              edgeGroups=[],
+             edgeMinGroup=None,
+             edgeMaxGroup=None,
              showEdges=True,
              showEdgeLabel=False,
              showEdgeLegend=False,
@@ -8522,8 +8686,8 @@ class Graph:
 
         Parameters
         ----------
-        graph : topologic_core.Graph
-            The input graph.
+        *graphs : topologic_core.Graph
+            One or more toplogic_core.graph objects.
         sagitta : float , optional
             The length of the sagitta. In mathematics, the sagitta is the line connecting the center of a chord to the apex (or highest point) of the arc subtended by that chord. The default is 0 which means a straight edge is drawn instead of an arc. The default is 0.
         absolute : bool , optional
@@ -8553,6 +8717,10 @@ class Graph:
             The dictionary key to use to display the vertex group. The default is None.
         vertexGroups : list , optional
             The list of vertex groups against which to index the color of the vertex. The default is [].
+        vertexMinGroup : int or float , optional
+            For numeric vertexGroups, vertexMinGroup is the desired minimum value for the scaling of colors. This should match the type of value associated with the vertexGroupKey. If set to None, it is set to the minimum value in vertexGroups. The default is None.
+        vertexMaxGroup : int or float , optional
+            For numeric vertexGroups, vertexMaxGroup is the desired maximum value for the scaling of colors. This should match the type of value associated with the vertexGroupKey. If set to None, it is set to the maximum value in vertexGroups. The default is None.
         showVertices : bool , optional
             If set to True the vertices will be drawn. Otherwise, they will not be drawn. The default is True.
         showVertexLabel : bool , optional
@@ -8579,6 +8747,10 @@ class Graph:
             The dictionary key to use to display the edge group. The default is None.
         edgeGroups : list , optional
             The list of edge groups against which to index the color of the edge. The default is [].
+        edgeMinGroup : int or float , optional
+            For numeric edgeGroups, edgeMinGroup is the desired minimum value for the scaling of colors. This should match the type of value associated with the edgeGroupKey. If set to None, it is set to the minimum value in edgeGroups. The default is None.
+        edgeMaxGroup : int or float , optional
+            For numeric edgeGroups, edgeMaxGroup is the desired maximum value for the scaling of colors. This should match the type of value associated with the edgeGroupKey. If set to None, it is set to the maximum value in edgeGroups. The default is None.
         showEdges : bool , optional
             If set to True the edges will be drawn. Otherwise, they will not be drawn. The default is True.
         showEdgeLabel : bool , optional
@@ -8637,12 +8809,49 @@ class Graph:
         """
         from topologicpy.Plotly import Plotly
         from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
 
-        if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.Show - Error: The input graph is not a valid graph. Returning None.")
-            return None
-        
-        data= Plotly.DataByGraph(graph, sagitta=sagitta, absolute=absolute, sides=sides,  angle=angle, vertexColor=vertexColor, vertexColorKey=vertexColorKey, vertexSize=vertexSize, vertexSizeKey=vertexSizeKey, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabel=showVertexLabel, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeColorKey=edgeColorKey, edgeWidth=edgeWidth, edgeWidthKey=edgeWidthKey, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabel=showEdgeLabel, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
+        if isinstance(graphs, tuple):
+            graphs = Helper.Flatten(list(graphs))
+        if isinstance(graphs, list):
+            new_graphs = [t for t in graphs if Topology.IsInstance(t, "Graph")]
+        if len(new_graphs) == 0:
+            if not silent:
+                print("Topology.Show - Error: the input topologies parameter does not contain any valid topology. Returning None.")
+            return None
+        data = []
+        for graph in new_graphs:
+            data += Plotly.DataByGraph(graph,
+                                       sagitta=sagitta,
+                                       absolute=absolute,
+                                       sides=sides,
+                                       angle=angle,
+                                       vertexColor=vertexColor,
+                                       vertexColorKey=vertexColorKey,
+                                       vertexSize=vertexSize,
+                                       vertexSizeKey=vertexSizeKey,
+                                       vertexLabelKey=vertexLabelKey,
+                                       vertexGroupKey=vertexGroupKey,
+                                       vertexGroups=vertexGroups,
+                                       vertexMinGroup=vertexMinGroup,
+                                       vertexMaxGroup=vertexMaxGroup,
+                                       showVertices=showVertices,
+                                       showVertexLabel=showVertexLabel,
+                                       showVertexLegend=showVertexLegend,
+                                       edgeColor=edgeColor,
+                                       edgeColorKey=edgeColorKey,
+                                       edgeWidth=edgeWidth,
+                                       edgeWidthKey=edgeWidthKey,
+                                       edgeLabelKey=edgeLabelKey,
+                                       edgeGroupKey=edgeGroupKey,
+                                       edgeGroups=edgeGroups,
+                                       edgeMinGroup=edgeMinGroup,
+                                       edgeMaxGroup=edgeMaxGroup,
+                                       showEdges=showEdges,
+                                       showEdgeLabel=showEdgeLabel,
+                                       showEdgeLegend=showEdgeLegend,
+                                       colorScale=colorScale,
+                                       silent=silent)
         fig = Plotly.FigureByData(data, width=width, height=height, xAxis=xAxis, yAxis=yAxis, zAxis=zAxis, axisSize=axisSize, backgroundColor=backgroundColor,
                                   marginLeft=marginLeft, marginRight=marginRight, marginTop=marginTop, marginBottom=marginBottom, tolerance=tolerance)
         Plotly.Show(fig, renderer=renderer, camera=camera, center=center, up=up, projection=projection)
@@ -8703,7 +8912,7 @@ class Graph:
         if not Topology.IsInstance(vertexB, "Vertex"):
             print("Graph.TopologicalDistance - Error: The input vertexB is not a valid vertex. Returning None.")
             return None
-        return graph.TopologicalDistance(vertexA, vertexB, tolerance)
+        return graph.TopologicalDistance(vertexA, vertexB, tolerance) # Hook to Core
     
     @staticmethod
     def Topology(graph):
@@ -8781,7 +8990,7 @@ class Graph:
             if not vertexInList(vertex, vertices):
                 vertices.append(vertex)
                 if parent:
-                    edge = Graph.Edge(graph, parent, vertex, tolerance)
+                    edge = Graph.Edge(graph, parent, vertex, tolerance=tolerance)
                     ev = Edge.EndVertex(edge)
                     if Vertex.Distance(parent, ev) < tolerance:
                         edge = Edge.Reverse(edge)
@@ -8792,7 +9001,7 @@ class Graph:
             dictionary['vertices'] = vertices
             dictionary['edges'] = edges
             for child in children:
-                dictionary = buildTree(graph, dictionary, child, vertex, tolerance)
+                dictionary = buildTree(graph, dictionary, child, vertex, tolerance=tolerance)
             return dictionary
         
         if not Topology.IsInstance(graph, "Graph"):
@@ -8803,7 +9012,7 @@ class Graph:
         else:
             vertex = Graph.NearestVertex(graph, vertex)
         dictionary = {'vertices':[], 'edges':[]}
-        dictionary = buildTree(graph, dictionary, vertex, None, tolerance)
+        dictionary = buildTree(graph, dictionary, vertex, None, tolerance=tolerance)
         return Graph.ByVerticesEdges(dictionary['vertices'], dictionary['edges'])
     
     @staticmethod