topologicpy 0.7.49__py3-none-any.whl → 0.7.51__py3-none-any.whl

topologicpy/Color.py

@@ -371,7 +371,7 @@ class Color:
         Parameters
         ----------
         color : list
-            The input color list. This is assumed to be in the format [r, g, b] or [r, g, b, a]
+            The input color list. This is assumed to be in the format [r, g, b] or [r, g, b, a] where the range is from 0 to 255.
         alpha : float , optional
             The transparency value. 0.0 means the color is fully transparent, 1.0 means the color is fully opaque. The default is 1.0.
         useAlpha : bool , optional

topologicpy/Dictionary.py

@@ -642,10 +642,8 @@ class Dictionary():
             The value found at the input key in the input dictionary.
 
         """
-        import json
         from topologicpy.Topology import Topology
         
-        
         if not Topology.IsInstance(dictionary, "Dictionary") and not isinstance(dictionary, dict):
             print("Dictionary.ValueAtKey - Error: The input dictionary parameter is not a valid topologic or python dictionary. Returning None.")
             return None

topologicpy/Face.py

@@ -2373,7 +2373,7 @@ class Face():
             from topologicpy.Face import Face
 
             if not Topology.IsInstance(face, "Face"):
-                print("Shell.ByMeshFace - Error: The input face parameter is not a valid face. Returning None.")
+                print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
                 return None
             if not meshSize:
                 bounding_face = Face.BoundingRectangle(face)
@@ -2477,9 +2477,11 @@ class Face():
                 wire = Face.ExternalBoundary(f)
                 wire = Wire.Invert(wire)
                 f = Face.ByWire(wire)
-                finalFaces.append(f)
+                if Topology.IsInstance(f, "Face"):
+                    finalFaces.append(f)
             else:
-                finalFaces.append(f)
+                if Topology.IsInstance(f, "face"):
+                    finalFaces.append(f)
         face_normal = Face.Normal(face)
         return_faces = []
         for ff in finalFaces:

topologicpy/Plotly.py

@@ -372,12 +372,11 @@ class Plotly:
                     v_label = ""
                     v_group = ""
                     d = Topology.Dictionary(v)
-                    v_group = Dictionary.ValueAtKey(d, key=vertexGroupKey)
                     if d:
                         if vertexLabelKey:
                             v_label = str(Dictionary.ValueAtKey(d, key=vertexLabelKey)) or ""
                         if vertexGroupKey:
-                            v_group = Dictionary.ValueAtKey(d, key=vertexGroupKey) or None
+                            v_group = Dictionary.ValueAtKey(d, key=vertexGroupKey) or ""
                     try:
                         v_groupList.append(vertexGroups.index(v_group))
                     except:
@@ -439,14 +438,10 @@ class Plotly:
                     e_group = ""
                     d = Topology.Dictionary(e)
                     if d:
-                        try:
+                        if not edgeLabelKey == None:
                             e_label = str(Dictionary.ValueAtKey(d, key=edgeLabelKey)) or ""
-                        except:
-                            e_label = ""
-                        try:
+                        if not edgeGroupKey == None:
                             e_group = str(Dictionary.ValueAtKey(d, key=edgeGroupKey)) or ""
-                        except:
-                            e_group = ""
                     try:
                         e_groupList.append(edgeGroups.index(e_group))
                     except:
@@ -490,12 +485,12 @@ class Plotly:
     @staticmethod
     def DataByTopology(topology,
                        showVertices=True, vertexSize=1.1, vertexColor="black", 
-                       vertexLabelKey=None, vertexGroupKey=None, vertexGroups=[], 
+                       vertexLabelKey=None, showVertexLabel=False, vertexGroupKey=None, vertexGroups=[], 
                        vertexMinGroup=None, vertexMaxGroup=None, 
                        showVertexLegend=False, vertexLegendLabel="Topology Vertices", vertexLegendRank=1,
                        vertexLegendGroup=1,
                        showEdges=True, edgeWidth=1, edgeColor="black", 
-                       edgeLabelKey=None, edgeGroupKey=None, edgeGroups=[], 
+                       edgeLabelKey=None, showEdgeLabel=False, edgeGroupKey=None, edgeGroups=[], 
                        edgeMinGroup=None, edgeMaxGroup=None, 
                        showEdgeLegend=False, edgeLegendLabel="Topology Edges", edgeLegendRank=2, 
                        edgeLegendGroup=2,
@@ -633,7 +628,7 @@ class Plotly:
         def closest_index(input_value, values):
             return int(min(range(len(values)), key=lambda i: abs(values[i] - input_value)))
 
-        def vertexData(vertices, dictionaries=[], color="black", size=1.1, labelKey=None, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Vertices", legendGroup=1, legendRank=1, showLegend=True, colorScale="Viridis"):
+        def vertexData(vertices, dictionaries=[], color="black", size=1.1, labelKey=None, showVertexLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Vertices", legendGroup=1, legendRank=1, showLegend=True, colorScale="Viridis"):
             x = []
             y = []
             z = []
@@ -664,16 +659,14 @@ class Plotly:
                     if len(dictionaries) > 0:
                         d = dictionaries[m]
                         if d:
-                            try:
+                            if not labelKey == None:
                                 label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
-                            except:
-                                label = ""
-                            try:
-                                group = Dictionary.ValueAtKey(d, key=groupKey) or None
-                            except:
-                                group = ""
+                            if not groupKey == None:
+                                group = Dictionary.ValueAtKey(d, key=groupKey) or ""
                         try:
-                            if type(group) == int or type(group) == float:
+                            if group == "":
+                                color = 'white'
+                            elif type(group) == int or type(group) == float:
                                 if group < minGroup:
                                     group = minGroup
                                 if group > maxGroup:
@@ -696,13 +689,17 @@ class Plotly:
                 groupList = color
             if len(labels) < 1:
                 labels = ""
+            if showVertexLabel == True:
+                mode = "markers+text"
+            else:
+                mode = "markers"
             vData= go.Scatter3d(x=x,
                                 y=y,
                                 z=z,
                                 name=legendLabel,
                                 showlegend=showLegend,
                                 marker=dict(color=groupList,  size=vertexSize),
-                                mode='markers',
+                                mode=mode,
                                 legendgroup=legendGroup,
                                 legendrank=legendRank,
                                 text=labels,
@@ -711,7 +708,7 @@ class Plotly:
                                 )
             return vData
 
-        def edgeData(vertices, edges, dictionaries=None, color="black", width=1, labelKey=None, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
+        def edgeData(vertices, edges, dictionaries=None, color="black", width=1, labelKey=None, showEdgeLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
             x = []
             y = []
             z = []
@@ -744,15 +741,13 @@ class Plotly:
                     if len(dictionaries) > 0:
                         d = dictionaries[m]
                         if d:
-                            try:
+                            if not labelKey == None:
                                 label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
-                            except:
-                                label = ""
-                            try:
-                                group = Dictionary.ValueAtKey(d, key=groupKey) or None
-                            except:
-                                group = ""
+                            if not groupKey == None:
+                                group = Dictionary.ValueAtKey(d, key=groupKey) or ""
                         try:
+                            if group == "":
+                                color = 'white'
                             if type(group) == int or type(group) == float:
                                 if group < minGroup:
                                     group = minGroup
@@ -778,13 +773,17 @@ class Plotly:
                     groupList = color
             if len(labels) < 1:
                 labels = ""
+            if showEdgeLabel == True:
+                mode = "lines+text"
+            else:
+                mode = "lines"
             eData = go.Scatter3d(x=x,
                                 y=y,
                                 z=z,
                                 name=legendLabel,
                                 showlegend=showLegend,
                                 marker_size=0,
-                                mode="lines",
+                                mode=mode,
                                 line=dict(color=groupList, width=edgeWidth),
                                 legendgroup=legendGroup,
                                 legendrank=legendRank,
@@ -834,16 +833,14 @@ class Plotly:
                     if len(dictionaries) > 0:
                         d = dictionaries[m]
                         if d:
-                            try:
+                            if not labelKey == None:
                                 label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
-                            except:
-                                label = ""
-                            try:
+                            if not groupKey == None:
                                 group = Dictionary.ValueAtKey(d, key=groupKey) or None
-                            except:
-                                group = ""
                         try:
-                            if type(group) == int or type(group) == float:
+                            if group == "":
+                                color = 'white'
+                            elif type(group) == int or type(group) == float:
                                 if group < minGroup:
                                     group = minGroup
                                 if group > maxGroup:
@@ -955,7 +952,7 @@ class Plotly:
                             d = Topology.Dictionary(tp_v)
                             v_dictionaries.append(d)
                         vertices.append([Vertex.X(tp_v, mantissa=mantissa), Vertex.Y(tp_v, mantissa=mantissa), Vertex.Z(tp_v, mantissa=mantissa)])
-                data.append(vertexData(vertices, dictionaries=v_dictionaries, color=vertexColor, size=vertexSize, labelKey=vertexLabelKey, groupKey=vertexGroupKey, minGroup=vertexMinGroup, maxGroup=vertexMaxGroup, groups=vertexGroups, legendLabel=vertexLegendLabel, legendGroup=vertexLegendGroup, legendRank=vertexLegendRank, showLegend=showVertexLegend, colorScale=colorScale))
+                data.append(vertexData(vertices, dictionaries=v_dictionaries, color=vertexColor, size=vertexSize, labelKey=vertexLabelKey, showVertexLabel=showVertexLabel, groupKey=vertexGroupKey, minGroup=vertexMinGroup, maxGroup=vertexMaxGroup, groups=vertexGroups, legendLabel=vertexLegendLabel, legendGroup=vertexLegendGroup, legendRank=vertexLegendRank, showLegend=showVertexLegend, colorScale=colorScale))
             
         if showEdges and Topology.Type(topology) > Topology.TypeID("Vertex"):
             if Topology.Type(topology) == Topology.TypeID("Edge"):
@@ -971,7 +968,7 @@ class Plotly:
                 geo = Topology.Geometry(e_cluster, mantissa=mantissa)
                 vertices = geo['vertices']
                 edges = geo['edges']
-                data.append(edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, width=edgeWidth, labelKey=edgeLabelKey, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
+                data.append(edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, width=edgeWidth, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
         
         if showFaces and Topology.Type(topology) >= Topology.TypeID("Face"):
             if Topology.IsInstance(topology, "Face"):

topologicpy/Topology.py

@@ -1477,8 +1477,144 @@ class Topology():
                 st = None
         return st
     
+
+    @staticmethod
+    def ByGeometry(vertices=[], edges=[], faces=[], topologyType = None, tolerance=0.0001):
+        """
+        Create a topology by the input lists of vertices, edges, and faces.
+
+        Parameters
+        ----------
+        vertices : list
+            The input list of vertices in the form of [x, y, z]
+        edges : list , optional
+            The input list of edges in the form of [i, j] where i and j are vertex indices.
+        faces : list , optional
+            The input list of faces in the form of [i, j, k, l, ...] where the items in the list are vertex indices. The face is assumed to be closed to the last vertex is connected to the first vertex automatically.
+        topologyType : str , optional
+            The desired topology type. The options are: "Vertex", "Edge", "Wire", "Face", "Shell", "Cell", "CellComplex". If set to None, a "Cluster" will be returned. The default is None.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topology : topologic_core.Topology
+            The created topology. The topology will have a dictionary embedded in it that records the input attributes (color, id, lengthUnit, name, type)
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Shell import Shell
+        from topologicpy.Cell import Cell
+        from topologicpy.CellComplex import CellComplex
+        from topologicpy.Cluster import Cluster
+
+        def topologyByFaces(faces, topologyType, tolerance):
+            if len(faces) == 1:
+                return faces[0]
+
+            output = None
+            if topologyType == "cell":
+                c = Cell.ByFaces(faces, tolerance=tolerance)
+                if Topology.IsInstance(c, "Cell"):
+                    output = c
+                else:
+                    cc = CellComplex.ByFaces(faces, tolerance=tolerance)
+                    if Topology.IsInstance(cc, "CellComplex"):
+                        output = CellComplex.ExternalBoundary(cc)
+            elif topologyType == "cellcomplex":
+                output = CellComplex.ByFaces(faces, tolerance=tolerance)
+                if Topology.IsInstance(output, "CellComplex"):
+                    cells = Topology.Cells(output)
+                    if len(cells) == 1:
+                        output = cells[0]
+                else:
+                    output = Cluster.ByTopologies(faces)
+            elif topologyType == "shell":
+                output = Shell.ByFaces(faces, tolerance=tolerance)  # This can return a list
+                if Topology.IsInstance(output, "Shell"):
+                    return output
+            elif topologyType == None:
+                output = Cluster.ByTopologies(faces)
+
+            return output
+
+        def topologyByEdges(edges, topologyType):
+            if len(edges) == 1:
+                return edges[0]
+
+            output = Cluster.ByTopologies(edges)
+            if topologyType.lower() == "wire":
+                output = Topology.SelfMerge(output, tolerance=tolerance)
+                if Topology.IsInstance(output, "Wire"):
+                    return output
+                return None
+            return output
+
+        vertices = [v for v in vertices if v]
+        edges = [e for e in edges if e]
+        faces = [f for f in faces if f]
+
+        if not vertices:
+            return None
+
+        topVerts = [Vertex.ByCoordinates(v[0], v[1], v[2]) for v in vertices]
+        topEdges = []
+        topFaces = []
+
+        if not topologyType == None:
+            topologyType = topologyType.lower()
+
+        if topologyType == "vertex":
+            if len(topVerts) >= 1:
+                return topVerts[0]
+            else:
+                return None
+        elif topologyType == "edge":
+            if len(edges) >= 1 and len(vertices) >= 2:
+                return Edge.ByVertices(topVerts[edges[0][0]], topVerts[edges[0][1]], tolerance=tolerance)
+            else:
+                return None
+
+        if topologyType == "wire" and edges:
+            topEdges = [Edge.ByVertices([topVerts[e[0]], topVerts[e[1]]], tolerance=tolerance) for e in edges]
+            if topEdges:
+                returnTopology = topologyByEdges(topEdges, topologyType)
+        elif faces:
+            for aFace in faces:
+                faceEdges = [Edge.ByVertices([topVerts[aFace[i]], topVerts[aFace[i + 1]]], tolerance=tolerance) for i in range(len(aFace) - 1)]
+                # Connect the last vertex to the first one
+                faceEdges.append(Edge.ByVertices([topVerts[aFace[-1]], topVerts[aFace[0]]], tolerance=tolerance))
+
+                if len(faceEdges) > 2:
+                    faceWire = Wire.ByEdges(faceEdges, tolerance=tolerance)
+                    try:
+                        topFace = Face.ByWire(faceWire, tolerance=tolerance, silent=True)
+                        if Topology.IsInstance(topFace, "Face"):
+                            topFaces.append(topFace)
+                        elif isinstance(topFace, list):
+                            topFaces.extend(topFace)
+                    except:
+                        pass
+            if topFaces:
+                returnTopology = topologyByFaces(topFaces, topologyType=topologyType, tolerance=tolerance)
+        elif edges:
+            topEdges = [Edge.ByVertices([topVerts[e[0]], topVerts[e[1]]], tolerance=tolerance) for e in edges]
+            if topEdges:
+                returnTopology = topologyByEdges(topEdges, topologyType)
+        else:
+            returnTopology = Cluster.ByTopologies(topVerts)
+        return returnTopology
+
+
+
+
+
+
     @staticmethod
-    def ByGeometry(vertices=[], edges=[], faces=[], color=[1.0, 1.0, 1.0, 1.0], id=None, name=None, lengthUnit="METERS", outputMode="default", tolerance=0.0001):
+    def ByGeometry_old(vertices=[], edges=[], faces=[], color=[1.0, 1.0, 1.0, 1.0], id=None, name=None, lengthUnit="METERS", outputMode="default", tolerance=0.0001):
         """
         Create a topology by the input lists of vertices, edges, and faces.
 
@@ -2201,7 +2337,215 @@ class Topology():
         return Topology.ByDXFFile(file, sides=sides)
 
     @staticmethod
-    def ByIFCFile(file, includeTypes=[], excludeTypes=[], transferDictionaries=False, removeCoplanarFaces=False):
+    def ByIFCFile(file, includeTypes=[], excludeTypes=[], transferDictionaries=False, removeCoplanarFaces=False, epsilon=0.0001, tolerance=0.0001):
+        """
+        Create a list of topologies by importing them from an IFC file.
+
+        Parameters
+        ----------
+        file : file object
+            The input IFC file.
+        includeTypes : list , optional
+            The list of IFC object types to include. It is case insensitive. If set to an empty list, all types are included. The default is [].
+        excludeTypes : list , optional
+            The list of IFC object types to exclude. It is case insensitive. If set to an empty list, no types are excluded. The default is [].
+        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.
+        removeCoplanarFaces : bool , optional
+            If set to True, coplanar faces are removed. Otherwise they are not. The default is False.
+        epsilon : float , optional
+                The desired epsilon (another form of tolerance) for finding if two faces are coplanar. The default is 0.0001.
+            tolerance : float , optional
+                The desired tolerance. The default is 0.0001.
+        Returns
+        -------
+        list
+            The created list of topologies.
+        
+        """
+
+        import ifcopenshell
+        from topologicpy.Dictionary import Dictionary
+
+        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 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 = (0.4, 0.4, 0.4)
+            elif "slab" in is_a:
+                color = (0.6, 0.6, 0.6)
+            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 convert_to_topology(entity, settings):    
+            if hasattr(entity, "Representation") and entity.Representation:
+                for rep in entity.Representation.Representations:
+                    if rep.is_a("IfcShapeRepresentation"):
+                        # Generate the geometry for this entity
+                        shape = ifcopenshell.geom.create_shape(settings, entity)
+                        shape_geometry = shape.geometry
+                        verts = shape_geometry.verts
+                        verts = [ [verts[i], verts[i + 1], verts[i + 2]] for i in range(0, len(verts), 3)]
+                        edges = shape_geometry.edges
+                        edges = [[edges[i], edges[i + 1]] for i in range(0, len(edges), 2)]
+                        faces = shape_geometry.faces
+                        faces = [ [faces[i], faces[i + 1], faces[i + 2]] for i in range(0, len(faces), 3)]
+                        # Convert geometry to Topologic format
+                        #shape_topology = ifc_to_topologic_geometry(verts, edges, faces)
+                        #shape_topology = Topology.SelfMerge(Topology.ByGeometry(verts, edges, faces))
+                        shape_topology = Topology.ByGeometry(verts, edges, faces, topologyType="CellComplex")
+                        if removeCoplanarFaces == True:
+                            shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
+
+                        # Store relevant information
+                        color, transparency, material_list = get_color_transparency_material(entity)
+                        entity_dict = {
+                            "TOPOLOGIC_id": str(Topology.UUID(shape_topology)),
+                            "TOPOLOGIC_name": getattr(entity, 'Name', "Untitled"),
+                            "TOPOLOGIC_type": Topology.TypeAsString(shape_topology),
+                            "TOPOLOGIC_color": color,
+                            "TOPOLOGIC_opacity": 1.0 - transparency,
+                            "IFC_global_id": getattr(entity, 'GlobalId', 0),
+                            "IFC_name": getattr(entity, 'Name', "Untitled"),
+                            "IFC_type": entity.is_a(),
+                            "IFC_material_list": material_list,
+                        }
+                        topology_dict = Dictionary.ByPythonDictionary(entity_dict)
+                        # Get PSETs dictionary
+                        pset_python_dict = get_psets(entity)
+                        pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
+                        topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
+                        shape_topology = Topology.SetDictionary(shape_topology, topology_dict)
+                        return shape_topology
+            return None
+
+        # Main Code
+        topologies = []
+        settings = ifcopenshell.geom.settings()
+        settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.SOLID)
+        settings.set(settings.USE_WORLD_COORDS, True)
+        products = file.by_type("IfcProduct")
+        entities = []
+        for product in products:
+            is_a = product.is_a()
+            if (is_a in includeTypes or len(includeTypes) == 0) and (not is_a in excludeTypes):
+                entities.append(product)
+        topologies = []
+        for entity in entities:
+            topologies.append(convert_to_topology(entity, settings))
+        return topologies
+
+    @staticmethod
+    def _ByIFCFile_old(file, includeTypes=[], excludeTypes=[], transferDictionaries=False, removeCoplanarFaces=False):
         """
         Create a topology by importing it from an IFC file.
 
@@ -2227,7 +2571,11 @@ class Topology():
         from topologicpy.Cluster import Cluster
         from topologicpy.Dictionary import Dictionary
         import uuid
-        
+        import random
+        import hashlib
+        import re
+        import numpy as np
+
         try:
             import ifcopenshell
             import ifcopenshell.geom
@@ -2247,61 +2595,342 @@ class Topology():
         if not file:
             print("Topology.ByIFCFile - Error: the input file parameter is not a valid file. Returning None.")
             return None
-        includeTypes = [s.lower() for s in includeTypes]
-        excludeTypes = [s.lower() for s in excludeTypes]
-        topologies = []
-        settings = ifcopenshell.geom.settings()
-        settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS)
-        settings.set(settings.USE_WORLD_COORDS, True)
-        iterator = ifcopenshell.geom.iterator(settings, file, multiprocessing.cpu_count())
-        if iterator.initialize():
-            while True:
-                shape = iterator.get()
-                is_a = shape.type.lower()
-                if (is_a in includeTypes or len(includeTypes) == 0) and (not is_a in excludeTypes):                    
-                    try:
-                        verts = shape.geometry.verts
-                        edges = shape.geometry.edges
-                        faces = shape.geometry.faces
+        
+        def clean_key(string):
+            # Replace any character that is not a letter, digit, or underscore with an underscore
+            cleaned_string = re.sub(r'[^a-zA-Z0-9_]', '_', string)
+            return cleaned_string
+        
+        def transform_wall_vertices(wall):
+
+            # Relatives Placement abrufen und ausgeben
+            if wall.ObjectPlacement and wall.ObjectPlacement.RelativePlacement:
+                relative_placement = wall.ObjectPlacement.RelativePlacement
+                if relative_placement.is_a('IFCAXIS2PLACEMENT3D'):
+                    location = relative_placement.Location
+                    ref_direction = relative_placement.RefDirection
+                    print("Relative Placement Location:", location.Coordinates)
+                    if ref_direction:
+                        print("Relative Placement RefDirection:", ref_direction.DirectionRatios)
+                    else:
+                        print("Relative Placement RefDirection: None")
+
+            # IFCPRODUCTDEFINITIONSHAPE der Wand abrufen
+            product_definition_shape = wall.Representation
+            if not product_definition_shape:
+                print("Keine Repräsentation gefunden.")
+                return
+
+            # Initialisieren von Variablen für Representation Type und Layer-Infos
+            representation_type = None
+            diverse_representation = False
+            layer_details = []
+
+            if hasattr(product_definition_shape, 'HasShapeAspects'):
+                for aspect in product_definition_shape.HasShapeAspects:
+                    for representation in aspect.ShapeRepresentations:
+                        if representation.is_a('IFCSHAPEREPRESENTATION'):
+                            for item in representation.Items:
+                                if item.is_a('IFCEXTRUDEDAREASOLID'):
+                                    # Profilbeschreibung abrufen
+                                    profile = item.SweptArea
+                                    if profile.is_a('IFCARBITRARYCLOSEDPROFILEDEF'):
+                                        if not representation_type:
+                                            representation_type = "ArbitraryClosedProfil"
+                                        elif representation_type != "ArbitraryClosedProfil":
+                                            diverse_representation = True
+
+                                        # Profilpunkte abrufen
+                                        if hasattr(profile, 'OuterCurve') and profile.OuterCurve.is_a('IFCINDEXEDPOLYCURVE'):
+                                            indexed_polycurve = profile.OuterCurve
+                                            if hasattr(indexed_polycurve, 'Points') and indexed_polycurve.Points.is_a('IFCCARTESIANPOINTLIST2D'):
+                                                point_list_2d = indexed_polycurve.Points
+                                                points = point_list_2d.CoordList
+                                                layer_info["Profilpunkte"] = points
+                                    else:
+                                        diverse_representation = True
+
+                                    # Location und RefDirection abrufen
+                                    if item.Position.is_a('IFCAXIS2PLACEMENT3D'):
+                                        axis_placement = item.Position
+                                        location = axis_placement.Location
+                                        ref_direction = axis_placement.RefDirection
+                                        layer_info["Location"] = location.Coordinates
+                                        if ref_direction:
+                                            layer_info["RefDirection"] = ref_direction.DirectionRatios
+                                        else:
+                                            layer_info["RefDirection"] = None
+
+                    layer_details.append(layer_info)
+
+            # Representation Type ausgeben
+            if diverse_representation:
+                representation_type = "divers"
+            print("Representation Type der Wand:", representation_type)
+
+            # Layer-Details ausgeben
+            for index, layer in enumerate(layer_details):
+                print(f"\nLayer {index + 1} Details:")
+                print("Material:", layer.get("Material", "Nicht verfügbar"))
+                print("Extrusionsstärke:", layer.get("Extrusionsstärke", "Nicht verfügbar"))
+                print("Profilpunkte:", layer.get("Profilpunkte", "Nicht verfügbar"))
+                print("Location:", layer.get("Location", "Nicht verfügbar"))
+                print("RefDirection:", layer.get("RefDirection", "Nicht verfügbar"))
+
+
+
+
+
+
+        def extract_matrix_from_placement(placement):
+            """Constructs a transformation matrix from an IFC Local Placement."""
+            # Initialize identity matrix
+            matrix = np.identity(4)
+
+            # Check if the placement is IfcLocalPlacement
+            if placement.is_a("IfcLocalPlacement"):
+                relative_placement = placement.RelativePlacement
+
+                if relative_placement.is_a("IfcAxis2Placement3D"):
+                    location = relative_placement.Location.Coordinates
+                    z_dir = relative_placement.Axis.DirectionRatios if relative_placement.Axis else [0, 0, 1]
+                    x_dir = relative_placement.RefDirection.DirectionRatios if relative_placement.RefDirection else [1, 0, 0]
+                    
+                    # Compute y direction (cross product of z and x)
+                    y_dir = np.cross(z_dir, x_dir)
+                    
+                    # Construct the rotation matrix
+                    rotation_matrix = np.array([
+                        [x_dir[0], y_dir[0], z_dir[0], 0],
+                        [x_dir[1], y_dir[1], z_dir[1], 0],
+                        [x_dir[2], y_dir[2], z_dir[2], 0],
+                        [0, 0, 0, 1]
+                    ])
+
+                    # Translation vector
+                    translation_vector = np.array([
+                        [1, 0, 0, location[0]],
+                        [0, 1, 0, location[1]],
+                        [0, 0, 1, location[2]],
+                        [0, 0, 0, 1]
+                    ])
+
+                    # Combine the rotation matrix and the translation vector
+                    matrix = np.dot(translation_vector, rotation_matrix)
+
+            return matrix
+
+        def apply_transformation(verts, matrix):
+            """Applies a 4x4 transformation matrix to a list of vertices."""
+            transformed_verts = []
+            for vert in verts:
+                print("vert:", vert)
+                v = np.array([vert[0], vert[1], vert[2], 1.0])
+                transformed_v = np.dot(matrix, v)
+                transformed_verts.append([transformed_v[0], transformed_v[1], transformed_v[2]])
+            return transformed_verts
+        
+        def get_entity_transformation_matrix(entity):
+            """Extracts the transformation matrix from an IFC entity."""
+            matrix = np.identity(4)  # Default to an identity matrix
+            if hasattr(entity, "ObjectPlacement") and entity.ObjectPlacement:
+                placement = entity.ObjectPlacement
+                matrix = extract_matrix_from_placement(placement)
+            return matrix
+    
+        # Function to generate a unique random color based on material ID
+        def generate_color_for_material(material_id):
+            # Use a hash function to get a consistent "random" seed
+            hash_object = hashlib.sha1(material_id.encode())
+            seed = int(hash_object.hexdigest(), 16) % (10 ** 8)
+            random.seed(seed)
+            # Generate a random color
+            r = random.random()
+            g = random.random()
+            b = random.random()
+            return [r, g, b]
+        
+        # Function to get the material IDs associated with an entity
+        def get_material_ids_of_entity(entity):
+            return_dict = {}
+            material_names = []
+            material_ids = []
+            if hasattr(entity, "HasAssociations"):
+                for association in entity.HasAssociations:
+                    if association.is_a("IfcRelAssociatesMaterial"):
+                        material = association.RelatingMaterial
+                        try:
+                            material_name = material.Name
+                        except:
+                            material_name = material.to_string()
+                        if material.is_a("IfcMaterial"):
+                            material_ids.append(material.id())
+                            material_names.append(material_name)
+                            return_dict[clean_key(material_name)] = material.id
+                        elif material.is_a("IfcMaterialList"):
+                            for mat in material.Materials:
+                                material_ids.append(mat.id())
+                                try:
+                                    material_name = mat.Name
+                                except:
+                                    material_name = mat.to_string()
+                                material_names.append(material_name)
+                                return_dict[clean_key(material_name)] = mat.id
+                        elif material.is_a("IfcMaterialLayerSetUsage") or material.is_a("IfcMaterialLayerSet"):
+                            for layer in material.ForLayerSet.MaterialLayers:
+                                material_ids.append(layer.Material.id())
+                                try:
+                                    material_name = layer.Name
+                                except:
+                                    material_name = layer.to_string()
+                                material_names.append(material_name)
+                                return_dict[clean_key(material_name)] = layer.Material.id()
+                        elif material.is_a("IfcMaterialConstituentSet"):
+                            for constituent in material.MaterialConstituents:
+                                material_ids.append(constituent.Material.id())
+                                try:
+                                    material_name = constituent.Material.Name
+                                except:
+                                    material_name = constituent.Material.to_string()
+                                material_names.append(material_name)
+                                return_dict[clean_key(material_name)] = constituent.Material.id()
+            
+            return return_dict
+        
+        def get_wall_layers(wall, matrix=None, transferDictionaries=False):
+            settings = ifcopenshell.geom.settings()
+            settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS)
+            settings.set(settings.USE_WORLD_COORDS, False)
+
+            # IFCPRODUCTDEFINITIONSHAPE der Wand abrufen
+            product_definition_shape = wall.Representation
+            if not product_definition_shape:
+                print("Topology.ByIFCFile - Error: The object has no representation. Returning None")
+                return None
+
+            if hasattr(product_definition_shape, 'HasShapeAspects'):
+                for aspect in product_definition_shape.HasShapeAspects:
+                    material_name = aspect.Name
+                    for representation in aspect.ShapeRepresentations:
+                        print(dir(representation))
+                        axis_placement = representation.Position
+                        location = axis_placement.Location
+                        ref_direction = axis_placement.RefDirection
+                        print("Location:", location)
+                        print("Direction", ref_direction)
+                        aspect_matrix = get_entity_transformation_matrix(representation)
+                        print("Aspect Matrix:", aspect_matrix)
+                        shape = ifcopenshell.geom.create_shape(settings, representation)
+                        verts = shape.verts
+                        edges = shape.edges
+                        faces = shape.faces
                         grouped_verts = [ [verts[i], verts[i + 1], verts[i + 2]] for i in range(0, len(verts), 3)]
+                        grouped_verts = apply_transformation(grouped_verts, aspect_matrix)
                         grouped_edges = [[edges[i], edges[i + 1]] for i in range(0, len(edges), 2)]
                         grouped_faces = [ [faces[i], faces[i + 1], faces[i + 2]] for i in range(0, len(faces), 3)]
-                        topology = Topology.ByGeometry(grouped_verts, grouped_edges, grouped_faces)
-                        if removeCoplanarFaces:
-                            topology = Topology.RemoveCoplanarFaces(topology)
-                        topologies.append(topology)
+                        topology = Topology.SelfMerge(Topology.ByGeometry(grouped_verts, grouped_edges, grouped_faces))
+                        #matrix = shape.transformation.matrix
+                        #topology = Topology.Transform(topology, matrix)
+                        d = get_material_ids_of_entity(wall)
+                        material_id = d.get(clean_key(material_name), 0)
                         if transferDictionaries:
                             keys = []
                             values = []
-                            keys.append("TOPOLOGIC_color")
-                            values.append([1.0, 1.0, 1.0, 1.0])
+                            try:
+                                entity_name = entity.Name
+                            except:
+                                entity_name = entity.to_str()
                             keys.append("TOPOLOGIC_id")
                             values.append(str(uuid.uuid4()))
                             keys.append("TOPOLOGIC_name")
-                            values.append(shape.name)
+                            values.append(entity_name)
                             keys.append("TOPOLOGIC_type")
                             values.append(Topology.TypeAsString(topology))
                             keys.append("IFC_id")
-                            values.append(str(shape.id))
-                            keys.append("IFC_guid")
-                            values.append(str(shape.guid))
-                            keys.append("IFC_unique_id")
-                            values.append(str(shape.unique_id))
+                            values.append(str(aspect.id))
+                            #keys.append("IFC_guid")
+                            #values.append(str(aspect.guid))
+                            #keys.append("IFC_unique_id")
+                            #values.append(str(aspect.unique_id))
                             keys.append("IFC_name")
-                            values.append(shape.name)
-                            keys.append("IFC_type")
-                            values.append(shape.type)
+                            values.append(entity_name)
+                            #keys.append("IFC_type")
+                            #values.append(aspect.type)
+                            keys.append("IFC_material_id")
+                            values.append(material_id)
+                            keys.append("IFC_material_name")
+                            values.append(material_name)
+                            keys.append("TOPOLOGIC_color")
+                            color = generate_color_for_material(str(material_id))
+                            values.append(color)
                             d = Dictionary.ByKeysValues(keys, values)
                             topology = Topology.SetDictionary(topology, d)
-                        topologies.append(topology)
-                    except:
-                        pass
-                if not iterator.next():
-                    break
+                
+            return topology
+        
+        
+        includeTypes = [s.lower() for s in includeTypes]
+        excludeTypes = [s.lower() for s in excludeTypes]
+        topologies = []
+        settings = ifcopenshell.geom.settings()
+        settings.set("dimensionality", ifcopenshell.ifcopenshell_wrapper.SOLID)
+        settings.set(settings.USE_WORLD_COORDS, True)
+        for entity in file.by_type('IfcProduct'):  # You might want to refine the types you check
+                if hasattr(entity, "Representation") and entity.Representation:
+                    print("Number of Representations:", len(entity.Representation.Representations))
+                    for rep in entity.Representation.Representations:
+                        print("Rep:", rep)
+                        print(dir(rep))
+                        matrix = get_entity_transformation_matrix(entity)
+                        print(matrix)
+                        if rep.is_a("IfcShapeRepresentation"):
+                            # Generate the geometry for this entity
+                            shape = ifcopenshell.geom.create_shape(settings, rep)
+                            verts = shape.verts
+                            edges = shape.edges
+                            faces = shape.faces
+                            grouped_verts = [ [verts[i], verts[i + 1], verts[i + 2]] for i in range(0, len(verts), 3)]
+                            #grouped_verts = apply_transformation(grouped_verts, matrix)
+                            grouped_edges = [[edges[i], edges[i + 1]] for i in range(0, len(edges), 2)]
+                            grouped_faces = [ [faces[i], faces[i + 1], faces[i + 2]] for i in range(0, len(faces), 3)]
+                            topology = Topology.SelfMerge(Topology.ByGeometry(grouped_verts, grouped_edges, grouped_faces))
+                            if removeCoplanarFaces:
+                                topology = Topology.RemoveCoplanarFaces(topology)
+                            if transferDictionaries:
+                                keys = []
+                                values = []
+                                keys.append("TOPOLOGIC_id")
+                                values.append(str(uuid.uuid4()))
+                                keys.append("TOPOLOGIC_name")
+                                values.append(shape.name)
+                                keys.append("TOPOLOGIC_type")
+                                values.append(Topology.TypeAsString(topology))
+                                keys.append("IFC_id")
+                                values.append(str(shape.id))
+                                keys.append("IFC_guid")
+                                values.append(str(shape.guid))
+                                keys.append("IFC_unique_id")
+                                values.append(str(shape.unique_id))
+                                keys.append("IFC_name")
+                                values.append(shape.name)
+                                keys.append("IFC_type")
+                                values.append(shape.type)
+                                material_dict = get_material_ids_of_entity(entity)
+                                keys.append("IFC_materials")
+                                values.append(material_dict)
+                                #keys.append("IFC_material_name")
+                                #values.append(material_name)
+                                #keys.append("TOPOLOGIC_color")
+                                #color = generate_color_for_material(str(material_ids))
+                                #values.append(color)
+                                d = Dictionary.ByKeysValues(keys, values)
+                                topology = Topology.SetDictionary(topology, d)
+                                topology = Topology.Transform(topology, matrix)
+                            topologies.append(topology)
         return topologies
 
     @staticmethod
-    def ByIFCPath(path, includeTypes=[], excludeTypes=[], transferDictionaries=False, removeCoplanarFaces=False):
+    def ByIFCPath(path, includeTypes=[], excludeTypes=[], transferDictionaries=False, removeCoplanarFaces=False, epsilon=0.0001, tolerance=0.0001):
         """
         Create a topology by importing it from an IFC file path.
 
@@ -2317,7 +2946,10 @@ class Topology():
             If set to True, the dictionaries from the IFC file will be transferred to the topology. Otherwise, they won't. The default is False.
         removeCoplanarFaces : bool , optional
             If set to True, coplanar faces are removed. Otherwise they are not. The default is False.
-        
+        epsilon : float , optional
+            The desired epsilon (another form of tolerance) for finding if two faces are coplanar. The default is 0.0001.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
         Returns
         -------
         list
@@ -2336,7 +2968,7 @@ class Topology():
         if not file:
             print("Topology.ByIFCPath - Error: the input file parameter is not a valid file. Returning None.")
             return None
-        return Topology.ByIFCFile(file, includeTypes=includeTypes, excludeTypes=excludeTypes, transferDictionaries=transferDictionaries, removeCoplanarFaces=removeCoplanarFaces)
+        return Topology.ByIFCFile(file, includeTypes=includeTypes, excludeTypes=excludeTypes, transferDictionaries=transferDictionaries, removeCoplanarFaces=removeCoplanarFaces, epsilon=epsilon, tolerance=tolerance)
     
     '''
     @staticmethod
@@ -5460,6 +6092,20 @@ class Topology():
         flat_topology = Topology.Translate(topology, -Vertex.X(origin, mantissa=mantissa), -Vertex.Y(origin, mantissa=mantissa), -Vertex.Z(origin, mantissa=mantissa))
         tran_mat = Vector.TransformationMatrix(direction, up)
         flat_topology = Topology.Transform(flat_topology, tran_mat)
+        flat_topology = Topology.SetDictionary(flat_topology, Topology.Dictionary(topology), silent=True)
+        flat_vertices = Topology.Vertices(flat_topology)
+        vertices = Topology.Vertices(topology)
+        flat_edges = Topology.Edges(flat_topology)
+        edges = Topology.Edges(topology)
+        faces = []
+        flat_faces = []
+        if Topology.IsInstance(topology, "Face"):
+            flat_faces = Topology.Faces(flat_topology)
+            faces = Topology.Faces(topology)
+        elements = vertices+edges+faces
+        flat_elements = flat_vertices+flat_edges+flat_faces
+        for i, f, in enumerate(flat_elements):
+            f = Topology.SetDictionary(f, Topology.Dictionary(elements[i]), silent=True)
         return flat_topology
     
     @staticmethod
@@ -6906,20 +7552,30 @@ class Topology():
 
         """
         from topologicpy.Dictionary import Dictionary
+        import inspect
 
         if not Topology.IsInstance(topology, "Topology") and not Topology.IsInstance(topology, "Graph"):
             if not silent:
                 print("Topology.SetDictionary - Error: the input topology parameter is not a valid topology or graph. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         if isinstance(dictionary, dict):
             dictionary = Dictionary.ByPythonDictionary(dictionary)
         if not Topology.IsInstance(dictionary, "Dictionary"):
             if not silent:
                 print("Topology.SetDictionary - Warning: the input dictionary parameter is not a valid dictionary. Returning original input.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return topology
         if len(dictionary.Keys()) < 1:
             if not silent:
                 print("Topology.SetDictionary - Warning: the input dictionary parameter is empty. Returning original input.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return topology
         _ = topology.SetDictionary(dictionary)
         return topology
@@ -7122,13 +7778,15 @@ class Topology():
              colorKey = "color",
              opacityKey = "opacity",
              showVertices=True, vertexSize=1.1, vertexColor="black", 
-             vertexLabelKey=None, vertexGroupKey=None, vertexGroups=[], 
+             vertexLabelKey=None, showVertexLabel= False,
+             vertexGroupKey=None, vertexGroups=[], 
              vertexMinGroup=None, vertexMaxGroup=None, 
              showVertexLegend=False, vertexLegendLabel="Topology Vertices", vertexLegendRank=1, 
              vertexLegendGroup=1, 
 
              showEdges=True, edgeWidth=1, edgeColor="black", 
-             edgeLabelKey=None, edgeGroupKey=None, edgeGroups=[], 
+             edgeLabelKey=None, showEdgeLabel = False,
+             edgeGroupKey=None, edgeGroups=[], 
              edgeMinGroup=None, edgeMaxGroup=None, 
              showEdgeLegend=False, edgeLegendLabel="Topology Edges", edgeLegendRank=2, 
              edgeLegendGroup=2, 
@@ -7173,6 +7831,8 @@ class Topology():
             The default is "black".
         vertexLabelKey : str , optional
             The dictionary key to use to display the vertex label. The default is None.
+        showVertexLabels : bool , optional
+            If set to True, the vertex labels are shown permenantely on screen. Otherwise, they are not. The default is False.
         vertexGroupKey : str , optional
             The dictionary key to use to display the vertex group. The default is None.
         vertexGroups : list , optional
@@ -7204,6 +7864,8 @@ class Topology():
             The default is "black".
         edgeLabelKey : str , optional
             The dictionary key to use to display the edge label. The default is None.
+        showEdgeLabels : bool , optional
+            If set to True, the edge labels are shown permenantely on screen. Otherwise, they are not. The default is False.
         edgeGroupKey : str , optional
             The dictionary key to use to display the edge group. The default is None.
         edgeGroups : list , optional
@@ -7356,12 +8018,12 @@ class Topology():
                 faceOpacity = Dictionary.ValueAtKey(d, opacityKey) or faceOpacity
             data += Plotly.DataByTopology(topology=topology,
                         showVertices=showVertices, vertexSize=vertexSize, vertexColor=vertexColor, 
-                        vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, 
+                        vertexLabelKey=vertexLabelKey, showVertexLabel=showVertexLabel, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, 
                         vertexMinGroup=vertexMinGroup, vertexMaxGroup=vertexMaxGroup, 
                         showVertexLegend=showVertexLegend, vertexLegendLabel=vertexLegendLabel, vertexLegendRank=vertexLegendRank,
                         vertexLegendGroup=vertexLegendGroup,
                         showEdges=showEdges, edgeWidth=edgeWidth, edgeColor=edgeColor, 
-                        edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, 
+                        edgeLabelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, 
                         edgeMinGroup=edgeMinGroup, edgeMaxGroup=edgeMaxGroup, 
                         showEdgeLegend=showEdgeLegend, edgeLegendLabel=edgeLegendLabel, edgeLegendRank=edgeLegendRank, 
                         edgeLegendGroup=edgeLegendGroup,
@@ -8494,11 +9156,30 @@ class Topology():
 
         """
         import uuid
+        from topologicpy.Dictionary import Dictionary
 
         predefined_namespace_dns = uuid.UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
         namespace_uuid = uuid.uuid5(predefined_namespace_dns, namespace)
-        brep_string = Topology.BREPString(topology)
-        return uuid.uuid5(namespace_uuid, brep_string)
+        cellComplexes = Topology.CellComplexes(topology)
+        cells = Topology.Cells(topology)
+        Shells = Topology.Shells(topology)
+        Faces = Topology.Faces(topology)
+        Wires = Topology.Wires(topology)
+        Edges = Topology.Edges(topology)
+        Vertices = Topology.Vertices(topology)
+        Apertures = Topology.Apertures(topology, subTopologyType="all")
+        subTopologies = cellComplexes+cells+Shells+Faces+Wires+Edges+Vertices+Apertures
+        dictionaries = [Dictionary.PythonDictionary(Topology.Dictionary(topology))]
+        dictionaries += [Dictionary.PythonDictionary(Topology.Dictionary(s)) for s in subTopologies]
+        dict_str = str(dictionaries)
+        top_geom = Topology.Geometry(topology, mantissa=6)
+        verts_str = str(top_geom['vertices'])
+        edges_str = str(top_geom['edges'])
+        faces_str = str(top_geom['faces'])
+        geo_str = verts_str+edges_str+faces_str
+        final_str = geo_str+dict_str
+        uuid_str = uuid.uuid5(namespace_uuid, final_str)
+        return str(uuid_str)
     
     @staticmethod
     def View3D(*topologies, uuid = None, nameKey="name", colorKey="color", opacityKey="opacity", defaultColor=[256,256,256], defaultOpacity=0.5, transposeAxes: bool = True, mode: int = 0, meshSize: float = None, overwrite: bool = False, mantissa: int = 6, tolerance: float = 0.0001):

topologicpy/Wire.py

@@ -373,13 +373,14 @@ class Wire():
         normal = Face.Normal(temp_face)
         flat_wire = Topology.Flatten(wire, direction=normal, origin=origin)
         edges = Topology.Edges(flat_wire)
+        original_edges = Topology.Edges(wire)
         offsets = []
         offset_edges = []
         final_vertices = []
         bisectors_list = []
         edge_dictionaries = []
-        for edge in edges:
-            d = Topology.Dictionary(edge)
+        for i, edge in enumerate(edges):
+            d = Topology.Dictionary(original_edges[i])
             d_offset = Dictionary.ValueAtKey(d, offsetKey)
             if d_offset == None:
                 d_offset = offset
@@ -406,7 +407,7 @@ class Wire():
                         if bisectors == True:
                             bisectors_list.append(Edge.ByVertices(v_a, v1))
                         if transferDictionaries == True:
-                            v1 = Topology.SetDictionary(v1, Topology.Dictionary(v_a))
+                            v1 = Topology.SetDictionary(v1, Topology.Dictionary(v_a), silent=True)
                             edge_dictionaries.append(Topology.Dictionary(edges[i]))
                         final_vertices.append(v1)
                     else:
@@ -463,15 +464,15 @@ class Wire():
                         v1_2 = Topology.TranslateByDirectionDistance(Edge.StartVertex(o_edge_a),
                                                                      direction = Edge.Direction(o_edge_a),
                                                                      distance = d_stepOffsetB)
+                        if transferDictionaries == True:
+                            v1_1 = Topology.SetDictionary(v1_1, Topology.Dictionary(v_a), silent=True)
+                            v1_2 = Topology.SetDictionary(v1_2, Topology.Dictionary(v_a), silent=True)
+                            edge_dictionaries.append(Topology.Dictionary(v_a))
+                            edge_dictionaries.append(Topology.Dictionary(edges[i]))
                         bisectors_list.append(Edge.ByVertices(v_a, v1_1))
                         bisectors_list.append(Edge.ByVertices(v_a, v1_2))
                         final_vertices.append(v1_1)
                         final_vertices.append(v1_2)
-                        if transferDictionaries == True:
-                            v1_1 = Topology.SetDictionary(v1_1, Topology.Dictionary(v_a))
-                            v1_2 = Topology.SetDictionary(v1_2, Topology.Dictionary(v_a))
-                            edge_dictionaries.append(Topology.Dictionary(v_a))
-                            edge_dictionaries.append(Topology.Dictionary(edges[i]))
         v_a = Edge.EndVertex(edges[-1])
         if Wire.IsClosed(wire) == False:
             v1 = Edge.EndVertex(offset_edges[-1])
@@ -481,12 +482,7 @@ class Wire():
             if bisectors == True:
                 bisectors_list.append(Edge.ByVertices(v_a, v1))
         
-
         return_wire = Wire.ByVertices(final_vertices, close=Wire.IsClosed(wire))
-        wire_edges = Topology.Edges(return_wire)
-        if transferDictionaries == True:
-            for i, wire_edge in enumerate(wire_edges):
-                wire_edge = Topology.SetDictionary(wire_edge, edge_dictionaries[i], silent=True)
         if not Topology.IsInstance(return_wire, "Wire"):
             if not silent:
                 print("Wire.ByOffset - Warning: The resulting wire is not well-formed, please check your offsets.")
@@ -494,6 +490,18 @@ class Wire():
             if not Wire.IsManifold(return_wire) and bisectors == False:
                 if not silent:
                     print("Wire.ByOffset - Warning: The resulting wire is non-manifold, please check your offsets.")
+        wire_edges = Topology.Edges(return_wire)
+        
+        if transferDictionaries == True:
+            if not len(wire_edges) == len(edge_dictionaries):
+                if not silent:
+                        print("Length of Wire Edges:", len(wire_edges))
+                        print("Length of Edge Dictionaries:", len(edge_dictionaries))
+                        print("Wire.ByOffset - Warning: The resulting wire is not well-formed, offsets may not be applied correctly. Please check your offsets.")
+            for i, wire_edge in enumerate(wire_edges):
+                if len(edge_dictionaries) > 0:
+                    temp_dictionary = edge_dictionaries[min(i,len(edge_dictionaries)-1)]
+                    wire_edge = Topology.SetDictionary(wire_edge, temp_dictionary, silent=True)
         if bisectors == True:
             temp_return_wire = Topology.SelfMerge(Cluster.ByTopologies(Topology.Edges(return_wire)+bisectors_list))
             if transferDictionaries == True:
@@ -738,7 +746,7 @@ class Wire():
                     if not(([i1, i2] in g_edges) or ([i2, i1] in g_edges)):
                         g_edges.append([i1, i2])
                 used.append(end)
-        new_wire = Topology.ByGeometry(vertices=g_vertices, edges=g_edges, faces=[], outputMode="wire")
+        new_wire = Topology.SelfMerge(Topology.ByGeometry(vertices=g_vertices, edges=g_edges, faces=[]))
         return new_wire
 
     @staticmethod

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.49'
+__version__ = '0.7.51'

{topologicpy-0.7.49.dist-info → topologicpy-0.7.51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.49
+Version: 0.7.51
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: MIT License

{topologicpy-0.7.49.dist-info → topologicpy-0.7.51.dist-info}/RECORD

@@ -3,33 +3,33 @@ topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
 topologicpy/Cell.py,sha256=uZ1gNVlfVtpi6sNgyfazP_nqe7mPjarE7MYzf8KoEI4,107930
 topologicpy/CellComplex.py,sha256=x474N-lo1krpdIGrWRAFRdDup5a_1V-mLORTS6ZGZ7M,48227
 topologicpy/Cluster.py,sha256=TZXuxzdaUr6OHSWnjWpjCOMlVj6YHBH8aUVbDVsncVA,54999
-topologicpy/Color.py,sha256=UlmRcCSOhqcM_OyMWz4t3Kr75KcgXDhz3uctAJ2n7Ic,18031
+topologicpy/Color.py,sha256=FrxX2yILqWvYrqD8kBaknfMfOR_phJOmhvTvFc07bY4,18065
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
 topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
-topologicpy/Dictionary.py,sha256=KqJ29YyE23Y3Xc6XmKLSCZXRfBvm-OEOxlMZ4dt-rfM,27094
+topologicpy/Dictionary.py,sha256=X_WARSYtWtYIsEUKdLH-plZmGZ3pHz_FBFxxeHGHdrU,27065
 topologicpy/Edge.py,sha256=vhYHkobSLGSWV-oe2oJFFDobqFToDyb7s71yQ840AAA,65166
 topologicpy/EnergyModel.py,sha256=XcCP55VW5WHDIIKcURijmBOZEgNUDEn_V9h5EejkntA,53876
-topologicpy/Face.py,sha256=pn0LGusTPKLrHEMhY94_Bs3rc4wUpIyEqyW9q-ftdG0,115379
+topologicpy/Face.py,sha256=7GCYo4ATkMW1skiv4gXOVARM29A7Buim9lTQu57B22Y,115489
 topologicpy/Graph.py,sha256=1dtcE342b6d7cTiMbtUWWOud6Vu0vHaf4HP2eG_-iqg,402544
 topologicpy/Grid.py,sha256=3-sn7CHWGcXk18XCnHjsUttNJTWwmN63g_Insj__p04,18218
 topologicpy/Helper.py,sha256=i-AfI29NMsZXBaymjilfvxQbuS3wpYbpPw4RWu1YCHs,16358
 topologicpy/Honeybee.py,sha256=vcBECJlgWVjNNdD9ZmjNik_pA1Y_ZNoOorsQb2CiyGA,21965
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=YvtF7RYUMATEZ8iHwFwK_MOxEDyARby2DTI2CCK6-cI,19694
-topologicpy/Plotly.py,sha256=o0JWE51lViK-UJUpIpf2Yusk_vTX5hfNMyFXFinKSRg,106048
+topologicpy/Plotly.py,sha256=gfGadsDBgXOeefzzceXkVshqONuPtkGiW-XNVuT2rrA,106193
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
 topologicpy/PyG.py,sha256=3U59QObO56EBwrvaplGeLZhbTao0gJCYhWm3oTpjFAE,109505
 topologicpy/Shell.py,sha256=joahFtpRQTWJpQOmi3qU4Xe0Sx2XXeayHlXTNx8CzMk,87610
 topologicpy/Speckle.py,sha256=rUS6PCaxIjEF5_fUruxvMH47FMKg-ohcoU0qAUb-yNM,14267
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=j_1vCdrOMRi525lqFn63hIJYuD3ZQ8AhHiB8vIiz0zU,379524
+topologicpy/Topology.py,sha256=100DUg9EUcFg3K9wlNdaKrXcFEZLvqHsexs3R-8pbYw,416196
 topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
 topologicpy/Vertex.py,sha256=bLY60YWoMsgCgHk7F7k9F93Sq2FJ6AzUcTfJ83NZfHA,71107
-topologicpy/Wire.py,sha256=9EJE0Iq3nGz5X7Suy6xxjmuOpfV49By6WH98UAL_7m4,153532
+topologicpy/Wire.py,sha256=h-vcKAuyHVvfX34nJx4bVF-AxeaUCx4NbVzGBq98M9o,154201
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=hRb_Cf1UnQBFBHqRUC49s9X_xlGuyOLU_zTL7Xm-1Oc,23
-topologicpy-0.7.49.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.49.dist-info/METADATA,sha256=yp1EQDMypWHv6U5kmf0R7RFA8gAc9eX2fxfHqKA7FHw,10918
-topologicpy-0.7.49.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
-topologicpy-0.7.49.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.49.dist-info/RECORD,,
+topologicpy/version.py,sha256=Nl_BpJIhLQbbkeSiv2q5IgytCINu26pAUqkPjuq0FPg,23
+topologicpy-0.7.51.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
+topologicpy-0.7.51.dist-info/METADATA,sha256=E68AdA4I73vasiialUPW6sDhhX4xFhYSwysUl_7ZR1g,10918
+topologicpy-0.7.51.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+topologicpy-0.7.51.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.51.dist-info/RECORD,,

{topologicpy-0.7.49.dist-info → topologicpy-0.7.51.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (73.0.1)
+Generator: setuptools (74.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any