topologicpy 0.7.82__py3-none-any.whl → 0.7.84__py3-none-any.whl

topologicpy/Cell.py

@@ -1967,9 +1967,13 @@ class Cell():
         """
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
-
+        import inspect
+        
         if not Topology.IsInstance(cell, "Cell"):
             print("Cell.RemoveCollinearEdges - Error: The input cell parameter is not a valid cell. Returning None.")
+            curframe = inspect.currentframe()
+            calframe = inspect.getouterframes(curframe, 2)
+            print('caller name:', calframe[1][3])
             return None
         faces = Cell.Faces(cell)
         clean_faces = []

topologicpy/CellComplex.py

@@ -972,9 +972,14 @@ class CellComplex():
         """
         from topologicpy.Cell import Cell
         from topologicpy.Topology import Topology
-
+        import inspect
+        
         if not Topology.IsInstance(cellComplex, "CellComplex"):
             print("CellComplex.RemoveCollinearEdges - Error: The input cellComplex parameter is not a valid cellComplex. Returning None.")
+            print("CellComplex.RemoveCollinearEdges - Inspection:")
+            curframe = inspect.currentframe()
+            calframe = inspect.getouterframes(curframe, 2)
+            print('caller name:', calframe[1][3])
             return None
         cells = CellComplex.Cells(cellComplex)
         clean_cells = []

topologicpy/Edge.py

@@ -1477,7 +1477,7 @@ class Edge():
         svb = Edge.StartVertex(edgeB)
         evb = Edge.EndVertex(edgeB)
         intVertex = None
-        if Edge.IsCollinear(edgeA, edgeB):
+        if Edge.IsCollinear(edgeA, edgeB, tolerance=tolerance):
             if Vertex.IsInternal(svb, edgeA):
                 intVertex = svb
             elif Vertex.IsInternal(evb, edgeA):

topologicpy/Face.py

@@ -594,6 +594,7 @@ class Face():
         # Try the simple method first
         face = None
         ext_boundary = Wire.RemoveCollinearEdges(Shell.ExternalBoundary(shell))
+        #ext_boundary = Shell.ExternalBoundary(shell)
         if Topology.IsInstance(ext_boundary, "Wire"):
             face = Face.ByWire(ext_boundary, silent=silent)
         elif Topology.IsInstance(ext_boundary, "Cluster"):
@@ -652,8 +653,11 @@ class Face():
             for int_boundary in int_boundaries:
                 temp_wires = Topology.Wires(int_boundary)
                 int_wires.append(Topology.RemoveCollinearEdges(temp_wires[0], angTolerance))
+                #int_wires.append(temp_wires[0])
+
             temp_wires = Topology.Wires(ext_boundary)
             ext_wire = Topology.RemoveCollinearEdges(temp_wires[0], angTolerance)
+            #ext_wire = temp_wires[0]
             face = Face.ByWires(ext_wire, int_wires)
             face = Topology.Unflatten(face, origin=origin, direction=normal)
             return face
@@ -1623,10 +1627,10 @@ class Face():
                 return None
 
         if not Topology.IsInstance(faceA, "Face"):
-            print("Face.IsInside - Error: The input faceA parameter is not a valid topologic face. Returning None.")
+            print("Face.IsCoplanar - Error: The input faceA parameter is not a valid topologic face. Returning None.")
             return None
         if not Topology.IsInstance(faceB, "Face"):
-            print("Face.IsInside - Error: The input faceB parameter is not a valid topologic face. Returning None.")
+            print("Face.IsCoplanar - Error: The input faceB parameter is not a valid topologic face. Returning None.")
             return None
 
         def normalize_plane_coefficients(plane):
@@ -1649,7 +1653,7 @@ class Face():
         return are_planes_coplanar(plane_a, plane_b, tolerance=tolerance)
 
     @staticmethod
-    def Isovist(face, vertex, obstacles: list = [], direction: list = [0,1,0], fov: float = 360, transferDictionaries: bool = False, metrics: bool = False, mantissa: int = 6, tolerance: float = 0.0001):
+    def Isovist(face, vertex, obstacles: list = [], direction: list = [0,1,0], fov: float = 360, transferDictionaries: bool = False, metrics: bool = False, triangles: bool = False, mantissa: int = 6, tolerance: float = 0.0001):
         """
         Returns the face representing the isovist projection from the input viewpoint.
         This method assumes all input is in 2D. Z coordinates are ignored.
@@ -1682,7 +1686,11 @@ class Face():
             - perimeter : float , the perimeter length of the isovist
             - compactness : float , how closely the shape of the isovist approximates a circle (the most compact geometric shape).
             - d_max : float, Maximum Visibility Distance. the length of the longest straight line that can be seen from the viewpoint.
+            - d_min : float, Minimum Visibility Distance. the length of the shortest straight line that can be seen from the viewpoint.
+            - d_avg : float, Average Visibility Distance. the length of the average straight line that can be seen from the viewpoint.
             - v_max : list, Furthest Point measures the x , y , z coordinates of the furthest visible point from the viewpoint.
+            - v_min : list, Closest Point measures the x , y , z coordinates of the closest visible point from the viewpoint.
+            - centroid: list, Centroid measures the x, y, z coordinates of the centroid of the isovist face.
             - v_d :  list, Visibility Distribution quantifies the angular distribution (in degrees) of visible points across the isovist.
                     This metric can tell you whether the visibility from a point is more spread out or concentrated in a certain direction. A uniform visibility distribution indicates a more balanced visual field, while a skewed distribution suggests that the observer's line of sight is constrained in certain directions.
             - v_density : float, Viewpoint Density which refers to the number of visible points per unit area within the isovist.
@@ -1690,6 +1698,8 @@ class Face():
             - d_f : float, Fractal Dimension measures the complexity of the isovist's boundary.
             - e_c : float , Edge Complexity measures how complex the edges of the isovist boundary are.
             - theta : float, Mean Visual Field Angle measures the average angular extent of the visible area from the observation point.
+        triangles : bool , optional
+            If set to True, the subtended triangles of the isovist are created and stored as contents of the returned isovist face. The default is False.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional:
@@ -1855,6 +1865,42 @@ class Face():
         else:
             obstacles = []
         
+        def closest_distance_vertex(vertex, edge, mantissa):
+            point = Vertex.Coordinates(vertex, mantissa=mantissa)
+            line_start = Vertex.Coordinates(Edge.StartVertex(edge), mantissa=mantissa)
+            line_end = Vertex.Coordinates(Edge.EndVertex(edge), mantissa=mantissa)
+
+            # Convert input points to NumPy arrays for vector operations
+            point = np.array(point)
+            line_start = np.array(line_start)
+            line_end = np.array(line_end)
+            
+            # Calculate the direction vector of the edge
+            line_direction = line_end - line_start
+            
+            # Vector from the edge's starting point to the point
+            point_to_start = point - line_start
+            
+            # Calculate the parameter 't' where the projection of the point onto the edge occurs
+            if np.dot(line_direction, line_direction) == 0:
+                t = 0
+            else:
+                t = np.dot(point_to_start, line_direction) / np.dot(line_direction, line_direction)
+            
+            # Check if 't' is outside the range [0, 1], and if so, calculate distance to closest endpoint
+            if t < 0:
+                t = 0
+            elif t > 1:
+                t = 1
+            
+            # Calculate the closest point on the edge to the given point
+            closest_point = line_start + t * line_direction
+            
+            # Calculate the distance between the closest point and the given point
+            distance = np.linalg.norm(point - closest_point)
+            
+            return float(distance), Vertex.ByCoordinates(list(closest_point))
+        
         origin = Topology.Centroid(face)
         normal = Face.Normal(face)
         flat_face = Topology.Flatten(face, origin=origin, direction=normal)
@@ -1879,6 +1925,10 @@ class Face():
         for obs in flat_obstacles:
             flat_face = Topology.Difference(flat_face, Face.ByWire(obs))
         
+        # Check that the viewpoint is inside the face
+        if not Vertex.IsInternal(flat_vertex, flat_face):
+            print("Face.Isovist - Error: The viewpoint is not inside the face. Returning None.")
+            return None
         targets = Topology.Vertices(flat_face)
         distances = []
         for target in targets:
@@ -1958,6 +2008,8 @@ class Face():
             return_face = Topology.Unflatten(simpler_face, origin=origin, direction=normal)
         return_face = Topology.Unflatten(return_face, origin=origin, direction=normal)
         if metrics == True:
+            vertices = Topology.Vertices(return_face)
+            edges = Topology.Edges(return_face)
             # 1 Viewpoint
             viewpoint = Vertex.Coordinates(vertex, mantissa=mantissa)
             # 2 Direction
@@ -1971,30 +2023,59 @@ class Face():
             # 6 Compactness
             compactness = round(Face.Compactness(return_face), mantissa)
             # 7 Maximum Distance (d_max)
-            vertices = Topology.Vertices(return_face)
-            furthest_vertex = vertices[0]
+            # 8 Minimum Distance (d_min)
+            # 9 Average Distance (d_avg)
+            # 10 Furthest Visible Vertex (v_max)
+            # 11 Closest Visible Vertex (v_min)
             d_max = round(Vertex.Distance(vertex, vertices[0]), mantissa)
-            # 8 Furthest Visible Vertex
+            d_min = round(Vertex.Distance(vertex, vertices[0]), mantissa)
+            furthest_vertex = vertices[0]
+            closest_vertex = vertices[0]
             coords = []
+            distances = []
             for v in vertices:
                 coords.append(Vertex.Coordinates(v, mantissa=mantissa))
                 dis = Vertex.Distance(vertex, v, mantissa=mantissa)
+                distances.append(dis)
                 if dis > d_max:
                     d_max  = dis
                     furthest_vertex = v
+            distances = []
+            edges = Topology.Edges(Cluster.ByTopologies([face]+obstacles))
+            for edge in edges:
+                dis, c_v = closest_distance_vertex(vertex, edge, mantissa=mantissa)
+                if dis < d_min and Vertex.IsPeripheral(c_v, return_face):
+                    d_min = dis
+                    closest_vertex = c_v
+            
+            # 12 Average Visible Distance
+            if len(distances) > 0:
+                d_avg = sum(distances)/float(len(distances))
+            else:
+                d_avg = 0
+            
+            # 10 Furthest Visible Vertex (v_max)
             v_max = Vertex.Coordinates(furthest_vertex, mantissa=mantissa)
-            # 9 Visibility Distribution (v_d)
+            # 11 Closest Visible Vertex (v_min)
+            v_min = Vertex.Coordinates(closest_vertex, mantissa=mantissa)
+            # 12 Centroid of Isovist (centroid)
+            centroid = Vertex.Coordinates(Topology.Centroid(return_face), mantissa=mantissa)
+
+            # 13 Visibility Distribution (v_d)
             v_d = visibility_distribution(viewpoint, coords)
             v_d = [round(x) for x in v_d]
-            # 10 Viewpoint density
-            v_density = round(float(len(vertices)) / abs(Face.Area(return_face)), mantissa)
-            # 11 Isovist Symmetry
+            # 14 Viewpoint density
+            if abs(Face.Area(return_face)) > 0:
+                v_density = round(float(len(vertices)) / abs(Face.Area(return_face)), mantissa)
+            else:
+                v_density = 0
+            # 15 Isovist Symmetry
             symmetry = round(isovist_symmetry(viewpoint, coords), mantissa)
-            # 12 Fractal Dimension
+            # 16 Fractal Dimension
             d_f = round(fractal_dimension(coords), mantissa)
-            # 13 Edge Complexity
+            # 17 Edge Complexity
             e_c = round(edge_complexity(coords), mantissa)
-            # 14 Mean Visual Field Angle
+            # 18 Mean Visual Field Angle
             theta = round(mean_visual_field_angle(viewpoint, coords), mantissa)
             keys = ["viewpoint",
                     "direction",
@@ -2003,7 +2084,11 @@ class Face():
                     "perimeter",
                     "compactness",
                     "d_max",
+                    "d_min",
+                    "d_avg",
                     "v_max",
+                    "v_min",
+                    "centroid",
                     "v_d",
                     "v_density",
                     "symmetry",
@@ -2011,21 +2096,47 @@ class Face():
                     "e_c",
                     "theta"]
             values = [viewpoint,
-                        direction,
-                        fov,
-                        area,
-                        perimeter,
-                        compactness,
-                        d_max,
-                        v_max,
-                        v_d,
-                        v_density,
-                        symmetry,
-                        d_f,
-                        e_c,
-                        theta]
+                      direction,
+                      fov,
+                      area,
+                      perimeter,
+                      compactness,
+                      d_max,
+                      d_min,
+                      d_avg,
+                      v_max,
+                      v_min,
+                      centroid,
+                      v_d,
+                      v_density,
+                      symmetry,
+                      d_f,
+                      e_c,
+                      theta]
             d = Dictionary.ByKeysValues(keys, values)
             return_face = Topology.SetDictionary(return_face, d)
+        if triangles:
+            triangle_list = []
+            edges = Topology.Edges(return_face)
+            for edge in edges:
+                d = Topology.Dictionary(edge)
+                if Vertex.Distance(Edge.StartVertex(edge), v) > 0.0001:
+                    e1 = Edge.ByVertices(Edge.StartVertex(edge), v)
+                    if Vertex.Distance(Edge.EndVertex(edge), v) > 0.0001:
+                        e2 = Edge.ByVertices(Edge.EndVertex(edge), v)
+                        triangle = Topology.SelfMerge(Cluster.ByTopologies(edge, e1, e2))
+                        if Topology.IsInstance(triangle, "wire"):
+                            if Wire.IsClosed(triangle):
+                                triangle = Face.ByWire(triangle, silent=True)
+                                if Topology.IsInstance(triangle, "face"):
+                                    if transferDictionaries == True:
+                                        triangle = Topology.SetDictionary(triangle, d)
+                                        tri_edges = Topology.Edges(triangle)
+                                        for tri_edge in tri_edges:
+                                            tri_edge = Topology.SetDictionary(tri_edge, d)
+                                    triangle_list.append(triangle)
+            if len(triangle_list) > 0:
+                return_face = Topology.AddContent(return_face, triangle_list)
         return return_face
 
     @staticmethod
@@ -2466,9 +2577,13 @@ class Face():
         """
         from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
-
+        import inspect
+        
         if not Topology.IsInstance(face, "Face"):
             print("Face.RemoveCollinearEdges - Error: The input face parameter is not a valid face. Returning None.")
+            curframe = inspect.currentframe()
+            calframe = inspect.getouterframes(curframe, 2)
+            print('caller name:', calframe[1][3])
             return None
         eb = Wire.RemoveCollinearEdges(Face.Wire(face), angTolerance=angTolerance, tolerance=tolerance)
         ib = [Wire.RemoveCollinearEdges(w, angTolerance=angTolerance, tolerance=tolerance) for w in Face.InternalBoundaries(face)]

topologicpy/Shell.py

@@ -1456,9 +1456,13 @@ class Shell():
         """
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
-
+        import inspect
+        
         if not Topology.IsInstance(shell, "Shell"):
             print("Shell.RemoveCollinearEdges - Error: The input shell parameter is not a valid shell. Returning None.")
+            curframe = inspect.currentframe()
+            calframe = inspect.getouterframes(curframe, 2)
+            print('caller name:', calframe[1][3])
             return None
         faces = Shell.Faces(shell)
         clean_faces = []

topologicpy/Topology.py

@@ -4184,7 +4184,6 @@ class Topology():
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Helper import Helper
         import inspect
-        print("input topologies:", topologies)
 
         topologies_list = []
         if Topology.IsInstance(topologies, "Topology"):
@@ -6749,8 +6748,13 @@ class Topology():
         from topologicpy.Cell import Cell
         from topologicpy.CellComplex import CellComplex
         from topologicpy.Cluster import Cluster
-        
+        import inspect
         if not Topology.IsInstance(topology, "Topology"):
+            if not silent:
+                print("Topology.RemoveCollinearEdges - Error: The input topology parameter is not a valid topology. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         return_topology = topology
         if Topology.IsInstance(topology, "Vertex") or Topology.IsInstance(topology, "Edge"): #Vertex or Edge or Cluster, return the original topology
@@ -6776,7 +6780,7 @@ class Topology():
             topologies += Cluster.FreeEdges(topology)
             faces = Topology.Faces(topology)
             for face in faces:
-                topologies.append(Face.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance))
+                topologies.append(Face.RemoveCollinearEdges(face, angTolerance=angTolerance, tolerance=tolerance))
             return_topology = Topology.SelfMerge(Cluster.ByTopologies(topologies), tolerance=tolerance)
         return return_topology
 
@@ -9045,7 +9049,7 @@ class Topology():
         r_shells = Topology.Shells(return_topology)
         r_cells = Topology.Cells(return_topology)
         r_cellComplexes = Topology.CellComplexes(return_topology)
-        
+
         for i, t in enumerate(r_vertices):
             t = Topology.SetDictionary(t, Topology.Dictionary(vertices[i]), silent=True)
         for i, t in enumerate(r_edges):

topologicpy/Vertex.py

@@ -1110,13 +1110,18 @@ class Vertex():
         import inspect
 
         if not Topology.IsInstance(vertex, "Vertex"):
-            print("Called from:", inspect.stack()[1][3])
             if not silent:
                 print("Vertex.IsInternal - Error: The input vertex parameter is not a valid vertex. Returning None.", vertex, topology)
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         if not Topology.IsInstance(topology, "Topology"):
             if not silent:
                 print("Vertex.IsInternal - Error: The input topology parameter is not a valid topology. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
 
         if Topology.IsInstance(topology, "Vertex"):
@@ -1178,7 +1183,6 @@ class Vertex():
             return False
         return False
     
-    
     @staticmethod
     def IsPeripheral(vertex, topology, tolerance: float = 0.0001, silent: bool = False) -> bool:
         """

topologicpy/Wire.py

@@ -2966,12 +2966,107 @@ class Wire():
         if direction != [0, 0, 1]:
             baseWire = Topology.Orient(baseWire, origin=origin, dirA=[0, 0, 1], dirB=direction)
         return baseWire
-    
+
+
     @staticmethod
     def RemoveCollinearEdges(wire, angTolerance: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
         Removes any collinear edges in the input wire.
 
+        Parameters
+        ----------
+        wire : topologic_core.Wire
+            The input wire.
+        angTolerance : float, optional
+            The desired angular tolerance. The default is 0.1.
+        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
+        -------
+        topologic_core.Wire
+            The wire without collinear edges, or the original wire if no modifications were necessary.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+
+        def cleanup(wire):
+            """Fuses vertices and removes edges below the tolerance distance."""
+            vertices = Vertex.Fuse(Topology.Vertices(wire), tolerance=tolerance)
+            edges = Topology.Edges(wire)
+            new_edges = []
+
+            for edge in edges:
+                sv = vertices[Vertex.Index(Edge.StartVertex(edge), vertices, tolerance=tolerance)]
+                ev = vertices[Vertex.Index(Edge.EndVertex(edge), vertices, tolerance=tolerance)]
+                if Vertex.Distance(sv, ev) > tolerance:
+                    new_edges.append(Edge.ByVertices([sv, ev]))
+
+            return Topology.SelfMerge(Cluster.ByTopologies(new_edges, silent=silent), tolerance=tolerance) if new_edges else wire
+
+        def remove_collinear_vertices(wire):
+            """Removes collinear vertices from a wire."""
+            if not Topology.IsInstance(wire, "Wire"):
+                return wire
+
+            vertices = Topology.Vertices(wire)
+            filtered_vertices = []
+
+            for i, vertex in enumerate(vertices):
+                edges = Topology.SuperTopologies(topology=vertex, hostTopology=wire, topologyType="edge")
+
+                if len(edges) != 2:
+                    filtered_vertices.append(vertex)
+                elif not Edge.IsCollinear(edges[0], edges[1], tolerance=tolerance):
+                    filtered_vertices.append(vertex)
+
+            if len(filtered_vertices) > 2:
+                return Wire.ByVertices(filtered_vertices, close=wire.IsClosed())
+            elif len(filtered_vertices) == 2:
+                return Edge.ByStartVertexEndVertex(filtered_vertices[0], filtered_vertices[1], tolerance=tolerance, silent=True)
+            else:
+                return wire
+
+        # Main function logic
+        if Topology.IsInstance(wire, "Cluster"):
+            wires = Topology.Wires(wire)
+            processed_wires = [Wire.RemoveCollinearEdges(w, angTolerance, tolerance, silent) for w in wires]
+            if len(processed_wires) == 0:
+                if not silent:
+                    print("Wire.RemoveCollinearEdges - Error: No wires were produced. Returning None.")
+                return None
+            elif len(processed_wires) == 1:
+                return Topology.SelfMerge(processed_wires[0])
+            else:
+                return Topology.SelfMerge(Cluster.ByTopologies(processed_wires, silent=silent))
+
+        if not Topology.IsInstance(wire, "Wire"):
+            if not silent:
+                print(f"Wire.RemoveCollinearEdges - Error: Input is not a valid wire. Returning None.")
+            return None
+
+        new_wire = cleanup(wire)
+        wires = Wire.Split(new_wire) if not Wire.IsManifold(new_wire) else [new_wire]
+
+        processed_wires = [remove_collinear_vertices(w) for w in wires]
+
+        if len(processed_wires) == 0:
+            return wire
+        elif len(processed_wires) == 1:
+            return Topology.SelfMerge(processed_wires[0])
+        else:
+            return Topology.SelfMerge(Cluster.ByTopologies(processed_wires, silent=silent))
+
+    @staticmethod
+    def RemoveCollinearEdges_old(wire, angTolerance: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Removes any collinear edges in the input wire.
+
         Parameters
         ----------
         wire : topologic_core.Wire
@@ -3051,8 +3146,6 @@ class Wire():
                 return result
         if not Topology.IsInstance(wire, "Wire"):
             if not silent:
-                print("The wire is:", wire)
-                Topology.Show(wire)
                 print("Wire.RemoveCollinearEdges - Error: The input wire parameter is not a valid wire. Returning None.")
                 curframe = inspect.currentframe()
                 calframe = inspect.getouterframes(curframe, 2)

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.82'
+__version__ = '0.7.84'

{topologicpy-0.7.82.dist-info → topologicpy-0.7.84.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.82
+Version: 0.7.84
 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.7.82.dist-info → topologicpy-0.7.84.dist-info}/RECORD

@@ -1,16 +1,16 @@
 topologicpy/ANN.py,sha256=m_WxD1lgQqDhUpaM20Lia6TmJACDYaAE96wigsi-99U,47932
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
 topologicpy/BVH.py,sha256=mKVCAu9K8qzcWXtPDVH5usXZV1DNNNJl4n3rU5Lh1ZM,12931
-topologicpy/Cell.py,sha256=2izd-YGqy897_JHHgrGlIo5WwUeEIWVD3KspV1z_sj8,107860
-topologicpy/CellComplex.py,sha256=5PtnRrDx_3zmtt4aTosxK9XBzZtayzaOC50pkJiIlFY,51170
+topologicpy/Cell.py,sha256=j6e0Hk5GVlCPXhwc39Qo3pSpWZF4nv4uCZojdg3uXO8,108046
+topologicpy/CellComplex.py,sha256=DbSiVZ-_J8vXud1cm69p9Te9sTJUB-_zE3rgbhqKw5E,51424
 topologicpy/Cluster.py,sha256=51q5G1L5xAzRMfVU8YBXhq0g3g2X9aVNcahU-vYZRrI,55672
 topologicpy/Color.py,sha256=wPhA7rLr9BTZsWYUUVnQpbmL5ZMkGlDSsa8f3S5B-d4,20250
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
 topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
 topologicpy/Dictionary.py,sha256=0AsGoz48pGTye_F4KcJopNjD9STeQ50LHc6PPvERFaA,31932
-topologicpy/Edge.py,sha256=9u9SdUxuenLUIK26xwFvPoYV34p0dCfXmHHBxdgvAdM,67164
+topologicpy/Edge.py,sha256=k71TGaJRERI2vgygDu-pYprUgu49N9UApcCxCorQyzc,67185
 topologicpy/EnergyModel.py,sha256=AqTtmXE35SxvRXhG3vYAQd7GQDW-6HtjYPHua6ME4Eg,53762
-topologicpy/Face.py,sha256=Y13hw84bjJO8bzEG7sB7PRDxcSqqmGZnNAbIhIUQ1Ys,136243
+topologicpy/Face.py,sha256=IAAueOqHOw3Kn_ZPxxBKgVgC5fFdcuiLMC1HeOPI92Y,142159
 topologicpy/Graph.py,sha256=ZhMVB6ntuhIgTrKLUPryeAJFFBF0cnRsNgESbaohOiw,416914
 topologicpy/Grid.py,sha256=9N6PE84qCm40TRi2WtlVZSBwXXr47zHpscEpZHg_JW4,18205
 topologicpy/Helper.py,sha256=vUWbnZJxn0e9YsFUNyJ5Dee8Nh6TmDp9uCzCk4e0qAA,21897
@@ -20,17 +20,17 @@ topologicpy/Neo4j.py,sha256=t52hgE9cVsqkGc7m7fjRsLnyfRHakVHwdvF4ms7ow78,22342
 topologicpy/Plotly.py,sha256=z7xs9Ra2OwJNv5NMapH27R6didS8UMpjZIN35ZnAQcE,113501
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
-topologicpy/Shell.py,sha256=8OJjlWk9eCZ3uGOTht6ZVrcMczCafw-YWoDGueaz7eg,87673
+topologicpy/Shell.py,sha256=xYpGxQ1x7hKVYD03_zhEY77lbDAsffttKYZWKiZAsNs,87859
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=nTthwB8vmfdpfoP8tTQCUhHr29WhjuV7l0btAI1rHkQ,433216
+topologicpy/Topology.py,sha256=9X9Y2Y1tXe_oefNp6oQRG6v7ZgmIec5pZ7KiBxSXKNY,433499
 topologicpy/Vector.py,sha256=A1g83zDHep58iVPY8WQ8iHNrSOfGWFEzvVeDuMnjDNY,33078
-topologicpy/Vertex.py,sha256=mcLJaWFCct03dkVmT25wAl6k0k2EaYvB1PWNO9WQHWg,73465
-topologicpy/Wire.py,sha256=o6MlOjubkJ_f5s1tUamizCsoPKvcQ2OudtJv0yCF-2o,186477
+topologicpy/Vertex.py,sha256=7oEu6xXl1vi8M_HFnPT66W8OO8Eb3eab2oKvgzzLK-A,73737
+topologicpy/Wire.py,sha256=e9vN5nRIUIqwA0bElVB6Vrto862OXJ97iDHhc-JEt3s,190501
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=rXEi2ZZcGFgf2u3AMH7tyJUFE9nvS8L279fdB54xeCk,23
-topologicpy-0.7.82.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.82.dist-info/METADATA,sha256=CZZqWePZAWM-hGdFkhmjQf9qbm3Ub_fKCPzHnu7RYvk,10513
-topologicpy-0.7.82.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-topologicpy-0.7.82.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.82.dist-info/RECORD,,
+topologicpy/version.py,sha256=U66vZMAESD9QWsvrRbFl3J6Cqc8Xv9QpUU903eulUJI,23
+topologicpy-0.7.84.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.84.dist-info/METADATA,sha256=WKYqAGNwpDTkn9KOQDEUQkV7w5v-v4jCEuzpnemh7Cs,10513
+topologicpy-0.7.84.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.7.84.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.84.dist-info/RECORD,,