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

topologicpy/Plotly.py

@@ -592,6 +592,7 @@ class Plotly:
             mode = "markers+text"
         else:
             mode = "markers"
+
         vData2 = go.Scatter3d(x=x,
                             y=y,
                             z=z,
@@ -603,11 +604,13 @@ class Plotly:
                                         opacity=1,
                                         sizemode="diameter"),
                             mode=mode,
+                            customdata = labels,
                             legendgroup=legendGroup,
                             legendrank=legendRank,
                             text=labels,
                             hoverinfo='text',
-                            hovertext=labels
+                            hovertext=labels,
+                            hovertemplate=["Click "+label for label in labels]
                             )
         if borderWidth > 0 or borderWidthKey:
             vData1 = go.Scatter3d(x=x,
@@ -676,14 +679,13 @@ class Plotly:
             labels = []
             for j, elements_cluster in enumerate(elements_clusters):
                 d_color = color
-                labels.append("Edge_"+str(j+1).zfill(n))
                 d = dict_clusters[j][0] # All dicitonaries have same values in dictionaries, so take first one.
                 if d:
                     if not colorKey == None:
                         d_color = Dictionary.ValueAtKey(d, key=colorKey) or color
                         d_color = Color.AnyToHex(d_color)
                     if not labelKey == None:
-                        label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
+                        labels.append(str(Dictionary.ValueAtKey(d, labelKey, "")))
                     if not widthKey == None:
                         e_width = Dictionary.ValueAtKey(d, key=widthKey)
                         if not e_width == None:
@@ -727,8 +729,10 @@ class Plotly:
                                     line=dict(color=d_color, width=width),
                                     legendgroup=legendGroup,
                                     legendrank=legendRank,
-                                    text=label,
-                                    hoverinfo='text')
+                                    text=labels,
+                                    customdata=labels,
+                                    hoverinfo='text',
+                                    hovertext=labels)
                 traces.append(trace)
         else:
             x = []

topologicpy/ShapeGrammar.py

@@ -0,0 +1,492 @@
+# Copyright (C) 2025
+# Wassim Jabi <wassim.jabi@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along with
+# this program. If not, see <https://www.gnu.org/licenses/>.
+
+import topologic_core as topologic
+
+class ShapeGrammar:
+    def __init__(self):
+        self.title = "Untitled" # Stores the title of the topology grammar.
+        self.description = "" # Stores the description of the grammar.
+        self.rules = []  # Stores transformation rules of the topology grammar.
+        # Operations
+        # Replace
+        replace = {"title": "Replace",
+                   "description": "Replaces the input topology with the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Transform
+        transform = {"title": "Transform",
+                   "description": "Transforms the input topology using the specified matrix.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Union
+        union = {"title": "Union",
+                   "description": "Unions the input topology and the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Difference
+        difference = {"title": "Difference",
+                   "description": "Subtracts the output topology from the input topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Difference
+        symdif = {"title": "Symmetric Difference",
+                   "description": "Calculates the symmetrical difference of the input topology and the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Intersect
+        intersect = {"title": "Intersect",
+                   "description": "Intersects the input topology and the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Merge
+        merge = {"title": "Merge",
+                   "description": "Merges the input topology and the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Slice
+        slice = {"title": "Slice",
+                   "description": "Slices the input topology using the output topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Impose
+        impose = {"title": "Impose",
+                   "description": "Imposes the output topology on the input topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Imprint
+        imprint = {"title": "Imprint",
+                   "description": "Imposes the output topology on the input topology.",
+                   "uSides": None,
+                   "vSides": None,
+                   "wSides": None}
+        # Divide
+        divide = {"title": "Divide",
+                   "description": "Divides the input topology along the x, y, and z axes using the specified number of sides (uSides, vSides, wSides)",
+                   "uSides": 2,
+                   "vSides": 2,
+                   "wSides": 2}
+        self.operations = [replace, transform, union, difference, symdif, intersect, merge, slice, impose, imprint, divide]
+
+    def OperationTitles(self):
+        """
+        Returns the list of available operation titles.
+
+        Parameters
+        ----------
+        
+        Returns
+        -------
+        list
+            The requested list of operation titles
+        """
+        return [op["title"] for op in self.operations]
+    
+    def OperationByTitle(self, title):
+        """
+        Returns the operation given the input title string
+
+        Parameters
+        ----------
+        title : str
+            The input operation str. See OperationTitles for list of operations.
+        
+        Returns
+        -------
+        ShapeGrammar.Operation
+            The requested operation
+        """
+        for op in self.operations:
+            op_title = op["title"]
+            if title.lower() in op_title.lower():
+                return op
+        return None
+
+    def AddRule(self,
+                input,
+                output,
+                title : str = "Untitled Rule",
+                description: str = "",
+                operation : dict = None,
+                matrix: list = None,
+                silent: bool = False):
+        """
+        Adds a rule to the topology grammar.
+
+        Parameters
+        ----------
+        input : topologic_core.Topology
+            The linput topology of the rule.
+        output : topologic_core.Topology
+            The output topology of the rule.
+        title : str , optional
+            The title of the rule. The default is "Untitled Rule"
+        description : str, optional
+            The description of the rule. The default is "".
+        operation : dict , optional
+            The desired rule operation. See Rule Operations. If set to None, the replacement rule is applied. The default is None.
+        matrix : list
+            The 4x4 transformation matrix that tranforms the output topology to the input topology. If set to None, no transformation is applied. The default is None.
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        None
+            This method does not return a value.
+        """
+        from topologicpy.Topology import Topology
+
+        def is_4x4_matrix(matrix):
+            return (
+                isinstance(matrix, list) and
+                len(matrix) == 4 and
+                all(isinstance(row, list) and len(row) == 4 for row in matrix)
+            )
+
+        if not Topology.IsInstance(input, "Topology"):
+            if not silent:
+                print("ShapeGrammar.AddRule - Error: The input input parameter is not a valid topology. Returning None.")
+            return None
+        if not output == None:
+            if not Topology.IsInstance(output, "Topology"):
+                if not silent:
+                    print("ShapeGrammar.AddRule - Error: The input output parameter is not a valid topology. Returning None.")
+                return None
+        if not operation == None:
+            if not operation in self.operations:
+                if not silent:
+                    print("ShapeGrammar.AddRule - Error: The input operation parameter is not a valid operation. Returning None.")
+                return None
+        if not matrix == None:
+            if not is_4x4_matrix(matrix):
+                if not silent:
+                    print("ShapeGrammar.AddRule - Error: The input matrix parameter is not a valid matrix. Returning None.")
+                return None
+        
+        self.rules.append({"input":input,
+                           "output": output,
+                           "title": title,
+                           "description": description,
+                           "operation": operation,
+                           "matrix": matrix
+                           })
+
+    def ApplicableRules(self, topology, keys: list = None, silent: bool = False):
+        """
+        Returns rules applicable to the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology
+        keys : list , optional
+            The list of dictionary keys to semantically match the rules. The default is None which means dictionaries are not considered.
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        list
+            The list of applicable rules.
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if not Topology.IsInstance(topology, "Topology"):
+            if not silent:
+                print("ShapeGrammar.ApplicableRules - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        
+        ap_rules = []
+        ap_trans = []
+        d = Topology.Dictionary(topology)
+        for i, rule in enumerate(self.rules):
+            dict_status = True
+            input = rule["input"]
+            # If there is a list of keys specified, check that the values match
+            if isinstance(keys, list):
+                d_input = Topology.Dictionary(input)
+                for j, key in enumerate(keys):
+                    if not Dictionary.ValueAtKey(d, key, None) == Dictionary.ValueAtKey(d_input, key, None):
+                        dict_status = False
+                        break
+            #If it passed the dictionary key test, then check topology similarity
+            if dict_status:
+                topology_status, mat = Topology.IsSimilar(rule["input"], topology)
+                if topology_status:
+                    ap_rules.append(rule)
+                    ap_trans.append(mat)
+        return ap_rules, ap_trans
+
+    def ApplyRule(self, topology, rule: dict = None, matrix: list = None, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns rules applicable to the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology
+        rule : dict , optional
+            The desired rule to apply. The default is None.
+        matrix : list
+            The 4x4 transformation matrix that tranforms the output topology to the input topology. If set to None, no transformation is applied. The default is None.
+        mantissa : int, optional
+            Decimal precision. Default is 6.
+        tolerance : float, optional
+            The desired Tolerance. Not used here but included for API compatibility. Default is 0.0001.
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        topologic_core.Topology
+            The transformed topology
+        """
+
+        from topologicpy.Topology import Topology
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Face import Face
+        from topologicpy.Vertex import Vertex
+
+        def is_4x4_matrix(matrix):
+            return (
+                isinstance(matrix, list) and
+                len(matrix) == 4 and
+                all(isinstance(row, list) and len(row) == 4 for row in matrix)
+            )
+        
+        def bb(topology):
+            vertices = Topology.Vertices(topology)
+            x = []
+            y = []
+            z = []
+            for aVertex in vertices:
+                x.append(Vertex.X(aVertex, mantissa=mantissa))
+                y.append(Vertex.Y(aVertex, mantissa=mantissa))
+                z.append(Vertex.Z(aVertex, mantissa=mantissa))
+            x_min = min(x)
+            y_min = min(y)
+            z_min = min(z)
+            maxX = max(x)
+            maxY = max(y)
+            maxZ = max(z)
+            return [x_min, y_min, z_min, maxX, maxY, maxZ]
+        
+        def slice(topology, uSides, vSides, wSides):
+            x_min, y_min, z_min, maxX, maxY, maxZ = bb(topology)
+            centroid = Vertex.ByCoordinates(x_min+(maxX-x_min)*0.5, y_min+(maxY-y_min)*0.5, z_min+(maxZ-z_min)*0.5)
+            wOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), Vertex.Y(centroid, mantissa=mantissa), z_min)
+            wFace = Face.Rectangle(origin=wOrigin, width=(maxX-x_min)*1.1, length=(maxY-y_min)*1.1)
+            wFaces = []
+            wOffset = (maxZ-z_min)/wSides
+            for i in range(wSides-1):
+                wFaces.append(Topology.Translate(wFace, 0,0,wOffset*(i+1)))
+            uOrigin = Vertex.ByCoordinates(x_min, Vertex.Y(centroid, mantissa=mantissa), Vertex.Z(centroid, mantissa=mantissa))
+            uFace = Face.Rectangle(origin=uOrigin, width=(maxZ-z_min)*1.1, length=(maxY-y_min)*1.1, direction=[1,0,0])
+            uFaces = []
+            uOffset = (maxX-x_min)/uSides
+            for i in range(uSides-1):
+                uFaces.append(Topology.Translate(uFace, uOffset*(i+1),0,0))
+            vOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), y_min, Vertex.Z(centroid, mantissa=mantissa))
+            vFace = Face.Rectangle(origin=vOrigin, width=(maxX-x_min)*1.1, length=(maxZ-z_min)*1.1, direction=[0,1,0])
+            vFaces = []
+            vOffset = (maxY-y_min)/vSides
+            for i in range(vSides-1):
+                vFaces.append(Topology.Translate(vFace, 0,vOffset*(i+1),0))
+            all_faces = uFaces+vFaces+wFaces
+            if len(all_faces) > 0:
+                f_clus = Cluster.ByTopologies(uFaces+vFaces+wFaces)
+                return Topology.Slice(topology, f_clus, tolerance=tolerance)
+            else:
+                return topology
+
+        if not Topology.IsInstance(topology, "Topology"):
+            if not silent:
+                print("ShapeGrammar.ApplyRule - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        if not matrix == None:
+            if not is_4x4_matrix(matrix):
+                if not silent:
+                    print("ShapeGrammar.ApplyRule - Error: The input matrix parameter is not a valid matrix. Returning None.")
+                return None
+        
+        if not rule == None:
+            input = rule["input"]
+            output = rule["output"]
+            r_matrix = rule["matrix"]
+            operation = rule["operation"]
+            if not operation == None:
+                op_title = operation["title"]
+            else:
+                op_title = "None"
+
+            result_output = topology
+            temp_output = None
+            if not output == None:
+                temp_output = output
+            # Transform the output topology to the input topology to prepare it for final transformation
+            if not r_matrix == None and not output == None:
+                    temp_output = Topology.Transform(output, r_matrix)
+
+            if "replace" in op_title.lower():
+                result_output = temp_output
+            elif "transform" in op_title.lower():
+                result_output = Topology.Transform(topology, r_matrix)
+            elif "union" in op_title.lower():
+                result_output = Topology.Union(input, temp_output)
+            elif "difference" in op_title.lower():
+                result_output = Topology.Difference(input, temp_output)
+            elif "symmetric difference" in op_title.lower():
+                result_output = Topology.SymmetricDifference(input, temp_output)
+            elif "intersect" in op_title.lower():
+                result_output = Topology.Intersect(input, temp_output)
+            elif "merge" in op_title.lower():
+                result_output = Topology.Merge(input, temp_output)
+            elif "slice" in op_title.lower():
+                result_output = Topology.Slice(input, temp_output)
+            elif "impose" in op_title.lower():
+                result_output = Topology.Impose(input, temp_output)
+            elif "imprint" in op_title.lower():
+                result_output = Topology.Imprint(input, temp_output)
+            elif "divide" in op_title.lower():
+                uSides = operation["uSides"]
+                vSides = operation["vSides"]
+                wSides = operation["wSides"]
+                if not uSides == None and not vSides == None and not wSides == None:
+                    result_output = slice(input, uSides, vSides, wSides)
+        
+        # Finally, transform the result to the input topology
+        if not matrix == None:
+            result_output = Topology.Transform(result_output, matrix)
+        
+        return result_output
+
+    def FigureByInputOutput(self, input, output, silent: bool = False):
+        """
+        Returns the Plotly figure of the input and output topologies as a rule.
+
+        Parameters
+        ----------
+        input : topologic_core.Topology
+            The input topology
+        output : topologic_core.Topology
+            The output topology
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        This function does not return a value
+        """
+
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Cell import Cell
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Plotly import Plotly
+
+        if not Topology.IsInstance(input, "Topology"):
+            if not silent:
+                print("ShapeGrammar.DrawInputOutput - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        if not Topology.IsInstance(output, "Topology"):
+            if not silent:
+                print("ShapeGrammar.DrawInputOutput - Error: The output topology parameter is not a valid topology. Returning None.")
+            return None
+
+        input_bb = Topology.BoundingBox(input)
+        input_centroid = Topology.Centroid(input_bb)
+        input_d = Topology.Dictionary(input_bb)
+        xmin = Dictionary.ValueAtKey(input_d, "xmin")
+        ymin = Dictionary.ValueAtKey(input_d, "ymin")
+        zmin = Dictionary.ValueAtKey(input_d, "zmin")
+        xmax = Dictionary.ValueAtKey(input_d, "xmax")
+        ymax = Dictionary.ValueAtKey(input_d, "ymax")
+        zmax = Dictionary.ValueAtKey(input_d, "zmax")
+        input_width = xmax-xmin
+        input_length = ymax-ymin
+        input_height = zmax-zmin
+        input_max = max(input_width, input_length, input_height)
+        sf = 1/input_max
+        temp_input = Topology.Translate(input, -Vertex.X(input_centroid), -Vertex.Y(input_centroid), -Vertex.Z(input_centroid))
+        temp_input = Topology.Scale(temp_input, x=sf, y=sf, z=sf)
+        temp_input = Topology.Translate(temp_input, 0.5, 0, 0)
+
+        output_bb = Topology.BoundingBox(output)
+        output_centroid = Topology.Centroid(output_bb)
+        output_d = Topology.Dictionary(output_bb)
+        xmin = Dictionary.ValueAtKey(output_d, "xmin")
+        ymin = Dictionary.ValueAtKey(output_d, "ymin")
+        zmin = Dictionary.ValueAtKey(output_d, "zmin")
+        xmax = Dictionary.ValueAtKey(output_d, "xmax")
+        ymax = Dictionary.ValueAtKey(output_d, "ymax")
+        zmax = Dictionary.ValueAtKey(output_d, "zmax")
+        output_width = xmax-xmin
+        output_length = ymax-ymin
+        output_height = zmax-zmin
+        output_max = max(output_width, output_length, output_height)
+        sf = 1/output_max
+        temp_output = Topology.Translate(output, -Vertex.X(output_centroid), -Vertex.Y(output_centroid), -Vertex.Z(output_centroid))
+        temp_output = Topology.Scale(temp_output, x=sf, y=sf, z=sf)
+        temp_output = Topology.Translate(temp_output, 2.5, 0, 0)
+
+        cyl = Cell.Cylinder(radius=0.04, height=0.4, placement="bottom")
+        cyl=Topology.Rotate(cyl, axis=[0,1,0], angle=90)
+        cyl = Topology.Translate(cyl, 1.25, 0, 0)
+
+        cone = Cell.Cone(baseRadius=0.1, topRadius=0, height=0.15, placement="bottom")
+        cone=Topology.Rotate(cone, axis=[0,1,0], angle=90)
+        cone = Topology.Translate(cone, 1.65, 0, 0)
+        cluster = Cluster.ByTopologies([temp_input, temp_output, cyl, cone])
+        cluster = Topology.Place(cluster, originA=Topology.Centroid(cluster), originB=Vertex.Origin())
+        data = Plotly.DataByTopology(cluster)
+        fig = Plotly.FigureByData(data)
+        return fig
+    
+    def FigureByRule(self, rule, silent: bool = False):
+        """
+        Returns the Plotly figure of the input rule.
+
+        Parameters
+        ----------
+        rule : dict
+            The input rule
+        silent : bool, optional
+            If True, suppresses error/warning messages. Default is False.
+        
+        Returns
+        -------
+        This function does not return a value
+        """
+        from topologicpy.Topology import Topology
+        if not isinstance(rule, dict):
+            if not silent:
+                print("ShapeGrammar.DrawRule - Error: The input rule parameter is not a valid rule. Returning None.")
+            return None
+        input = rule["input"]
+        output = self.ApplyRule(input, rule)
+        return self.FigureByInputOutput(input, output)

topologicpy/Topology.py

@@ -2118,17 +2118,15 @@ class Topology():
         return Topology.ByDXFFile(file, sides=sides)
 
     @staticmethod
-    def ByIFCFile(file, includeTypes=[], excludeTypes=[], transferDictionaries=False,
+    def ByIFCFile(ifc_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 topology by importing it from an IFC file.
 
         Parameters
         ----------
-        file : file object
+        ifc_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 [].
@@ -2138,18 +2136,6 @@ 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.01.
         tolerance : float , optional
@@ -2162,119 +2148,89 @@ class Topology():
             The created list of topologies.
         
         """
+        import multiprocessing
         import ifcopenshell
         import ifcopenshell.geom
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Face import Face
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
-        from concurrent.futures import ThreadPoolExecutor
-        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)
-
-        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]
-
+        
+        # 1 Guard against including and excluding the same types
+        includeTypes = [s.lower() for s in includeTypes]
+        excludeTypes = [s.lower() for s in excludeTypes]
+        if len(includeTypes) > 0 and len(excludeTypes) > 0:
+            excludeTypes = [s for s in excludeTypes if s not in includeTypes]
+        # 2 Setup geometry settings
         settings = ifcopenshell.geom.settings()
         settings.set(settings.USE_WORLD_COORDS, True)
+        # A string representation of the OCC representation
+        settings.set("iterator-output", ifcopenshell.ifcopenshell_wrapper.NATIVE)
+        # A string representation of the OCC representation
         settings.set("iterator-output", ifcopenshell.ifcopenshell_wrapper.SERIALIZED)
+        
+        # 3 Create iterator
+        it = ifcopenshell.geom.iterator(settings, ifc_file, multiprocessing.cpu_count())
+        if not it.initialize():
+            if not silent:
+                print("Topology.ByIFCFile")
+            raise RuntimeError("Geometry iterator failed to initialize")
 
+        # 4) Loop over shapes
         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
+
+        while True:
+            shape = it.get()
+            element = ifc_file.by_guid(shape.guid)
+            element_type = element.is_a().lower()
+            if ((element_type in includeTypes) or (len(includeTypes) == 0)) and ((not element_type in excludeTypes) or (len(excludeTypes) == 0)):
+                geom = shape.geometry
+                topology = Topology.ByBREPString(geom.brep_data)
+                faces = Topology.Faces(topology)
+                new_faces = []
+                for face in faces:
+                    eb = Face.ExternalBoundary(face)
+                    ib = Face.InternalBoundaries(face)
+                    f = Face.ByWires(eb, ib)
+                    new_faces.append(f)
+                topology = Topology.SelfMerge(Cluster.ByTopologies(new_faces))
                 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)
+                if transferDictionaries:
+                    element_dict = {
+                        "TOPOLOGIC_id": str(Topology.UUID(topology)),
+                        "TOPOLOGIC_name": getattr(element, 'Name', "Untitled"),
+                        "TOPOLOGIC_type": Topology.TypeAsString(topology),
+                        "IFC_global_id": getattr(element, 'GlobalId', 0),
+                        "IFC_name": getattr(element, 'Name', "Untitled"),
+                        "IFC_type": element_type
+                    }
+
+                    # Optionally add property sets
+                    psets = {}
+                    if hasattr(element, 'IsDefinedBy'):
+                        for rel in element.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(element_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)
+            if not it.next():
+                break
 
-            # 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
+        return topologies
 
     @staticmethod
     def _ByIFCFile_old(file, includeTypes=[], excludeTypes=[], transferDictionaries=False, removeCoplanarFaces=False):
@@ -6590,15 +6546,19 @@ class Topology():
                     return False, None
         # Done with Exclusion Tests.
 
-        faces_a = Topology.Faces(topologyA)
-        faces_b = Topology.Faces(topologyB)
-        if len(faces_a) > 0 and len(faces_b) > 0:
-            largest_faces_a = Topology.LargestFaces(topologyA)
-            largest_faces_b = Topology.LargestFaces(topologyB)
+        if Topology.IsInstance(topologyA, "face"):
+            largest_faces_a = [topologyA]
+            largest_faces_b = [topologyB]
         else:
-            if not silent:
-                print("Topology.IsSimilar - Error: The topologies do not have faces. Returning None.")
-            return False, None
+            faces_a = Topology.Faces(topologyA)
+            faces_b = Topology.Faces(topologyB)
+            if len(faces_a) > 0 and len(faces_b) > 0:
+                largest_faces_a = Topology.LargestFaces(topologyA)
+                largest_faces_b = Topology.LargestFaces(topologyB)
+            else:
+                if not silent:
+                    print("Topology.IsSimilar - Error: The topologies do not have faces. Returning None.")
+                return False, None
 
     # Process largest faces
         for face_a in largest_faces_a:
@@ -9949,7 +9909,6 @@ class Topology():
             
             # Extract translation (last column of the matrix)
             translation = [m[3] for m in matrix[:3]]
-            print("translation", translation)
             x_translate, y_translate, z_translate = translation
             
             # Extract rotation (top-left 3x3 part of the matrix)
@@ -9957,7 +9916,6 @@ class Topology():
             
             # Extract scaling (diagonal of the matrix)
             scaling_factors = [matrix[m][m] for m in [0,1,2]]  # scaling is stored in the diagonal of the rotation matrix
-            print(scaling_factors)
             x_scale, y_scale, z_scale = scaling_factors
             
             # Step 1: Apply Scaling

topologicpy/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.28
+Version: 0.8.30
 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.28.dist-info → topologicpy-0.8.30.dist-info}/RECORD

@@ -18,20 +18,21 @@ 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=s0fC_eNsgJN8zkkY_EomZi6jnKCIdtrVYsgnS51MWkU,119271
+topologicpy/Plotly.py,sha256=FIFahDnWhvbQ--VJjy3lQGl5735w8hDzZNrVkCkpZFE,119455
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
+topologicpy/ShapeGrammar.py,sha256=JwE__VcKum5X3r33WwToEWtpJdFuhzZYyNhU2ob15ss,21194
 topologicpy/Shell.py,sha256=h8S2nP1e0JtMxeOdAFZVhOYTJWTW8vlZRM5lxK0gu2o,89577
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=_VBBAUIDhvpkp72JBZlv7k9qx9jYubm3yM56UZ1Nc6c,36837
-topologicpy/Topology.py,sha256=3wTW_C3lquA7lc5sLMxxoBj53Ygc--6hLl5LGvnv3NI,478412
+topologicpy/Topology.py,sha256=De_-naqB-hBPjcFeDQjbKUS7QzfhVxWJzu-7IMqLojc,476669
 topologicpy/Vector.py,sha256=mx7fgABdioikPWM9HzXKzmqfx3u_XBcU_jlLD4qK2x8,42407
 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=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/version.py,sha256=jN0mlk8vix45n9If_9Klf_t7fIZ7At3hYPz3_y-xov4,23
+topologicpy-0.8.30.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.30.dist-info/METADATA,sha256=RlkwNXmDCcLnsl11dRg0HUVn5D2vEq9BmcH2mJ4zRMU,10535
+topologicpy-0.8.30.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+topologicpy-0.8.30.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.30.dist-info/RECORD,,

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

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