topologicpy 0.8.2__py3-none-any.whl → 0.8.4__py3-none-any.whl

topologicpy/Edge.py

@@ -325,6 +325,50 @@ class Edge():
             edge = None
         return edge
     
+    @staticmethod
+    def ByOriginDirectionLength(origin = None, direction=[0,0,1], length: float = 1.0, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Creates a straight edge from the input parameters.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex
+            The origin (start vertex) of the edge.
+        direction : list , optional
+            The desired direction vector of the edge. The default is [0,0,1] (pointing up in the Z direction)
+        length: float , optional
+            The desired length of edge. The default is 1.0.
+        tolerance : float , optional
+            The desired tolerance to decide if an edge can be created. 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
+        -------
+        topologic_core.Edge
+            The created edge.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+
+        if origin == None:
+            origin = Vertex.Origin()
+        
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Edge.ByVertexDirectionLength - Error: The input vertex parameter is not a valid vertex. Returning None.")
+            return None
+        
+        if length < tolerance:
+            if not silent:
+                print("Edge.ByVertexDirectionLength - Error: The input edge parameter must not be less than the input tolerance parameter. Returning None.")
+            return None
+
+        endVertex = Topology.TranslateByDirectionDistance(origin, direction=direction[:3], distance=length)
+        edge = Edge.ByVertices(origin, endVertex, tolerance=tolerance)
+        return edge
+
     @staticmethod
     def ByVertices(*args, tolerance: float = 0.0001, silent: bool = False):
         """

topologicpy/Matrix.py

@@ -204,6 +204,46 @@ class Matrix:
         e_vectors = Helper.Sort(e_vectors, list(eigenvalues))
         return e_values, e_vectors
     
+    @staticmethod
+    def Invert(matA, silent: bool = False):
+        """
+        Inverts the input matrix.
+
+        Parameters
+        ----------
+        matA : list of list of float
+            The input matrix.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        list of list of float
+            The resulting matrix after it has been inverted.
+
+        """
+        import numpy as np
+
+        if not isinstance(matA, list):
+            if not silent:
+                print("Matrix.Invert - Error: The input matA parameter is not a valid 4X4 matrix. Returning None.")
+            return None
+        np_matrix = np.array(matA)
+        if np_matrix.shape != (4, 4):
+            if not silent:
+                print("Matrix.Invert - Error: The input matA parameter is not a valid 4X4 matrix. Returning None.")
+            return None
+        
+        # Check if the matrix is invertible
+        if np.isclose(np.linalg.det(np_matrix), 0):
+            if not silent:
+                print("Matrix.Invert - Error: The input matA parameter is not invertible. Returning None.")
+            return None
+        
+        # Invert the matrix
+        inverted_matrix = np.linalg.inv(np_matrix)
+        return inverted_matrix.tolist()
+    
     @staticmethod
     def Multiply(matA, matB):
         """

topologicpy/Plotly.py

@@ -714,15 +714,6 @@ class Plotly:
             traces.append(trace)
         return traces
 
-
-
-
-
-
-
-
-
-
     @staticmethod
     def DataByTopology(topology,
                        showVertices=True,
@@ -1106,9 +1097,10 @@ class Plotly:
                 faceColor = Dictionary.ValueAtKey(d, key=faceColorKey) or faceColor
             if not faceOpacityKey == None:
                 d = Topology.Dictionary(topology)
-                d_opacity = Dictionary.ValueAtKey(d, key=faceOpacityKey) or faceOpacity
-                if 0 < d_opacity < 1:
-                    faceOpacity = d_opacity
+                d_opacity = Dictionary.ValueAtKey(d, key=faceOpacityKey)
+                if not d_opacity == None:
+                    if 0 <= d_opacity <= 1:
+                        faceOpacity = d_opacity
             if Topology.IsInstance(topology, "Face"):
                 tp_faces = [topology]
             else:

topologicpy/Topology.py

@@ -4126,6 +4126,116 @@ class Topology():
             return None
         return Topology.ByXYZFile(file, frameIdKey=frameIdKey, vertexIdKey=frameIdKey)
     
+    def CanonicalMatrix(topology, n: int = 10, normalize: bool = False, mantissa: int = 6, silent: bool = False):
+        """
+        Returns the canonical matrix of the input topology.
+        The canonical matrix refers to a transformation matrix that maps an object's
+        coordinate system to a canonical coordinate frame, where:
+        . The origin of the object aligns with the world origin
+        . The principal axes of the object align with the world axes
+        This transformation is computed using Principal Component Analysis (PCA),
+        leveraging the eigenvectors of the covariance matrix of the object's vertices
+        and thus can give erroneous results. The transformation matrix may not yield an object oriented as expected.
+        
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        n : int , optional
+            The number of segments to use to increase the number of points on each face. The default is 10.
+        normalize : bool , optional
+            If set to True, the longest edge in the input topology is scaled to become of length 1. The default is False.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        list
+            The 4X4 canonical matrix.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.CellComplex import CellComplex
+        from topologicpy.Topology import Topology
+        from topologicpy.Grid import Grid
+        from topologicpy.Matrix import Matrix
+        import numpy as np
+
+        def generate_floats(n):
+            if n < 2:
+                return [0.0] if n == 1 else []
+            return [i / (n - 1) for i in range(n)]
+
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Topology.CanonicalMatrix - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        
+        faces = Topology.Faces(topology)
+        if len(faces) == 0:
+            if not silent:
+                print("Topology.CanonicalMatrix - Error: The input topology parameter does not contain any faces. Returning None.")
+            return None
+        
+        # Step 1: Derive a copy topology to work with.
+        if Topology.IsInstance(topology, "CellComplex"):
+            top = CellComplex.ExternalBoundary(topology)
+        else:
+            top = Topology.Copy(topology)
+        
+        # Step 2: Create a Translation Matrix to translate to origin
+        centroid = Topology.Centroid(top)
+        translation_matrix = Matrix.ByTranslation(-Vertex.X(centroid, mantissa=mantissa), -Vertex.Y(centroid, mantissa=mantissa), -Vertex.Z(centroid, mantissa=mantissa))
+        translated_top = Topology.Translate(top, -Vertex.X(centroid, mantissa=mantissa), -Vertex.Y(centroid, mantissa=mantissa), -Vertex.Z(centroid, mantissa=mantissa))
+
+        # Step 3: Create a Scaling matrix to normalize size (e.g., largest edge length to 1)
+        if normalize == False:
+            scale_factor = 1.0
+        else:
+            edges = Topology.Edges(translated_top)
+            max_edge_length = max([Edge.Length(edge, mantissa=mantissa) for edge in edges])
+            scale_factor = 1.0 / max_edge_length if max_edge_length != 0 else 1.0
+        scaling_matrix = Matrix.ByScaling(scaleX=scale_factor, scaleY=scale_factor, scaleZ=scale_factor)
+        scaled_top = Topology.Scale(translated_top, origin=Vertex.Origin(), x=scale_factor, y=scale_factor, z=scale_factor)
+
+        # Step 4: Increase the number of vertices by adding a grid of points on each face.
+        faces = Topology.Faces(scaled_top)
+        vertices = Topology.Vertices(scaled_top)
+        r = generate_floats(n)
+        for face in faces:
+            vertices += Topology.Vertices(Grid.VerticesByParameters(face=face, uRange=r, vRange=r, clip=True))
+        points = np.array([[Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa), Vertex.Z(v, mantissa=mantissa)] for v in vertices])
+
+        # Step 5: Align orientation using PCA
+        # Compute PCA
+        mean = points.mean(axis=0)
+        centered_points = points - mean
+        covariance_matrix = np.cov(centered_points.T)
+        eigenvalues, eigenvectors = np.linalg.eigh(covariance_matrix)
+
+        # Step 6: Sort eigenvectors by eigenvalues (largest first)
+        sorted_indices = np.argsort(-eigenvalues)
+        eigenvectors = eigenvectors[:, sorted_indices]
+
+        # Step 7: Enforce consistent orientation by flipping eigenvectors
+        for i in range(3):  # Ensure each eigenvector points in a positive direction
+            if np.dot(eigenvectors[:, i], [1, 0, 0]) < 0:
+                eigenvectors[:, i] *= -1
+        
+        # Step 8: Create the rotation matrix
+        rotation_matrix = np.eye(4)
+        rotation_matrix[:3, :3] = eigenvectors.T  # Use transpose to align points to axes
+        
+        # Step 9: Rotate the object to align it 
+        transformation_matrix = Matrix.Multiply(scaling_matrix, translation_matrix)
+        transformation_matrix = Matrix.Multiply(rotation_matrix.tolist(), transformation_matrix)
+
+        # Step 10: Return the resulting matrix
+        return transformation_matrix
+
     @staticmethod
     def CenterOfMass(topology):
         """
@@ -6492,9 +6602,9 @@ class Topology():
             return None
         return topologic.Topology.IsSame(topologyA, topologyB)
     
-    def IsVertexMatched(topologyA, topologyB, mantissa: int = 6, tolerance=0.0001, silent : bool = False):
+    def IsVertexCongruent(topologyA, topologyB, mantissa: int = 6, tolerance=0.0001, silent : bool = False):
         """
-        Returns True if the input topologies are vertex matched (have same number of vertices and all vertices are coincedent within a tolerance). Returns False otherwise.
+        Returns True if the input topologies are vertex matched (have same number of vertices and all vertices are congruent within a tolerance). Returns False otherwise.
 
         Parameters
         ----------
@@ -6512,7 +6622,7 @@ class Topology():
         Returns
         -------
         bool
-            True of the input topologies are vertex matched. False otherwise.
+            True of the input topologies are vertex congruent. False otherwise.
 
         """
         from topologicpy.Vertex import Vertex
@@ -6573,6 +6683,104 @@ class Topology():
         coords_b = [Vertex.Coordinates(v, mantissa=mantissa) for v in vertices_b]
         return coordinates_match(coords_a, coords_b, tolerance=tolerance)
 
+    @staticmethod
+    def LargestFaces(topology, removeCoplanarFaces: bool = False, epsilon: float = 0.001, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns the list of the largest faces found in the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        removeCoplanarFaces : bool , optional
+            If set to True, coplanar faces are removed to find the true largest faces. Otherwise they are not. The default is False.
+        epsilon : float , optional
+            The desired epsilon (another form of tolerance) for finding if two faces are coplanar. The default is 0.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 list of the largest faces found in the input topology.
+        
+        """
+        from topologicpy.Face import Face
+
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Topology.LaregestFaces - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        faces = Topology.Faces(topology)
+        if len(faces) == 0:
+            if not silent:
+                print("Topology.LargestFaces - Error: The input topology parameter does not contain any faces. Returning None.")
+            return None
+        if len(faces) == 1:
+            return faces
+        
+        if removeCoplanarFaces == True:
+            simple_topology = Topology.RemoveCoplanarFaces(topology)
+            simple_topology = Topology.RemoveCollinearEdges(simple_topology)
+            faces = Topology.Faces(simple_topology)
+        face_areas = [Face.Area(face) for face in faces]
+        max_area = max(face_areas)
+        max_faces = []
+        for i, face_area in enumerate(face_areas):
+            if abs(max_area - face_area) < tolerance:
+                max_faces.append(faces[i])
+        return max_faces
+
+    @staticmethod
+    def LongestEdges(topology, removeCoplanarFaces: bool = False, epsilon: float = 0.001, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns the list of the longest edges found in the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        removeCoplanarFaces : bool , optional
+            If set to True, coplanar faces are removed to find the true longest straight edges. Otherwise they are not. The default is False.
+        epsilon : float , optional
+            The desired epsilon (another form of tolerance) for finding if two faces are coplanar. The default is 0.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 list of of the longest edges found in the input topology.
+        
+        """
+        from topologicpy.Edge import Edge
+
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Topology.LongestEdges - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        edges = Topology.Edges(topology)
+        if len(edges) == 0:
+            if not silent:
+                print("Topology.LongestEdges - Error: The input topology parameter does not contain any edges. Returning None.")
+            return None
+        if len(edges) == 1:
+            return edges
+        
+        if removeCoplanarFaces == True:
+            simple_topology = Topology.RemoveCoplanarFaces(topology)
+            simple_topology = Topology.RemoveCollinearEdges(simple_topology)
+            edges = Topology.Edges(simple_topology)
+        edge_lengths = [Edge.Length(edge) for edge in edges]
+        max_length = max(edge_lengths)
+        max_edges = []
+        for i, edge_length in enumerate(edge_lengths):
+            if abs(max_length - edge_length) < tolerance:
+                max_edges.append(edges[i])
+        return max_edges
+
     @staticmethod
     def MergeAll(topologies, tolerance=0.0001):
         """
@@ -6833,7 +7041,7 @@ class Topology():
         originB : topologic_core.Vertex , optional
             The new location at which to place the topology. If set to None, the world origin (0, 0, 0) is used. The default is None.
         mantissa : int , optional
-            The desired length of the mantissa. The default is 6
+            The desired length of the mantissa. The default is 6.
 
         Returns
         -------
@@ -6860,6 +7068,90 @@ class Topology():
             newTopology = None
         return newTopology
 
+    @staticmethod
+    def PrincipalAxes(topology, n: int = 10, mantissa: int = 6, silent: bool = False):
+        """
+        Returns the prinicipal axes (vectors) of the input topology.
+        Please note that this is not a perfect algorithm and it can get confused based on the geometry of the input.
+        Also, please note that there is no guarantee that three returned vectors match your expectation for an x,y,z axis order.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        n : int , optional
+            The number of segments to use to increase the number of points on each face. The default is 10.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        list
+            The list of x, y, and z vectors representing the principal axes of the topology.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.CellComplex import CellComplex
+        from topologicpy.Topology import Topology
+        from topologicpy.Grid import Grid
+        from topologicpy.Vector import Vector
+        import numpy as np
+
+        def generate_floats(n):
+            if n < 2:
+                return [0.0] if n == 1 else []
+            return [i / (n - 1) for i in range(n)]
+
+        
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Topology.CanonicalMatrix - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        
+        faces = Topology.Faces(topology)
+        if len(faces) == 0:
+            if not silent:
+                print("Topology.CanonicalMatrix - Error: The input topology parameter does not contain any faces. Returning None.")
+            return None
+        
+        # Step 1: Derive a copy topology to work with.
+        if Topology.IsInstance(topology, "CellComplex"):
+            top = CellComplex.ExternalBoundary(topology)
+        else:
+            top = Topology.Copy(topology)
+        
+        # Step 2: Increase the number of vertices by adding a grid of points on each face.
+        faces = Topology.Faces(top)
+        vertices = Topology.Vertices(top)
+        r = generate_floats(n)
+        for face in faces:
+            vertices += Topology.Vertices(Grid.VerticesByParameters(face=face, uRange=r, vRange=r, clip=True))
+        points = np.array([[Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa), Vertex.Z(v, mantissa=mantissa)] for v in vertices])
+
+        # Step 3: Align orientation using PCA
+        # Compute PCA
+        mean = points.mean(axis=0)
+        centered_points = points - mean
+        covariance_matrix = np.cov(centered_points.T)
+        eigenvalues, eigenvectors = np.linalg.eigh(covariance_matrix)
+
+        # Sort eigenvectors by eigenvalues (largest first)
+        sorted_indices = np.argsort(-eigenvalues)
+        eigenvectors = eigenvectors[:, sorted_indices]
+
+        # Enforce consistent orientation by flipping eigenvectors
+        for i in range(3):  # Ensure each eigenvector points in a positive direction
+            if np.dot(eigenvectors[:, i], [1, 0, 0]) < 0:
+                eigenvectors[:, i] *= -1
+        
+        # Retrieve and return the principal axes
+        x_axis = Vector.ByCoordinates(*eigenvectors[:, 0])
+        y_axis = Vector.ByCoordinates(*eigenvectors[:, 1])
+        z_axis = Vector.ByCoordinates(*eigenvectors[:, 2])
+        return x_axis, y_axis, z_axis
+
     @staticmethod
     def RemoveCollinearEdges(topology, angTolerance: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
@@ -7978,7 +8270,6 @@ class Topology():
                 l = None
         return l
     
-    
     @staticmethod
     def SharedFaces(topologyA, topologyB):
         """
@@ -8005,7 +8296,56 @@ class Topology():
             except:
                 l = None
         return l
-    
+
+    @staticmethod
+    def ShortestEdges(topology, removeCoplanarFaces: bool = False, epsilon: float = 0.001, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns the list of the shortest edges found in the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        removeCoplanarFaces : bool , optional
+            If set to True, coplanar faces are removed to find the true shortest straight edges. Otherwise they are not. The default is False.
+        epsilon : float , optional
+            The desired epsilon (another form of tolerance) for finding if two faces are coplanar. The default is 0.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 list of the shortest edges found in the input topology.
+        
+        """
+        from topologicpy.Edge import Edge
+
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Topology.ShortestEdges - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        edges = Topology.Edges(topology)
+        if len(edges) == 0:
+            if not silent:
+                print("Topology.ShortestEdges - Error: The input topology parameter does not contain any edges. Returning None.")
+            return None
+        if len(edges) == 1:
+            return edges[0]
+        
+        if removeCoplanarFaces == True:
+            simple_topology = Topology.RemoveCoplanarFaces(topology)
+            simple_topology = Topology.RemoveCollinearEdges(simple_topology)
+            edges = Topology.Edges(simple_topology)
+        edge_lengths = [Edge.Length(edge) for edge in edges]
+        min_length = min(edge_lengths)
+        min_edges = []
+        for i, edge_length in enumerate(edge_lengths):
+            if abs(min_length - edge_length) < tolerance:
+                min_edges.append(edges[i])
+        return min_edges
+
     @staticmethod
     def Show(*topologies,
              nameKey = "name",
@@ -8424,6 +8764,55 @@ class Topology():
             figure = Plotly.AddColorBar(figure, values=cbValues, nTicks=cbTicks, xPosition=cbX, width=cbWidth, outlineWidth=cbOutlineWidth, title=cbTitle, subTitle=cbSubTitle, units=cbUnits, colorScale=colorScale, mantissa=mantissa)
         Plotly.Show(figure=figure, renderer=renderer, camera=camera, center=center, up=up, projection=projection)
 
+    @staticmethod
+    def SmallestFaces(topology, removeCoplanarFaces: bool = False, epsilon: float = 0.001, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns the list of the smallest faces found in the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        removeCoplanarFaces : bool , optional
+            If set to True, coplanar faces are removed to find the true smallest faces. Otherwise they are not. The default is False.
+        epsilon : float , optional
+            The desired epsilon (another form of tolerance) for finding if two faces are coplanar. The default is 0.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 list of the smallest faces found in the input topology.
+        
+        """
+        from topologicpy.Face import Face
+
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Topology.SmallestFaces - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        faces = Topology.Faces(topology)
+        if len(faces) == 0:
+            if not silent:
+                print("Topology.SmallestFaces - Error: The input topology parameter does not contain any faces. Returning None.")
+            return None
+        if len(faces) == 1:
+            return faces
+        
+        if removeCoplanarFaces == True:
+            simple_topology = Topology.RemoveCoplanarFaces(topology)
+            simple_topology = Topology.RemoveCollinearEdges(simple_topology)
+            faces = Topology.Faces(simple_topology)
+        face_areas = [Face.Area(face) for face in faces]
+        min_area = min(face_areas)
+        min_faces = []
+        for i, face_area in enumerate(face_areas):
+            if abs(min_area - face_area) < tolerance:
+                min_faces.append(faces[i])
+        return min_faces
+
     @staticmethod
     def SortBySelectors(topologies, selectors, exclusive=False, tolerance=0.0001):
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.2'
+__version__ = '0.8.4'

{topologicpy-0.8.2.dist-info → topologicpy-0.8.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: topologicpy
-Version: 0.8.2
+Version: 0.8.4
 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
@@ -115,12 +115,12 @@ To cite one of the main papers that defines topologicpy, you can use:
 
 Or you can import the following .bib formatted references into your favourite reference manager
 ```
-@misc{Jabi2024,
+@misc{Jabi2025,
    author = {Wassim Jabi},
    doi = {https://doi.org/10.5281/zenodo.11555173},
    title = {topologicpy},
    url = {http://pypi.org/projects/topologicpy},
-   year = {2024},
+   year = {2025},
 }
 ```
 ```
@@ -140,6 +140,6 @@ Or you can import the following .bib formatted references into your favourite re
 }
 ```
 
-topologicpy: © 2024 Wassim Jabi
+topologicpy: © 2025 Wassim Jabi
 
-Topologic: © 2024 Cardiff University and UCL
+Topologic: © 2025 Cardiff University and UCL

{topologicpy-0.8.2.dist-info → topologicpy-0.8.4.dist-info}/RECORD

@@ -8,29 +8,29 @@ topologicpy/Color.py,sha256=q9xsGmxFMz7sQKmygwSVS12GaTRB-OT0-_i6t3-cthE,20307
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
 topologicpy/DGL.py,sha256=M_znFtyPBJJz-iXLYZs2wwBj24fhevIo739dGha0chM,139041
 topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,33186
-topologicpy/Edge.py,sha256=4Rl6M9ex66Q9-kNvi_Lg7UlAwdvMzpeFlxlieI3amn0,69511
+topologicpy/Edge.py,sha256=lWwJdQkAhiH5POB7TN6HSLv03g2jXHzBU7e2fE3eAno,71340
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=D1g4O5i5QMPZvIoX06Z-FsyNsYBDkCiHWJp00uqnr5o,180742
 topologicpy/Graph.py,sha256=T_NC-Gvf7F7DWdfWvQB7sQ_v790lTT74SLKTl-UhSZE,492072
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=DAAE_Ie_ekeMnCvcW08xXRwSAGCkjrS4lbz-o3ELuY4,27172
 topologicpy/Honeybee.py,sha256=Y_El6M8x3ixvvIe_VcRiwj_4C89ZZg5_WlT7adbCkpw,21849
-topologicpy/Matrix.py,sha256=QOQ7W12344hMLXfSTlJcluOm7od25LImWKKb2O0ADmg,9572
+topologicpy/Matrix.py,sha256=ydw0EH4rZcGBFeLmBHPIyuk57DVKKL3M1GcArkFsYxM,10941
 topologicpy/Neo4j.py,sha256=BKOF29fRgXmdpMGkrNzuYbyqgCJ6ElPPMYlfTxXiVbc,22392
-topologicpy/Plotly.py,sha256=Tvo0_zKVEHtPhsMNNvLy5G0HIys5FPAOyp_o4QN_I_A,115760
+topologicpy/Plotly.py,sha256=xfd_c2Mcam5KP-gDD-esl42RVXW5TSJsUCCqhUg1VFk,115788
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=fLRnQ79vtdBDRW1Xn8Gaap34XheGbw7UBFd-ALJ2Y1g,87978
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=-7OsjGeJ64NKcEONee9SqOeh1YQ6yGHEzIPxycQCUdA,445348
+topologicpy/Topology.py,sha256=IHLJxh0TQ7P8Git4qfFDlvas81JXaKQGjxwgBzIX1T0,463367
 topologicpy/Vector.py,sha256=Cl7besf20cAGmyNPh-9gbFAHnRU5ZWSMChJ3VyFIDs4,35416
 topologicpy/Vertex.py,sha256=tv6C-rbuNgXHDGgVLT5fbalynLdXqlUuiCDKtkeQ0vk,77814
 topologicpy/Wire.py,sha256=Gl3Jpygwp8775SG57ua5r5ffTHcN4FOAkeI87yP1cok,234001
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=K2rsUy8S7UHe3tStL6NCs5z92apbvbkrpGIEjcCNCNs,22
-topologicpy-0.8.2.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.2.dist-info/METADATA,sha256=DBa_orJTbm3dIrzhCaCiTfsaqfvkAg1jaxCdeHFoeQA,10512
-topologicpy-0.8.2.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-topologicpy-0.8.2.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.2.dist-info/RECORD,,
+topologicpy/version.py,sha256=PtH7P3DXedvpK4LWSSxCTW38cmEXvmG6EvUpXZC-eLo,22
+topologicpy-0.8.4.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.4.dist-info/METADATA,sha256=WsO5JswYFeodLDlAb5Jv9TnaIhSl0z2ge2fhH-3hLpw,10512
+topologicpy-0.8.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+topologicpy-0.8.4.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.4.dist-info/RECORD,,

{topologicpy-0.8.2.dist-info → topologicpy-0.8.4.dist-info}/WHEEL

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