topologicpy 0.7.17__py3-none-any.whl → 0.7.18__py3-none-any.whl

topologicpy/Cell.py

@@ -377,6 +377,8 @@ class Cell():
             If set to True, the last wire in the list of input wires will be connected to the first wire in the list of input wires. The default is False.
         triangulate : bool , optional
             If set to True, the faces will be triangulated. The default is True.
+        planarize : bool, optional
+            If set to True, the created faces are planarized before building the cell. Otherwise, they are not. The default is False.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -908,7 +910,7 @@ class Cell():
         from topologicpy.Topology import Topology
 
         def angleCode(f, up, tiltAngle):
-            dirA = Face.NormalAtParameters(f)
+            dirA = Face.Normal(f)
             ang = round(Vector.Angle(dirA, up), 2)
             if abs(ang - 90) < tiltAngle:
                 code = 0

topologicpy/CellComplex.py

@@ -467,7 +467,7 @@ class CellComplex():
         from topologicpy.Topology import Topology
 
         def angleCode(f, up, tiltAngle):
-            dirA = Face.NormalAtParameters(f)
+            dirA = Face.Normal(f)
             ang = round(Vector.Angle(dirA, up), 2)
             if abs(ang - 90) < tiltAngle:
                 code = 0

topologicpy/Face.py

@@ -131,8 +131,8 @@ class Face():
         if not Topology.IsInstance(faceB, "Face"):
             print("Face.Angle - Warning: The input faceB parameter is not a valid topologic face. Returning None.")
             return None
-        dirA = Face.NormalAtParameters(faceA, 0.5, 0.5, "xyz", 3)
-        dirB = Face.NormalAtParameters(faceB, 0.5, 0.5, "xyz", 3)
+        dirA = Face.Normal(faceA, outputType="xyz", mantissa=3)
+        dirB = Face.Normal(faceB, outputType="xyz", mantissa=3)
         return round((Vector.Angle(dirA, dirB)), mantissa)
 
     @staticmethod
@@ -439,7 +439,9 @@ class Face():
         if not Topology.IsInstance(wire, "Wire"):
             print("Face.ByThickenedWire - Error: The input wire parameter is not a valid wire. Returning None.")
             return None
-
+        if not Wire.IsManifold(wire):
+            print("Face.ByThickenedWire - Error: The input wire parameter is not a manifold wire. Returning None.")
+            return None
         three_vertices = Wire.Vertices(wire)[0:3]
         temp_w = Wire.ByVertices(three_vertices, close=True)
         flat_face = Face.ByWire(temp_w, tolerance=tolerance)
@@ -858,7 +860,7 @@ class Face():
             return None
         if not north:
             north = Vector.North()
-        dirA = Face.NormalAtParameters(face,mantissa=mantissa)
+        dirA = Face.Normal(face, outputType="xyz", mantissa=mantissa)
         return Vector.CompassAngle(vectorA=dirA, vectorB=north, mantissa=mantissa, tolerance=tolerance)
 
     @staticmethod
@@ -1041,12 +1043,9 @@ class Face():
 
         eb = face.ExternalBoundary()
         f_dir = Face.Normal(face)
-        faceVertices = Topology.Vertices(eb)
-        temp_face = Face.ByWire(eb)
-        temp_dir = Face.Normal(temp_face)
-        if Vector.IsAntiParallel(f_dir, temp_dir):
-            faceVertices.reverse()
-        eb = Wire.ByVertices(faceVertices)
+        w_dir = Wire.Normal(eb)
+        if Vector.IsAntiParallel(f_dir, w_dir):
+            eb = Wire.Reverse(eb)
         return eb
     
     @staticmethod
@@ -1648,7 +1647,7 @@ class Face():
         return medialAxis
 
     @staticmethod
-    def Normal(face, outputType: str = "xyz", mantissa: int = 6) -> list:
+    def Normal(face, outputType="xyz", mantissa=6):
         """
         Returns the normal vector to the input face. A normal vector of a face is a vector perpendicular to it.
 
@@ -1661,55 +1660,86 @@ class Face():
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
 
-        Returns
-        -------
-        list
-            The normal vector to the input face. This is computed at the approximate center of the face.
-
-        """
-        return Face.NormalAtParameters(face, u=0.5, v=0.5, outputType=outputType, mantissa=mantissa)
-
-    @staticmethod
-    def NormalAtParameters(face, u: float = 0.5, v: float = 0.5, outputType: str = "xyz", mantissa: int = 6) -> list:
-        """
-        Returns the normal vector to the input face. A normal vector of a face is a vector perpendicular to it.
-
-        Parameters
-        ----------
-        face : topologic_core.Face
-            The input face.
-        u : float , optional
-            The *u* parameter at which to compute the normal to the input face. The default is 0.5.
-        v : float , optional
-            The *v* parameter at which to compute the normal to the input face. The default is 0.5.
-        outputType : string , optional
-            The string defining the desired output. This can be any subset or permutation of "xyz". It is case insensitive. The default is "xyz".
-        mantissa : int , optional
-            The desired length of the mantissa. The default is 6.
-
         Returns
         -------
         list
             The normal vector to the input face.
 
         """
-        returnResult = []
+        from topologicpy.Topology import Topology
+        from topologicpy.Vertex import Vertex
+        import os
+        import warnings
         try:
-            coords = topologic.FaceUtility.NormalAtParameters(face, u, v) # Hook to Core
-            x = round(coords[0], mantissa)
-            y = round(coords[1], mantissa)
-            z = round(coords[2], mantissa)
-            outputType = list(outputType.lower())
-            for axis in outputType:
-                if axis == "x":
-                    returnResult.append(x)
-                elif axis == "y":
-                    returnResult.append(y)
-                elif axis == "z":
-                    returnResult.append(z)
+            import numpy as np
         except:
-            returnResult = None
-        return returnResult
+            print("Face.Normal - Warning: Installing required numpy library.")
+            try:
+                os.system("pip install numpy")
+            except:
+                os.system("pip install numpy --user")
+            try:
+                import numpy as np
+                print("Face.Normal - Warning: numpy library installed correctly.")
+            except:
+                warnings.warn("Face.Normal - Error: Could not import numpy. Please try to install numpy manually. Returning None.")
+                return None
+
+        if not Topology.IsInstance(face, "Face"):
+            print("Face.Normal - Error: The input face parameter is not a valid face. Returning None.")
+            return None
+        
+        vertices = Topology.Vertices(face)
+        vertices = [Vertex.Coordinates(v, mantissa=mantissa) for v in vertices]
+        
+        if len(vertices) < 3:
+            print("Face.Normal - Error: At least three vertices are required to define a plane. Returning None.")
+            return None
+        
+        # Convert vertices to numpy array for easier manipulation
+        vertices = np.array(vertices)
+        
+        # Try to find two non-collinear edge vectors
+        vec1 = None
+        vec2 = None
+        for i in range(1, len(vertices)):
+            for j in range(i + 1, len(vertices)):
+                temp_vec1 = vertices[i] - vertices[0]
+                temp_vec2 = vertices[j] - vertices[0]
+                cross_product = np.cross(temp_vec1, temp_vec2)
+                if np.linalg.norm(cross_product) > 1e-6:  # Check if the cross product is not near zero
+                    vec1 = temp_vec1
+                    vec2 = temp_vec2
+                    break
+            if vec1 is not None and vec2 is not None:
+                break
+        
+        if vec1 is None or vec2 is None:
+            print("Face.Normal - Error: The given vertices do not form a valid plane (all vertices might be collinear). Returning None.")
+            return None
+        
+        # Calculate the cross product of the two edge vectors
+        normal = np.cross(vec1, vec2)
+
+        # Normalize the normal vector
+        normal_length = np.linalg.norm(normal)
+        if normal_length == 0:
+            print("Face.Normal - Error: The given vertices do not form a valid plane (cross product resulted in a zero vector). Returning None.")
+            return None
+        
+        normal = normal / normal_length
+        normal = normal.tolist()
+        normal = [round(x, mantissa) for x in normal]
+        return_normal = []
+        outputType = list(outputType.lower())
+        for axis in outputType:
+            if axis == "x":
+                return_normal.append(normal[0])
+            elif axis == "y":
+                return_normal.append(normal[1])
+            elif axis == "z":
+                return_normal.append(normal[2])
+        return return_normal
     
     @staticmethod
     def NormalEdge(face, length: float = 1.0, tolerance: float = 0.0001, silent: bool = False):
@@ -1744,43 +1774,10 @@ class Face():
             return None
         iv = Face.InternalVertex(face)
         u, v = Face.VertexParameters(face, iv)
-        vec = Face.NormalAtParameters(face, u=u, v=v)
+        vec = Face.Normal(face)
         ev = Topology.TranslateByDirectionDistance(iv, vec, length)
         return Edge.ByVertices([iv, ev], tolerance=tolerance, silent=silent)
 
-    @staticmethod
-    def NormalEdgeAtParameters(face, u: float = 0.5, v: float = 0.5, length: float = 1.0, tolerance: float = 0.0001):
-        """
-        Returns the normal vector to the input face as an edge with the desired input length. A normal vector of a face is a vector perpendicular to it.
-
-        Parameters
-        ----------
-        face : topologic_core.Face
-            The input face.
-        u : float , optional
-            The *u* parameter at which to compute the normal to the input face. The default is 0.5.
-        v : float , optional
-            The *v* parameter at which to compute the normal to the input face. The default is 0.5.
-        length : float , optional
-            The desired length of the normal edge. The default is 1.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
-        
-        Returns
-        -------
-        topologic_core.Edge
-            The created normal edge to the input face. This is computed at the approximate center of the face.
-
-        """
-        from topologicpy.Edge import Edge
-        from topologicpy.Topology import Topology
-        if not Topology.IsInstance(face, "Face"):
-            return None
-        sv = Face.VertexByParameters(face=face, u=u, v=v)
-        vec = Face.NormalAtParameters(face, u=u, v=v)
-        ev = Topology.TranslateByDirectionDistance(sv, vec, length)
-        return Edge.ByVertices([sv, ev], tolerance=tolerance, silent=True)
-
     @staticmethod
     def PlaneEquation(face, mantissa: int = 6) -> dict:
         """

topologicpy/Graph.py

@@ -269,6 +269,88 @@ class _DrawTree(object):
         return self.__str__()
 
 class Graph:
+    def AdjacencyDictionary(graph, vertexLabelKey: str = "label", edgeKey: str = "Length", reverse: bool = False, mantissa: int = 6):
+        """
+        Returns the adjacency dictionary of the input Graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertexLabelKey : str , optional
+            The returned vertices are labelled according to the dictionary values stored under this key.
+            If the vertexLabelKey does not exist, it will be created and the vertices are labelled numerically and stored in the vertex dictionary under this key. The default is "label".
+        edgeWeightKey : str , optional
+            If set, the edges' dictionaries will be searched for this key to set their weight. If the key is set to "length" (case insensitive), the length of the edge will be used as its weight. If set to None, a weight of 1 will be used. The default is "Length".
+        reverse : bool , optional
+                If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. The default is False.
+        mantissa : int , optional
+                The desired length of the mantissa. The default is 6.
+
+        Returns
+        -------
+        dict
+            The adjacency dictionary.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+
+        if not Topology.IsInstance(graph, "Graph"):
+            print("Graph.AdjacencyDictionary - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if not isinstance(vertexLabelKey, str):
+            print("Graph.AdjacencyDictionary - Error: The input vertexLabelKey is not a valid string. Returning None.")
+            return None
+        vertices = Graph.Vertices(graph)
+        labels = []
+        n = max(len(str(len(vertices))), 3)
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            value = Dictionary.ValueAtKey(d, vertexLabelKey)
+            if value == None:
+                value = str(i).zfill(n)
+            if d == None:
+                d = Dictionary.ByKeyValue(vertexLabelKey, value)
+            else:
+                d = Dictionary.SetValueAtKey(d, vertexLabelKey, value)
+            v = Topology.SetDictionary(v, d)
+            labels.append(value)
+        vertices = Helper.Sort(vertices, labels)
+        labels.sort()
+        if reverse == True:
+            vertices.reverse()
+            labels.reverse()
+        order = len(vertices)
+        adjDict = {}
+        for i in range(order):
+            v = Graph.NearestVertex(graph, vertices[i])
+            vertex_label = labels[i]
+            adjVertices = Graph.AdjacentVertices(graph, v)
+            temp_list = []
+            for adjVertex in adjVertices:
+                if edgeKey == None:
+                    weight = 1
+                elif "length" in edgeKey.lower():
+                    edge = Graph.Edge(graph, v, adjVertex)
+                    weight = Edge.Length(edge, mantissa=mantissa)
+                else:
+                    edge = Graph.Edge(graph, v, adjVertex)
+                    weight = Dictionary.ValueAtKey(Topology.Dictionary(edge), edgeKey)
+                    if weight == None:
+                        weight = Edge.Length(edge, mantissa=mantissa)
+                    else:
+                        weight = round(weight, mantissa)
+                adjIndex = Vertex.Index(adjVertex, vertices)
+                adjLabel = labels[adjIndex]
+                if not adjIndex == None:
+                    temp_list.append((adjLabel, weight))
+            temp_list.sort()
+            adjDict[vertex_label] = temp_list
+        return adjDict
+    
     @staticmethod
     def AdjacencyMatrix(graph, vertexKey=None, reverse=False, edgeKeyFwd=None, edgeKeyBwd=None, bidirKey=None, bidirectional=True, useEdgeIndex=False, useEdgeLength=False, tolerance=0.0001):
         """

topologicpy/Topology.py

@@ -3236,7 +3236,7 @@ class Topology():
         _ = topology.Faces(None, faces)
         normals = []
         for aFace in faces:
-            normals.append(Face.NormalAtParameters(aFace, 0.5, 0.5, "XYZ", 3))
+            normals.append(Face.Normal(aFace, outputType="XYZ", mantissa=3))
         # build a matrix of similarity
         mat = buildSimilarityMatrix(normals, angTolerance)
         categories = categorizeIntoClusters(mat)
@@ -4799,17 +4799,6 @@ class Topology():
                 _ = topology.CellComplexes(None, topologies)
             return topologies
 
-        def triangulateFace(face):
-            faceTriangles = []
-            for i in range(0, 5, 1):
-                try:
-                    _ = topologic.FaceUtility.Triangulate(face, float(i)*0.1, faceTriangles)
-                    return faceTriangles
-                except:
-                    continue
-            faceTriangles.append(face)
-            return faceTriangles
-
         vertices = []
         edges = []
         faces = []
@@ -4858,14 +4847,10 @@ class Topology():
             ib = []
             _ = aFace.InternalBoundaries(ib)
             if(len(ib) > 0):
-                triFaces = triangulateFace(aFace)
+                triFaces = Face.Triangulate(aFace)
                 for aTriFace in triFaces:
-                    wire = aTriFace.ExternalBoundary()
+                    wire = Face.ExternalBoundary(aTriFace)
                     faceVertices = getSubTopologies(wire, topologic.Vertex)
-                    temp_face = Face.ByWire(wire)
-                    temp_dir = Face.Normal(temp_face)
-                    if Vector.IsAntiParallel(f_dir, temp_dir):
-                        faceVertices.reverse()
                     f = []
                     for aVertex in faceVertices:
                         try:
@@ -4876,13 +4861,8 @@ class Topology():
                         f.append(fVertexIndex)
                     faces.append(f)
             else:
-                wire =  aFace.ExternalBoundary()
-                #wire = topologic.WireUtility.RemoveCollinearEdges(wire, 0.1) #This is an angle Tolerance
+                wire =  Face.ExternalBoundary(aFace)
                 faceVertices = getSubTopologies(wire, topologic.Vertex)
-                temp_face = Face.ByWire(wire)
-                temp_dir = Face.Normal(temp_face)
-                if Vector.IsAntiParallel(f_dir, temp_dir):
-                    faceVertices.reverse()
                 f = []
                 for aVertex in faceVertices:
                     try:

topologicpy/Wire.py

@@ -1953,6 +1953,101 @@ class Wire(Topology):
         return_wire = Topology.Unflatten(flat_wire, origin=Vertex.Origin(), direction=normal)
         return return_wire
     
+    @staticmethod
+    def Normal(wire, outputType="xyz", mantissa=6):
+        """
+        Returns the normal vector to the input wire. A normal vector of a wire is a vector perpendicular to it.
+
+        Parameters
+        ----------
+        wire : topologic_core.Wire
+            The input wire.
+        outputType : string , optional
+            The string defining the desired output. This can be any subset or permutation of "xyz". It is case insensitive. The default is "xyz".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+
+        Returns
+        -------
+        list
+            The normal vector to the input face.
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Vertex import Vertex
+        import os
+        import warnings
+        try:
+            import numpy as np
+        except:
+            print("Wire.Normal - Warning: Installing required numpy library.")
+            try:
+                os.system("pip install numpy")
+            except:
+                os.system("pip install numpy --user")
+            try:
+                import numpy as np
+                print("Wire.Normal - Warning: numpy library installed correctly.")
+            except:
+                warnings.warn("Wire.Normal - Error: Could not import numpy. Please try to install numpy manually. Returning None.")
+                return None
+
+        if not Topology.IsInstance(wire, "Wire"):
+            print("Wire.Normal - Error: The input wire parameter is not a valid wire. Returning None.")
+            return None
+        
+        vertices = Topology.Vertices(wire)
+        vertices = [Vertex.Coordinates(v, mantissa=mantissa) for v in vertices]
+        
+        if len(vertices) < 3:
+            print("Wire.Normal - Error: At least three vertices are required to define a plane. Returning None.")
+            return None
+        
+        # Convert vertices to numpy array for easier manipulation
+        vertices = np.array(vertices)
+        
+        # Try to find two non-collinear edge vectors
+        vec1 = None
+        vec2 = None
+        for i in range(1, len(vertices)):
+            for j in range(i + 1, len(vertices)):
+                temp_vec1 = vertices[i] - vertices[0]
+                temp_vec2 = vertices[j] - vertices[0]
+                cross_product = np.cross(temp_vec1, temp_vec2)
+                if np.linalg.norm(cross_product) > 1e-6:  # Check if the cross product is not near zero
+                    vec1 = temp_vec1
+                    vec2 = temp_vec2
+                    break
+            if vec1 is not None and vec2 is not None:
+                break
+        
+        if vec1 is None or vec2 is None:
+            print("Wire.Normal - Error: The given vertices do not form a valid plane (all vertices might be collinear). Returning None.")
+            return None
+        
+        # Calculate the cross product of the two edge vectors
+        normal = np.cross(vec1, vec2)
+
+        # Normalize the normal vector
+        normal_length = np.linalg.norm(normal)
+        if normal_length == 0:
+            print("Wire.Normal - Error: The given vertices do not form a valid plane (cross product resulted in a zero vector). Returning None.")
+            return None
+        
+        normal = normal / normal_length
+        normal = normal.tolist()
+        normal = [round(x, mantissa) for x in normal]
+        return_normal = []
+        outputType = list(outputType.lower())
+        for axis in outputType:
+            if axis == "x":
+                return_normal.append(normal[0])
+            elif axis == "y":
+                return_normal.append(normal[1])
+            elif axis == "z":
+                return_normal.append(normal[2])
+        return return_normal
+    
     @staticmethod
     def OrientEdges(wire, vertexA, tolerance=0.0001):
         """
@@ -2106,7 +2201,7 @@ class Wire(Topology):
         if not Topology.IsInstance(face, "Face"):
             return None
         if not direction:
-            direction = -1*Face.NormalAtParameters(face, 0.5, 0.5, "XYZ", mantissa)
+            direction = -1*Face.Normal(face, outputType="xyz", mantissa=mantissa)
         large_face = Topology.Scale(face, face.CenterOfMass(), 500, 500, 500)
         edges = []
         _ = wire.Edges(None, edges)

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.17'
+__version__ = '0.7.18'

{topologicpy-0.7.17.dist-info → topologicpy-0.7.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.17
+Version: 0.7.18
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: MIT License
@@ -108,6 +108,42 @@ topologicpy depends on the following python libraries which will be installed au
 ## API Documentation
 API documentation can be found at [https://topologicpy.readthedocs.io](https://topologicpy.readthedocs.io)
 
+## How to cite topologicpy
+If you wish to cite the actual software, you can use:
+
+**Jabi, W. (2024). topologicpy. pypi.org. http://doi.org/10.5281/zenodo.11555172**
+
+To cite one of the main papers that defines topologicpy, you can use:
+
+**Jabi, W., & Chatzivasileiadi, A. (2021). Topologic: Exploring Spatial Reasoning Through Geometry, Topology, and Semantics. In S. Eloy, D. Leite Viana, F. Morais, & J. Vieira Vaz (Eds.), Formal Methods in Architecture (pp. 277–285). Springer International Publishing. https://doi.org/10.1007/978-3-030-57509-0_25**
+
+Or you can import the following .bib formatted references into your favourite reference manager
+```
+@misc{Jabi2024,
+   author = {Wassim Jabi},
+   doi = {https://doi.org/10.5281/zenodo.11555173},
+   title = {topologicpy},
+   url = {http://pypi.org/projects/topologicpy},
+   year = {2024},
+}
+```
+```
+  @inbook{Jabi2021,
+   abstract = {Topologic is a software modelling library that supports a comprehensive conceptual framework for the hierarchical spatial representation of buildings based on the data structures and concepts of non-manifold topology (NMT). Topologic supports conceptual design and spatial reasoning through the integration of geometry, topology, and semantics. This enables architects and designers to reflect on their design decisions before the complexities of building information modelling (BIM) set in. We summarize below related work on NMT starting in the late 1980s, describe Topologic’s software architecture, methods, and classes, and discuss how Topologic’s features support conceptual design and spatial reasoning. We also report on a software usability workshop that was conducted to validate a software evaluation methodology and reports on the collected qualitative data. A reflection on Topologic’s features and software architecture illustrates how it enables a fundamental shift from pursuing fidelity of design form to pursuing fidelity of design intent.},
+   author = {Wassim Jabi and Aikaterini Chatzivasileiadi},
+   city = {Cham},
+   doi = {10.1007/978-3-030-57509-0_25},
+   editor = {Sara Eloy and David Leite Viana and Franklim Morais and Jorge Vieira Vaz},
+   isbn = {978-3-030-57509-0},
+   journal = {Formal Methods in Architecture},
+   pages = {277-285},
+   publisher = {Springer International Publishing},
+   title = {Topologic: Exploring Spatial Reasoning Through Geometry, Topology, and Semantics},
+   url = {https://link.springer.com/10.1007/978-3-030-57509-0_25},
+   year = {2021},
+}
+```
+
 topologicpy: © 2024 Wassim Jabi
 
 Topologic: © 2024 Cardiff University and UCL

{topologicpy-0.7.17.dist-info → topologicpy-0.7.18.dist-info}/RECORD

@@ -1,6 +1,6 @@
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
-topologicpy/Cell.py,sha256=JYP0Qv61Sxgni5nCTd7Hx9pjoUE4F4lje0iMUgDxDO4,99704
-topologicpy/CellComplex.py,sha256=ZxTfpV0Worgnwj4tz-qk2a6OmAtctG_8CnHKnwoVzJU,47452
+topologicpy/Cell.py,sha256=FNmDHdNkJYaM982MLktfSipqFnfJBQmdxKp3kmuBKjA,99861
+topologicpy/CellComplex.py,sha256=Fd70Dj7E4LqV5O-7kcCCYnrFEyqheZvxc0YWktm0EL8,47440
 topologicpy/Cluster.py,sha256=HvomWm_V4bx76YMxqOEhAUrsvcU6z5e_zry6WxMuV2M,54819
 topologicpy/Color.py,sha256=UlmRcCSOhqcM_OyMWz4t3Kr75KcgXDhz3uctAJ2n7Ic,18031
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
@@ -8,8 +8,8 @@ topologicpy/DGL.py,sha256=5jNn1L8F8REx1-oAh9sr_cfil0R5kUuueCNDKwNU_GM,138991
 topologicpy/Dictionary.py,sha256=pMbfE2RYGCNpVr2x58qiHRc-aBWnp1jLlyzwS9nz6-w,25891
 topologicpy/Edge.py,sha256=f7LjP662_yoqopAXBh1Gqv8DvdzvfM_heJTP2XnFskY,58447
 topologicpy/EnergyModel.py,sha256=ni0H1JgvLl1-q90yK9Sm1qj5P1fTuidlimEIcwuj6qE,53287
-topologicpy/Face.py,sha256=3sMhe86QCo8qLSLlw2CdWkwzVuMNegmnAhUSe__h0iQ,108351
-topologicpy/Graph.py,sha256=90D_G90RBkJ1ZDCLFR2XG2juwnWKfADd0YPIFqIjsck,387669
+topologicpy/Face.py,sha256=1J1dnS3tNnaoFQyWdWjn9YnHldyiN-J67IjytIT0-R4,108142
+topologicpy/Graph.py,sha256=JM4N6EShvDspFcE9_E027HKAkHhZ5e5UD4I9LxlRfmA,391560
 topologicpy/Grid.py,sha256=Cpzs9l5-SptMQbUR8AvbbIOHrGMGlK0Qx8FWmQBgvX0,18497
 topologicpy/Helper.py,sha256=07V9IFu5ilMpvAdZVhIbdBOjBJSRTtJ0BfR1IoRaRXU,17743
 topologicpy/Honeybee.py,sha256=dlr5OEH93q51ZmEgvi8PXGfCHBDAjIZ1cm38Rft1Bz4,20235
@@ -20,14 +20,14 @@ topologicpy/Polyskel.py,sha256=pNawz5lnvy4oTzCL91fGY2PblW2hmcYBdT5268m2RZs,19743
 topologicpy/Shell.py,sha256=fdMhCKH5Oq2id16XjTWRe8-06jZ8z8LnrVqMR-33F3s,79144
 topologicpy/Speckle.py,sha256=rUS6PCaxIjEF5_fUruxvMH47FMKg-ohcoU0qAUb-yNM,14267
 topologicpy/Sun.py,sha256=mN3RzlslcZT3APUtwmWIXVbPkJ6OcKTaTf6338gbMJE,37152
-topologicpy/Topology.py,sha256=O79RJPcMV0-id-1CSRtBdrJHWHLLWdNIAPdfGbPn_qI,339720
+topologicpy/Topology.py,sha256=Y0McJCx_eH6y92bMbRfG82Foe0A9K7j3Fp8w-dD9h4k,338825
 topologicpy/Vector.py,sha256=G4mIIcE5Y-EHfiNV_rxiOz8pJeV3NMEwLu5EOgM0gKA,32653
 topologicpy/Vertex.py,sha256=bD3JnNhizbp6HFhHRve2LK_y5w27jytCbsagOLxKjZQ,71198
-topologicpy/Wire.py,sha256=L9RsS6kmmmF5n7QNNNebQRR6Rg2bFdUaF2RZjyGdRuY,139799
+topologicpy/Wire.py,sha256=OtqCUmZeqeNF3baBLmUjB8yBZ3gmzzpSPcD-zzKzz4k,143577
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=wcUsHaWS0KncOllDb6GdknQP3quV24cgTSGaGPX-yX0,23
-topologicpy-0.7.17.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.17.dist-info/METADATA,sha256=UP-ISL841EAJkgEPB48Zz9SV52tRttTKCt0DyuIh9xI,8410
-topologicpy-0.7.17.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-topologicpy-0.7.17.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.17.dist-info/RECORD,,
+topologicpy/version.py,sha256=JKTQ-L90z9YkGvUYq8IRiy8FeivJmY_tDcKgSZ-ssw4,23
+topologicpy-0.7.18.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
+topologicpy-0.7.18.dist-info/METADATA,sha256=NiOC_LjQzxSER_rnY5Kz05fNWAbiEOuGxcoFAh2-_VA,10916
+topologicpy-0.7.18.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+topologicpy-0.7.18.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.18.dist-info/RECORD,,