topologicpy 0.8.26__py3-none-any.whl → 0.8.28__py3-none-any.whl

topologicpy/Face.py

@@ -1927,6 +1927,34 @@ class Face():
         else:
             inverted_face = Face.ByWires(inverted_wire, internal_boundaries, tolerance=tolerance)
         return inverted_face
+    @staticmethod
+    def IsConvex(face, mantissa: int = 6, silent: bool = False) -> bool:
+        """
+        Returns True if the input face is convex. Returns False otherwise.
+
+        Parameters
+        ----------
+        face : topologic_core.Face
+            The  input face.
+        mantissa : int , optional
+            The length of the desired mantissa. The default is 6.
+        silent : bool , optional
+            If set to True no warnings or errors are printed. The default is False.
+        Returns
+        -------
+        bool
+            True if the nput face is convex. False otherwise.
+
+        """
+        from topologicpy.Topology import Topology
+        
+        if not Topology.IsInstance(face, "face"):
+            if not silent:
+                print("Face.IsConvex - Error: The input face parameter is not a valid topologic face. Returning None.")
+            return None
+        eb = Face.ExternalBoundary(face)
+        eb = Face.ByWire(eb)
+        return all(Face.InteriorAngles(eb)) < 180
 
     @staticmethod
     def IsCoplanar(faceA, faceB, mantissa: int = 6, tolerance: float = 0.0001) -> bool:
@@ -2468,9 +2496,9 @@ class Face():
             flat_face = Topology.Difference(flat_face, Face.ByWire(obs))
         
         # Check that the viewpoint is inside the face
-        if not Vertex.IsInternal(flat_vertex, flat_face):
-            print("Face.Isovist - Error: The viewpoint is not inside the face. Returning None.")
-            return None
+        # if not Vertex.IsInternal(flat_vertex, flat_face):
+        #     print("Face.Isovist - Error: The viewpoint is not inside the face. Returning None.")
+        #     return None
         targets = Topology.Vertices(flat_face)
         distances = []
         for target in targets:
@@ -3544,7 +3572,7 @@ class Face():
         return Face.ByWire(wire, tolerance=tolerance)
 
     @staticmethod
-    def Triangulate(face, mode: int = 0, meshSize: float = None, mantissa: int = 6, tolerance: float = 0.0001) -> list:
+    def Triangulate(face, mode: int = 0, meshSize: float = None, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False) -> list:
         """
         Triangulates the input face and returns a list of faces.
 
@@ -3571,6 +3599,8 @@ class Face():
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -3638,7 +3668,8 @@ class Face():
             from topologicpy.Topology import Topology
 
             if not Topology.IsInstance(face, "Face"):
-                print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
+                if not silent:
+                    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)
@@ -3713,7 +3744,8 @@ class Face():
             return faces
 
         if not Topology.IsInstance(face, "Face"):
-            print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
+            if not silent:
+                print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
             return None
         vertices = Topology.Vertices(face)
         if len(vertices) == 3: # Already a triangle

topologicpy/Graph.py

@@ -2455,6 +2455,204 @@ class Graph:
 
     @staticmethod
     def ByIFCFile(file,
+                  includeTypes: list = [],
+                  excludeTypes: list = [],
+                  includeRels: list = [],
+                  excludeRels: list = [],
+                  transferDictionaries: bool = False,
+                  useInternalVertex: 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,
+                  epsilon: float = 0.0001,
+                  tolerance: float = 0.0001,
+                  silent: bool = False):
+        
+        """
+        Create a Graph from an IFC file. This code is partially based on code from Bruno Postle.
+
+        Parameters
+        ----------
+        file : file
+            The input IFC file
+        includeTypes : list , optional
+            A list of IFC object types to include in the graph. The default is [] which means all object types are included.
+        excludeTypes : list , optional
+            A list of IFC object types to exclude from the graph. The default is [] which mean no object type is excluded.
+        includeRels : list , optional
+            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
+            NOT USED. If set to True, the dictionaries from the IFC file will be transferred to the topology. Otherwise, they won't. The default is False.
+        useInternalVertex : bool , optional
+            If set to True, use an internal vertex to represent the subtopology. Otherwise, use its centroid. The default is False.
+        storeBREP : bool , optional
+            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
+            The desired minimum value to assign for a vertex's Y coordinate. The default is -0.5.
+        zMin : float, optional
+            The desired minimum value to assign for a vertex's Z coordinate. The default is -0.5.
+        xMax : float, optional
+            The desired maximum value to assign for a vertex's X coordinate. The default is 0.5.
+        yMax : float, optional
+            The desired maximum value to assign for a vertex's Y coordinate. The default is 0.5.
+        zMax : float, optional
+            The desired maximum value to assign for a vertex's Z coordinate. The default is 0.5.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic_core.Graph
+            The created graph.
+        
+        """
+
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+        
+        def vertex_at_key_value(vertices, key, value):
+            for v in vertices:
+                d = Topology.Dictionary(v)
+                d_value = Dictionary.ValueAtKey(d, key)
+                if value == d_value:
+                    return v
+            return None
+        
+        def get_vertices(includeTypes=[], excludeTypes=[], removeCoplanarFaces=False, storeBREP=False, useInternalVertex=useInternalVertex, epsilon=0.0001, tolerance=0.0001):
+            # Get the topologies
+            topologies = Topology.ByIFCFile(file,
+                                            includeTypes=includeTypes,
+                                            excludeTypes=excludeTypes,
+                                        transferDictionaries=True,
+                                        removeCoplanarFaces=removeCoplanarFaces,
+                                        epsilon=epsilon,
+                                        tolerance=tolerance)
+            vertices = []
+            for topology in topologies:
+                if Topology.IsInstance(topology, "Topology"):
+                    if useInternalVertex == True:
+                        v = Topology.InternalVertex(topology)
+                    else:
+                        v = Topology.Centroid(topology)
+                    d = Topology.Dictionary(topology)
+                    if storeBREP:
+                        d = Dictionary.SetValueAtKey(d, "BREP", Topology.BREPString(topology))
+                    if Topology.IsInstance(v, "vertex"):
+                        v = Topology.SetDictionary(v, Topology.Dictionary(topology))
+                        vertices.append(v)
+                    else:
+                        if not silent:
+                            ifc_id = Dictionary.ValueAtKey(Topology.Dictionary(topology), "IFC_global_id", 0)
+                            print(f"Graph.ByIFCFile - Warning: Could not create a vertex for entity {ifc_id}. Skipping")
+            return vertices
+        
+        # Get the relationships
+        def get_relationships(ifc_file, includeRels=[], excludeRels=[]):
+            include_set = set(s.lower() for s in includeRels)
+            exclude_set = set(s.lower() for s in excludeRels)
+
+            relationships = [
+                rel for rel in ifc_file.by_type("IfcRelationship")
+                if (rel.is_a().lower() not in exclude_set) and
+                (not include_set or rel.is_a().lower() in include_set)
+            ]
+
+            return relationships
+        def get_edges(ifc_relationships, vertices):
+            tuples = []
+            edges = []
+
+            for ifc_rel in ifc_relationships:
+                source = None
+                destinations = []
+                if ifc_rel.is_a("IfcRelConnectsPorts"):
+                    source = ifc_rel.RelatingPort
+                    destinations = ifc_rel.RelatedPorts
+                elif ifc_rel.is_a("IfcRelConnectsPortToElement"):
+                    source = ifc_rel.RelatingPort
+                    destinations = [ifc_rel.RelatedElement]
+                elif ifc_rel.is_a("IfcRelAggregates"):
+                    source = ifc_rel.RelatingObject
+                    destinations = ifc_rel.RelatedObjects
+                elif ifc_rel.is_a("IfcRelNests"):
+                    source = ifc_rel.RelatingObject
+                    destinations = ifc_rel.RelatedObjects
+                elif ifc_rel.is_a("IfcRelAssignsToGroup"):
+                    source = ifc_rel.RelatingGroup
+                    destinations = ifc_rel.RelatedObjects
+                elif ifc_rel.is_a("IfcRelConnectsPathElements"):
+                    source = ifc_rel.RelatingElement
+                    destinations = [ifc_rel.RelatedElement]
+                elif ifc_rel.is_a("IfcRelConnectsStructuralMember"):
+                    source = ifc_rel.RelatingStructuralMember
+                    destinations = [ifc_rel.RelatedStructuralConnection]
+                elif ifc_rel.is_a("IfcRelContainedInSpatialStructure"):
+                    source = ifc_rel.RelatingStructure
+                    destinations = ifc_rel.RelatedElements
+                elif ifc_rel.is_a("IfcRelFillsElement"):
+                    source = ifc_rel.RelatingOpeningElement
+                    destinations = [ifc_rel.RelatedBuildingElement]
+                elif ifc_rel.is_a("IfcRelSpaceBoundary"):
+                    source = ifc_rel.RelatingSpace
+                    destinations = [ifc_rel.RelatedBuildingElement]
+                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 = vertex_at_key_value(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 = vertex_at_key_value(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:
+                                            if not [si,ei] in tuples:
+                                                tuples.append([si,ei])
+                                                tuples.append([ei,si])
+                                                e = Edge.ByVertices([sv,ev])
+                                                if Topology.IsInstance(e, "edge"):
+                                                    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)
+                                                else:
+                                                    if not silent:
+                                                        if not silent:
+                                                            print(f"Graph.ByIFCFile - Warning: Could not create an edge for relationship {ifc_rel.id()}. Skipping")
+
+            return edges
+        
+        vertices = get_vertices(includeTypes=includeTypes,
+                                excludeTypes=excludeTypes,
+                                removeCoplanarFaces=removeCoplanarFaces,
+                                storeBREP=storeBREP,
+                                useInternalVertex=useInternalVertex,
+                                epsilon=epsilon,
+                                tolerance=0.0001)
+        relationships = get_relationships(file, includeRels=includeRels, excludeRels=excludeRels)
+        edges = get_edges(relationships, vertices)
+        return Graph.ByVerticesEdges(vertices, edges)
+        
+    @staticmethod
+    def ByIFCFile_old(file,
                   includeTypes: list = [],
                   excludeTypes: list = [],
                   includeRels: list = [],

topologicpy/Grid.py

@@ -286,12 +286,11 @@ class Grid():
                     vTempVec = Vector.Multiply(uvVector, v, tolerance=tolerance)
                     gridVertex = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)+uTempVec[0], Vertex.Y(origin, mantissa=mantissa)+vTempVec[1], Vertex.Z(origin, mantissa=mantissa)+uTempVec[2])
                     if clip and Topology.IsInstance(face, "Face"):
-                        gridVertex = gridVertex.Intersect(face, False)
-                    if Topology.IsInstance(gridVertex, "Vertex"):
-                        d = Dictionary.ByKeysValues(["u","v"],[u,v])
-                        if d:
-                            gridVertex.SetDictionary(d)
-                        gridVertices.append(gridVertex)
+                        if Vertex.IsInternal(gridVertex, face):
+                            d = Dictionary.ByKeysValues(["u","v"],[u,v])
+                            if d:
+                                gridVertex.SetDictionary(d)
+                    gridVertices.append(gridVertex)
         grid = None
         if len(gridVertices) > 0:
             grid = Cluster.ByTopologies(gridVertices)
@@ -347,12 +346,17 @@ class Grid():
                 for v in vRange:
                     gridVertex = Face.VertexByParameters(face, u, v)
                     if clip and Topology.IsInstance(face, "Face"):
-                        gridVertex = gridVertex.Intersect(face, False)
-                    if Topology.IsInstance(gridVertex, "Vertex"):
-                        d = Dictionary.ByKeysValues(["u","v"],[u,v])
-                        if d:
-                            gridVertex.SetDictionary(d)
-                        gridVertices.append(gridVertex)
+                        if Vertex.IsInternal(gridVertex, face):
+                            d = Dictionary.ByKeysValues(["u","v"],[u,v])
+                            if d:
+                                gridVertex.SetDictionary(d)
+                            gridVertices.append(gridVertex)
+                    #     gridVertex = gridVertex.Intersect(face, False)
+                    # if Topology.IsInstance(gridVertex, "Vertex"):
+                    #     d = Dictionary.ByKeysValues(["u","v"],[u,v])
+                    #     if d:
+                    #         gridVertex.SetDictionary(d)
+                    #     gridVertices.append(gridVertex)
         grid = None
         if len(gridVertices) > 0:
             grid = Cluster.ByTopologies(gridVertices)

topologicpy/Plotly.py

@@ -809,7 +809,8 @@ class Plotly:
                        faceLegendLabel="Topology Faces",
                        faceLegendRank=3,
                        faceLegendGroup=3, 
-                       intensityKey=None, intensities=[], colorScale="viridis", mantissa=6, tolerance=0.0001):
+                       intensityKey=None, intensities=[], colorScale="viridis",
+                       mantissa=6, tolerance=0.0001, silent=False):
         """
         Creates plotly face, edge, and vertex data.
 
@@ -1188,7 +1189,7 @@ class Plotly:
                 f_dictionaries = []
                 all_triangles = []
                 for tp_face in tp_faces:
-                    triangles = Face.Triangulate(tp_face, tolerance=tolerance)
+                    triangles = Face.Triangulate(tp_face, tolerance=tolerance, silent=silent)
                     if isinstance(triangles, list):
                         for tri in triangles:
                             if faceColorKey or faceOpacityKey or faceLabelKey or faceGroupKey:

topologicpy/Shell.py

@@ -1846,6 +1846,42 @@ class Shell():
             final_result = Shell.ByFaces(final_faces, tolerance=tolerance)
         return final_result
 
+    @staticmethod
+    def Square(origin= None, size: float = 1.0,
+                  uSides: int = 2, vSides: int = 2, direction: list = [0, 0, 1],
+                  placement: str = "center", tolerance: float = 0.0001):
+        """
+        Creates a square.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the square. The default is None which results in the square being placed at (0, 0, 0).
+        size : float , optional
+            The size of the square. The default is 1.0.
+        length : float , optional
+            The length of the square. The default is 1.0.
+        uSides : int , optional
+            The number of sides along the width. The default is 2.
+        vSides : int , optional
+            The number of sides along the length. The default is 2.
+        direction : list , optional
+            The vector representing the up direction of the square. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the square. This can be "center", or "lowerleft". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Shell
+            The created shell square.
+
+        """
+        return Shell.Rectangle(origin=origin, width=size, length=size,
+                  uSides=uSides, vSides=vSides, direction=direction,
+                  placement=placement, tolerance=tolerance)
+    
     @staticmethod
     def Vertices(shell) -> list:
         """

topologicpy/Topology.py

@@ -2118,9 +2118,13 @@ class Topology():
         return Topology.ByDXFFile(file, sides=sides)
 
     @staticmethod
-    def ByIFCFile(file, includeTypes=[], excludeTypes=[], transferDictionaries=False, removeCoplanarFaces=False, epsilon=0.0001, tolerance=0.0001):
+    def ByIFCFile(file, includeTypes=[], excludeTypes=[], transferDictionaries=False,
+                  removeCoplanarFaces=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,
+                  epsilon=0.0001, tolerance=0.0001, silent=False):
         """
-        Create a list of topologies by importing them from an IFC file.
+        Create a topology by importing it from an IFC file.
 
         Parameters
         ----------
@@ -2134,215 +2138,143 @@ 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.
+        xMin : float, optional
+            The desired minimum value to assign for a vertex's X coordinate. The default is -0.5.
+        yMin : float, optional
+            The desired minimum value to assign for a vertex's Y coordinate. The default is -0.5.
+        zMin : float, optional
+            The desired minimum value to assign for a vertex's Z coordinate. The default is -0.5.
+        xMax : float, optional
+            The desired maximum value to assign for a vertex's X coordinate. The default is 0.5.
+        yMax : float, optional
+            The desired maximum value to assign for a vertex's Y coordinate. The default is 0.5.
+        zMax : float, optional
+            The desired maximum value to assign for a vertex's Z coordinate. The default is 0.5.
         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.
+            The desired epsilon (another form of tolerance) for finding if two faces are coplanar. The default is 0.01.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
         Returns
         -------
         list
             The created list of topologies.
         
         """
-
-        import ifcopenshell, ifcopenshell.geom
-        from topologicpy.Dictionary import Dictionary
+        import ifcopenshell
+        import ifcopenshell.geom
         from topologicpy.Vertex import Vertex
-        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
         from topologicpy.Face import Face
-        import numpy as np
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from concurrent.futures import ThreadPoolExecutor
+        import random
 
-        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
+        # Early filtering in parallel (safe)
+        def is_valid(product):
+            is_a = product.is_a().lower()
+            include = [t.lower() for t in includeTypes]
+            exclude = [t.lower() for t in excludeTypes]
+            return (not include or is_a in include) and (is_a not in exclude)
 
-            # 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
-        # Create a 4x4 unity matrix
-        matrix = [[1.0 if i == j else 0.0 for j in range(4)] for i in range(4)]
-        def convert_to_topology(entity, settings, transferDictionaries=False):    
-            if hasattr(entity, "Representation") and entity.Representation:
-                for rep in entity.Representation.Representations:
-                    shape_topology = None
-                    if rep.is_a("IfcShapeRepresentation"):
-                        # Generate the geometry for this entity
-                        try:
-                            shape = ifcopenshell.geom.create_shape(settings, entity)
-                            trans = shape.transformation
-                            # Convert into a 4x4 matrix
-                            matrix = [trans.matrix[i:i+4] for i in range(0, len(trans.matrix), 4)]
-                            # 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 = ifc_to_topologic_geometry(verts, edges, faces)
-                            #shape_topology = Topology.SelfMerge(Topology.ByGeometry(verts, edges, faces))
-                            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)
-                                shape_topology = Topology.Transform(shape_topology, matrix)
-
-                                # Store relevant information
-                                if transferDictionaries == True:
-                                    color, transparency, material_list = get_color_transparency_material(entity)
-                                    if color == None:
-                                        color = "white"
-                                    if transparency == None:
-                                        transparency = 0
-                                    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)
-                        except:
-                            pass
-                        return shape_topology
-            return None
+        with ThreadPoolExecutor() as executor:
+            products = list(file.by_type("IfcProduct"))
+            valid_entities = list(executor.map(lambda p: p if is_valid(p) else None, products))
+            valid_entities = [e for e in valid_entities if e is not 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)
+        settings.set("iterator-output", ifcopenshell.ifcopenshell_wrapper.SERIALIZED)
+
         topologies = []
-        for entity in entities:
-            topologies.append(convert_to_topology(entity, settings, transferDictionaries=transferDictionaries))
-        return topologies
+        for entity in valid_entities:
+            if not hasattr(entity, "Representation") or not entity.Representation:
+                continue
+            shape = ifcopenshell.geom.create_shape(settings, entity)
+            topology = None
+            if hasattr(shape.geometry, 'brep_data'):
+                brep_string = shape.geometry.brep_data
+                topology = Topology.ByBREPString(brep_string)
+                if not topology:
+                    if not silent:
+                        print(f"Topology.ByIFCFile - Warning: Could not convert entity {getattr(entity, 'GlobalId', 0)} to a topology. Skipping.")
+                    continue
+                if removeCoplanarFaces:
+                    topology = Topology.RemoveCoplanarFaces(topology, epsilon=epsilon, tolerance=tolerance)
+            else:
+                if not silent:
+                    print(f"Topology.ByIFCFile - Warning: Entity {getattr(entity, 'GlobalId', 0)} does not have a BREP. Skipping.")
+                continue
+            
+
+            if transferDictionaries:
+                entity_dict = {
+                    "TOPOLOGIC_id": str(Topology.UUID(topology)),
+                    "TOPOLOGIC_name": getattr(entity, 'Name', "Untitled"),
+                    "TOPOLOGIC_type": Topology.TypeAsString(topology),
+                    "IFC_global_id": getattr(entity, 'GlobalId', 0),
+                    "IFC_name": getattr(entity, 'Name', "Untitled"),
+                    "IFC_type": entity.is_a()
+                }
+
+                # Optionally add property sets
+                psets = {}
+                if hasattr(entity, 'IsDefinedBy'):
+                    for rel in entity.IsDefinedBy:
+                        if rel.is_a('IfcRelDefinesByProperties'):
+                            pdef = rel.RelatingPropertyDefinition
+                            if pdef and pdef.is_a('IfcPropertySet'):
+                                key = f"IFC_{pdef.Name}"
+                                props = {}
+                                for prop in pdef.HasProperties:
+                                    if prop.is_a('IfcPropertySingleValue') and prop.NominalValue:
+                                        props[f"IFC_{prop.Name}"] = prop.NominalValue.wrappedValue
+                                psets[key] = props
+
+                final_dict = Dictionary.ByPythonDictionary(entity_dict)
+                if psets:
+                    pset_dict = Dictionary.ByPythonDictionary(psets)
+                    final_dict = Dictionary.ByMergedDictionaries([final_dict, pset_dict])
+                
+                topology = Topology.SetDictionary(topology, final_dict)
+
+            topologies.append(topology)
+        
+        final_topologies = []
+        for topology in topologies:
+            faces = []
+
+            for w in Topology.Wires(topology):
+                # Skip trivial wires (e.g. edges)
+                if len(Topology.Vertices(w)) < 3:
+                    continue
+
+                # Only attempt face creation if the wire is closed
+                if Wire.IsClosed(w) and Wire.IsManifold(w):
+                    f = Face.ByWire(w)
+                    if f:
+                        faces.append(f)
+                        continue
+
+                # fallback: keep wire
+                faces.append(w)
+
+            # Avoid unnecessary Cluster/SelfMerge if there's only one face
+            if len(faces) == 1:
+                final_topology = faces[0]
+            else:
+                final_topology = Topology.SelfMerge(Cluster.ByTopologies(faces))
+                if final_topology == None:
+                    final_topology = Cluster.ByTopologies(faces)
+            if transferDictionaries:
+                d = Topology.Dictionary(topology)
+                final_topology = Topology.SetDictionary(final_topology, d)
+
+            final_topologies.append(final_topology)
+        return final_topologies
 
     @staticmethod
     def _ByIFCFile_old(file, includeTypes=[], excludeTypes=[], transferDictionaries=False, removeCoplanarFaces=False):
@@ -4398,75 +4330,137 @@ class Topology():
         return contexts
 
     @staticmethod
-    def ConvexHull(topology, mantissa: int = 6, tolerance: float = 0.0001):
+    def ConvexHull(topology, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
-        Creates a convex hull
+        Computes the convex hull of the input topology.
+        Returns a Face in 2D (even embedded in 3D), or a Cell/Shell in 3D.
 
         Parameters
         ----------
         topology : topologic_core.Topology
             The input Topology.
-        mantissa : int , optional
-            The desired length of the mantissa. The default is 6.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
+        mantissa : int, optional
+            Precision of the coordinates. Default is 6.
+        tolerance : float, optional
+            Tolerance value for geometric operations. Default is 0.0001.
+        silent : bool, optional
+            If True, suppresses warning and error messages.
 
         Returns
         -------
         topologic_core.Topology
-            The created convex hull of the input topology.
-
+            The convex hull of the topology as a Face (2D) or Cell/Shell (3D).
         """
         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.Cluster import Cluster        
-        
-        def convexHull3D(item, tolerance, option):
-            if item:
-                vertices = Topology.Vertices(item)
-                pointList = []
-                for v in vertices:
-                    pointList.append(Vertex.Coordinates(v, mantissa=mantissa))
-                points = np.array(pointList)
-                if option:
-                    hull = ConvexHull(points, qhull_options=option)
-                else:
-                    hull = ConvexHull(points)
-                faces = []
-                for simplex in hull.simplices:
-                    edges = []
-                    for i in range(len(simplex)-1):
-                        sp = hull.points[simplex[i]]
-                        ep = hull.points[simplex[i+1]]
-                        sv = Vertex.ByCoordinates(sp[0], sp[1], sp[2])
-                        ev = Vertex.ByCoordinates(ep[0], ep[1], ep[2])
-                        edges.append(Edge.ByVertices([sv, ev], tolerance=tolerance))
-                    sp = hull.points[simplex[-1]]
-                    ep = hull.points[simplex[0]]
-                    sv = Vertex.ByCoordinates(sp[0], sp[1], sp[2])
-                    ev = Vertex.ByCoordinates(ep[0], ep[1], ep[2])
-                    edges.append(Edge.ByVertices([sv, ev], tolerance=tolerance))
-                    faces.append(Face.ByWire(Wire.ByEdges(edges, tolerance=tolerance), tolerance=tolerance))
+        from topologicpy.Shell import Shell
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+
+        import numpy as np
+        from scipy.spatial import ConvexHull as SciPyConvexHull
+
+        if not Topology.IsInstance(topology, "Topology"):
+            if not silent:
+                print("Topology.ConvexHull - Error: Input is not a valid topology. Returning None.")
+            return None
+
+        def convexHull_2d(vertices, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+            from topologicpy.Vertex import Vertex
+            from topologicpy.Edge import Edge
+            from topologicpy.Wire import Wire
+            from topologicpy.Face import Face
+            from topologicpy.Cluster import Cluster
+            from topologicpy.Topology import Topology
+
+            import numpy as np
+            from scipy.spatial import ConvexHull as SciPyConvexHull
+
+            cluster = Cluster.ByTopologies(vertices)
+            normal = Vertex.Normal(vertices)
+            centroid = Topology.Centroid(cluster)
+            flat_cluster = Topology.Flatten(cluster, origin=centroid, direction=normal)
+            flat_verts = Topology.Vertices(flat_cluster)
+            coords = np.array([[Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa)] for v in flat_verts])
             try:
-                c = Cell.ByFaces(faces, tolerance=tolerance)
-                return c
+                hull = SciPyConvexHull(coords)
             except:
-                returnTopology = Topology.SelfMerge(Cluster.ByTopologies(faces), tolerance=tolerance)
-                if Topology.Type(returnTopology) == Topology.TypeID("Shell"):
-                    return Shell.ExternalBoundary(returnTopology, tolerance=tolerance)
-        if not Topology.IsInstance(topology, "Topology"):
-            print("Topology.ConvexHull - Error: the input topology parameter is not a valid topology. Returning None.")
+                if not silent:
+                    print("Topology.ConvexHull - Error computing 2D hull. Returning None.")
+                return None
+
+            # Reconstruct 3D points from 2D hull
+            hull_indices = hull.vertices
+            sorted_coords = coords[hull_indices]
+
+            edges = []
+            for i in range(len(sorted_coords)):
+                p1 = sorted_coords[i]
+                p2 = sorted_coords[(i + 1) % len(sorted_coords)]
+                v1 = Vertex.ByCoordinates(*p1)
+                v2 = Vertex.ByCoordinates(*p2)
+                edges.append(Edge.ByVertices([v1, v2], tolerance=tolerance))
+            convex_hull = Wire.ByEdges(edges, tolerance=tolerance)
+            if Topology.IsInstance(convex_hull, "wire"):
+                convex_hull_2 = Face.ByWire(convex_hull, tolerance=tolerance, silent=True)
+            if not Topology.IsInstance(convex_hull_2, "face"):
+                convex_hull_2 = convex_hull
+            convex_hull = Topology.Unflatten(convex_hull_2, origin=centroid, direction=normal)
+            return convex_hull
+        
+        vertices = Topology.Vertices(topology)
+        if len(vertices) < 3:
+            if not silent:
+                print("Topology.ConvexHull - Error: Need at least 3 points to compute a convex hull.")
             return None
-        returnObject = None
-        try:
-            returnObject = convexHull3D(topology, tolerance, None)
-        except:
-            returnObject = convexHull3D(topology, tolerance, 'QJ')
-        return returnObject
+        
+        coords = np.array([Vertex.Coordinates(v, mantissa=mantissa) for v in vertices])
+
+        if Vertex.AreCoplanar(vertices, mantissa=mantissa, tolerance=tolerance, silent=silent):
+            # Planar case
+            return convexHull_2d(vertices, mantissa=mantissa, tolerance=tolerance, silent=silent)
+        else:
+            # Non-planar case
+            try:
+                hull = SciPyConvexHull(coords)
+            except:
+                try:
+                    hull = SciPyConvexHull(coords, qhull_options="QJ")
+                except Exception as e:
+                    if not silent:
+                        print(f"Topology.ConvexHull - 3D hull failed even with QJ: {e}")
+                    return None
+            faces = []
+            for simplex in hull.simplices:
+                points = coords[simplex]
+                edges = []
+                for i in range(len(points)):
+                    p1 = points[i]
+                    p2 = points[(i + 1) % len(points)]
+                    v1 = Vertex.ByCoordinates(*p1)
+                    v2 = Vertex.ByCoordinates(*p2)
+                    edges.append(Edge.ByVertices([v1, v2], tolerance=tolerance))
+                wire = Wire.ByEdges(edges, tolerance=tolerance)
+                face = Face.ByWire(wire, tolerance=tolerance)
+                faces.append(face)
+
+            convex_hull = Cell.ByFaces(faces, tolerance=tolerance, silent=True)
+            if convex_hull:
+                convex_hull_2 = Topology.RemoveCoplanarFaces(convex_hull, tolerance=tolerance, silent=True)
+                if not convex_hull_2:
+                    return convex_hull
+            else:
+                convex_hull = Shell.ByFaces(faces, tolerance=tolerance, silent=True)
+                if convex_hull:
+                    convex_hull_2 = Topology.RemoveCoplanarFaces(convex_hull, tolerance=tolerance, silent=True)
+                    if not convex_hull_2:
+                        return convex_hull
+                else:
+                    convex_hull = Cluster.ByTopologies(faces)
+            return convex_hull
     
     @staticmethod
     def Copy(topology, deep=False):
@@ -4499,6 +4493,63 @@ class Topology():
             return_topology = Topology.SetDictionary(return_topology, d)
         return return_topology
     
+    @staticmethod
+    def Diameter(topology, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Computes the diameter of the convex hull of the given topology.
+        The diameter is the maximum distance between any two vertices on the convex hull.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        float
+            The diameter of the convex hull of the topology.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+
+        if not Topology.IsInstance(topology, "Topology"):
+            if not silent:
+                print("Topology.Diameter - Error: The input topology parameter is not a valid Topology. Returning None.")
+            return None
+        if Topology.IsInstance(topology, "Vertex"):
+            return 0.0
+        if Topology.IsInstance(topology, "Edge"):
+            sv = Edge.StartVertex(topology)
+            ev = Edge.EndVertex(topology)
+            return Vertex.Distance(sv, ev, mantissa=mantissa)
+
+        # Step 1: Get the convex hull
+        hull = Topology.ConvexHull(topology, tolerance=tolerance, mantissa=mantissa, silent=silent)
+        if not hull:
+            return 0.0
+
+        # Step 2: Get all unique vertices of the hull
+        vertices = Topology.Vertices(hull)
+        num_vertices = len(vertices)
+        if num_vertices < 2:
+            return 0.0
+
+        # Step 3: Find the furthest pair
+        max_distance = 0.0
+        for i in range(num_vertices):
+            for j in range(i + 1, num_vertices):
+                dist = Vertex.Distance(vertices[i], vertices[j], mantissa=mantissa)
+                if dist > max_distance:
+                    max_distance = dist
+
+        return round(max_distance, mantissa)
+    
     @staticmethod
     def Dictionary(topology):
         """
@@ -7429,7 +7480,7 @@ class Topology():
             distances = []
             for v in vertices:
                 distances.append(Vertex.PerpendicularDistance(v, face=face2, mantissa=6))
-            d = sum(distances)/len(distances)
+            d = sum(distances) / len(distances) if distances else float('inf')
             return d <= epsilon
 
         def cluster_faces_on_planes(faces, epsilon=1e-6):
@@ -8928,7 +8979,8 @@ class Topology():
                                               intensities=intensities,
                                               colorScale=colorScale,
                                               mantissa=mantissa,
-                                              tolerance=tolerance))
+                                              tolerance=tolerance,
+                                              silent=silent))
                 topology_counter += offset
         figure = Plotly.FigureByData(data=data, width=width, height=height,
                                      xAxis=xAxis, yAxis=yAxis, zAxis=zAxis, axisSize=axisSize,
@@ -10149,7 +10201,7 @@ class Topology():
         selectors = []
         for aFace in topologyFaces:
             if len(Topology.Vertices(aFace)) > 3:
-                triFaces = Face.Triangulate(aFace, mode=mode, meshSize=meshSize, tolerance=tolerance)
+                triFaces = Face.Triangulate(aFace, mode=mode, meshSize=meshSize, tolerance=tolerance, silent=silent)
             else:
                 triFaces = [aFace]
             for triFace in triFaces:

topologicpy/Vertex.py

@@ -152,6 +152,50 @@ class Vertex():
                 return False
         return True
     
+    @staticmethod
+    def AreCoplanar(vertices: list, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False) -> bool:
+        """
+        Returns True if the input list of vertices are coplanar. Returns False otherwise.
+
+        Parameters
+        ----------
+        vertices : list
+            The input list of vertices.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001
+        silent : bool , optional
+            If set to True, no warnings or errors are printed. The default is False.
+
+        Returns
+        -------
+        bool
+            True if the input vertices are coplanar.
+
+        """
+        from topologicpy.Topology import Topology
+        from numpy.linalg import svd
+
+        if not isinstance(vertices, list):
+            if not silent:
+                print("Vertex.Normal - Error: The vertices input parameter is not a valid list. Returning None.")
+            return None
+        
+        verts = [v for v in vertices if Topology.IsInstance(v, "vertex")]
+
+        if len(verts) < 3:
+            if not silent:
+                print("Vertex.AreCoplanar - Error: The list of vertices contains less than 3 valid topologic vertices. Returning None.")
+            return None  # At least 3 vertices are needed
+        
+        coords = np.array([Vertex.Coordinates(v, mantissa=mantissa) for v in vertices])
+
+        # Check if points are coplanar using SVD
+        _, s, vh = svd(coords - coords.mean(axis=0))
+        rank = (s > tolerance).sum()
+        return (rank <= 2)
+    
     @staticmethod
     def AreIpsilateral(vertices: list, face) -> bool:
         """
@@ -1453,6 +1497,57 @@ class Vertex():
             sorted_indices = [x for _, x in sorted(zip(distances, indices))]
         return vertices[sorted_indices[0]]
 
+    @staticmethod
+    def Normal(vertices, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Computes the normal vector of a list of co-planar Topologic vertices.
+        Depending on the order of the vertices, the normal can be flipped 180 degrees.
+
+        Parameters
+        ----------
+        vertices : list
+            A list of Topologic Vertex objects that are assumed to be co-planar.
+        mantissa : int, optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float, optional
+           The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True no warnings or errors are printed. The default is False.
+
+        Returns
+        -------
+        list
+            A unit normal vector [x, y, z] of the plane defined by the vertices, or None if invalid.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+        import numpy as np
+
+        if not isinstance(vertices, list):
+            if not silent:
+                print("Vertex.Normal - Error: The vertices input parameter is not a valid list. Returning None.")
+            return None
+        
+        verts = [v for v in vertices if Topology.IsInstance(v, "vertex")]
+
+        if len(verts) < 3:
+            if not silent:
+                print("Vertex.Normal - Error: The list of vertices contains less than 3 valid topologic vertices. Returning None.")
+            return None  # At least 3 vertices are needed
+
+        coords = np.array([Vertex.Coordinates(v, mantissa=mantissa) for v in verts])
+        centroid = np.mean(coords, axis=0)
+        centered = coords - centroid
+
+        # Use SVD to find the normal as the vector corresponding to the smallest singular value
+        _, _, vh = np.linalg.svd(centered)
+        normal = vh[-1]  # The last row is the normal of the best-fit plane
+
+        norm = np.linalg.norm(normal)
+        if norm < tolerance:
+            return None  # Degenerate normal
+        return list(np.round(normal / norm, mantissa))
+    
     @staticmethod
     def Origin():
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.26'
+__version__ = '0.8.28'

{topologicpy-0.8.26.dist-info → topologicpy-0.8.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.26
+Version: 0.8.28
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.8.26.dist-info → topologicpy-0.8.28.dist-info}/RECORD

@@ -11,27 +11,27 @@ topologicpy/DGL.py,sha256=HQXy9iDnrvWGDxaBfe5pRbweQ2zLBvAf6UdjfhKkQYI,139041
 topologicpy/Dictionary.py,sha256=Lf24WHW8q_RCq0l8VpT3XJTn6UuStY66JI4Lb4W08jI,34126
 topologicpy/Edge.py,sha256=pu4tZbRbK8qx2oqRbwHAeKuwU2X8JFGPSJjJMTJw8Q0,71418
 topologicpy/EnergyModel.py,sha256=Pyb28gDDwhzlQIH0xqAygqS0P3SJxWyyV7OWS_AAfRs,53856
-topologicpy/Face.py,sha256=7K46gB_UIKjKEKyzyY0JqGarqjwjH0ggS-JQTpDtWC4,184847
-topologicpy/Graph.py,sha256=9gK-dEMtjo7KOXbCACpgwOYWhgTAHy42g6WiQ-rw20M,563389
-topologicpy/Grid.py,sha256=qRnFUvs079zMOZ6COWzBX6408niI7HyNz-BM0VRguXY,18245
+topologicpy/Face.py,sha256=E1ffqvCNDWKFnFiDrEu70KWPGMGjtD3SoIxu4Yokn_I,186106
+topologicpy/Graph.py,sha256=t_2lHDUdQHsG-PYVjeRZtqfjKv6eD8jI8ZJl9uQW_GU,574360
+topologicpy/Grid.py,sha256=EbI2NcYhQDpD5mItd7A1Lpr8Puuf87vZPWuoh7_gChQ,18483
 topologicpy/Helper.py,sha256=JdvC30WMrla46mTj5TdwCV_bRv-6y8vK5Bkx0prluy4,29100
 topologicpy/Honeybee.py,sha256=yctkwfdupKnp7bAOjP1Z4YaYpRrWoMEb4gz9Z5zaWwE,21751
 topologicpy/Matrix.py,sha256=BHGDRkBn1pf5DkRoY8feAhDGHTF3bjFM4jluiEb_A0w,22779
 topologicpy/Neo4j.py,sha256=vNMaqTWerwr-3luLjYEXNhf8T97aFee6x5sIKBHY73s,22392
-topologicpy/Plotly.py,sha256=eHTKT8vOHJDLwH4xypj52atGLR0dGic45d-BiPA55Q8,119219
+topologicpy/Plotly.py,sha256=s0fC_eNsgJN8zkkY_EomZi6jnKCIdtrVYsgnS51MWkU,119271
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
-topologicpy/Shell.py,sha256=3zUSf0VfkAF73ZyTYNWYW21x4-vyfi7JkYu_r5GTVIc,87983
+topologicpy/Shell.py,sha256=h8S2nP1e0JtMxeOdAFZVhOYTJWTW8vlZRM5lxK0gu2o,89577
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=_VBBAUIDhvpkp72JBZlv7k9qx9jYubm3yM56UZ1Nc6c,36837
-topologicpy/Topology.py,sha256=BKiVJ-R5FfwXJ2FYp1V8pjaPoMxRm83MGe2RzBx0_tQ,479205
+topologicpy/Topology.py,sha256=3wTW_C3lquA7lc5sLMxxoBj53Ygc--6hLl5LGvnv3NI,478412
 topologicpy/Vector.py,sha256=mx7fgABdioikPWM9HzXKzmqfx3u_XBcU_jlLD4qK2x8,42407
-topologicpy/Vertex.py,sha256=PIwfbA7_TxK_dSGlSeM5mson97TRr4dYrfZyOLgO150,80913
+topologicpy/Vertex.py,sha256=UMDhERrLH6b4WOu4pl0UgYzcfp9-NvmASLtKXwetO_4,84687
 topologicpy/Wire.py,sha256=eRs4PM7h4yU5v6umPh0oBJR4cN8BwsqlVroaFdnvK4w,228499
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=rN0alF_hLv16P_Fcr4gxu7bHFSkbtvltSnm1X_HNZ5w,23
-topologicpy-0.8.26.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.26.dist-info/METADATA,sha256=D7oAeLuTLnKLuMBL8WSrlBMwSSjsK5QpsodjjHXkc7E,10535
-topologicpy-0.8.26.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-topologicpy-0.8.26.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.26.dist-info/RECORD,,
+topologicpy/version.py,sha256=YRGDu9QPaNPQlZcx7MJLLUrv2aIEpppZ8LAIiyZvW00,23
+topologicpy-0.8.28.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.28.dist-info/METADATA,sha256=W4Rje6xhqAy7LxQUXrv0Q5yY97BFPOKC0iWuZDqjjJM,10535
+topologicpy-0.8.28.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+topologicpy-0.8.28.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.28.dist-info/RECORD,,

{topologicpy-0.8.26.dist-info → topologicpy-0.8.28.dist-info}/WHEEL

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