topologicpy 0.8.59__py3-none-any.whl → 0.8.71__py3-none-any.whl

topologicpy/Vertex.py

@@ -750,17 +750,8 @@ class Vertex():
 
         """
         from topologicpy.Topology import Topology
-        
-        def boundingBox(cell):
-            vertices = Topology.Vertices(cell)
-            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))
-            return ([min(x), min(y), min(z), max(x), max(y), max(z)])
+        from topologicpy.Cell import Cell
+        from topologicpy.BVH import BVH
         
         if Topology.IsInstance(topology, "Cell"):
             cells = [topology]
@@ -770,15 +761,17 @@ class Vertex():
             return None
         if len(cells) < 1:
             return None
+        
+        bvh = BVH.ByTopologies(cells, tolerance=tolerance, silent=True)
+        candidates = BVH.Clashes(bvh, vertex, tolerance=tolerance)
+        print("Vertex.EnclosingCells - candidates:", candidates)
         enclosingCells = []
-        for i in range(len(cells)):
-            bbox = boundingBox(cells[i])
-            if ((Vertex.X(vertex, mantissa=mantissa) < bbox[0]) or (Vertex.Y(vertex, mantissa=mantissa) < bbox[1]) or (Vertex.Z(vertex, mantissa=mantissa) < bbox[2]) or (Vertex.X(vertex, mantissa=mantissa) > bbox[3]) or (Vertex.Y(vertex, mantissa=mantissa) > bbox[4]) or (Vertex.Z(vertex, mantissa=mantissa) > bbox[5])) == False:
-                if Vertex.IsInternal(vertex, cells[i], tolerance=tolerance):
-                    if exclusive:
-                        return([cells[i]])
-                    else:
-                        enclosingCells.append(cells[i])
+        for i in range(len(candidates)):
+            if Vertex.IsInternal(vertex, candidates[i], tolerance=tolerance):
+                if exclusive:
+                    return([candidates[i]])
+                else:
+                    enclosingCells.append(candidates[i])
         return enclosingCells
 
     @staticmethod
@@ -1137,9 +1130,27 @@ class Vertex():
         return not (Vertex.IsPeripheral(vertex, topology, tolerance=tolerance, silent=silent) or Vertex.IsInternal(vertex, topology, tolerance=tolerance, silent=silent))
     
     @staticmethod
-    def IsInternal(vertex, topology, tolerance: float = 0.0001, silent: bool = False) -> bool:
-        """
-        Returns True if the input vertex is inside the input topology. Returns False otherwise.
+    def IsInternal(
+        vertex,
+        topology,
+        maxLeafSize: int = 4,
+        identify: bool = False,
+        tolerance: float = 0.0006,
+        silent: bool = True,
+    ) -> bool:
+        """
+        Returns True if `vertex` lies inside (or on the boundary of) `topology`.
+
+        Broad-phase:
+        - Build a BVH over Cells (3D) or Faces (2D) using BVH.ByTopologies.
+        - Query via BVH.Clashes(bvh, vertex) to get only nearby primitives.
+
+        Narrow-phase (geometric, no Topology.IsInternal):
+        - Boundary snap: if Vertex.Distance(vertex, primitive) <= tolerance -> inside.
+        - 3D: Cast a ray (+X direction). For each candidate Cell, intersect the ray with its Faces.
+                For each intersected Face: project face polygon(s) to 2D (dominant-axis drop) and
+                test point-in-polygon (outer minus holes). Odd number of valid intersections => inside.
+        - 2D: Project the Face loops to 2D and do point-in-polygon (outer minus holes).
 
         Parameters
         ----------
@@ -1147,97 +1158,320 @@ class Vertex():
             The input vertex.
         topology : topologic_core.Topology
             The input topology.
-        tolerance : float , optional
-            The tolerance for computing if the input vertex is internal to the input topology. Default is 0.0001.
-        silent : bool , optional
-            If set to True, error and warning messages are suppressed. Default is False.
+        maxLeafSize: int , optional
+            The maximum number of primitives (topologies) that can be stored in a single leaf node of the BVH.
+            Smaller values result in deeper trees with finer spatial subdivision (potentially faster queries but slower build times),
+            while larger values produce shallower trees with coarser spatial grouping (faster builds but less precise queries).
+            Default is 4.
+        identify: bool, optional
+            If set to True, a tuple is returned where the identified subTopology is returned (e.g. (True, edge)). Default is False.
+        tolerance : float, optional
+            Distance and numeric tolerance. Default 1e-7.
+        silent : bool, optional
+            Suppress non-critical prints.
 
         Returns
         -------
         bool
-            True if the input vertex is internal to the input topology. False otherwise.
-
         """
-        from topologicpy.Edge import Edge
-        from topologicpy.Wire import Wire
+        # --- Local imports (TopologicPy) ---
+        from topologicpy.Topology import Topology
+        from topologicpy.Vertex import Vertex
         from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.Shell import Shell
         from topologicpy.CellComplex import CellComplex
         from topologicpy.Cluster import Cluster
-        from topologicpy.Topology import Topology
-        import inspect
-
-        if not Topology.IsInstance(vertex, "Vertex"):
-            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
+        from topologicpy.Wire import Wire
+        from topologicpy.Edge import Edge
+        from topologicpy.BVH import BVH
+        from topologicpy.BVH import AABB
+        from topologicpy.Helper import Helper
 
-        if Topology.IsInstance(topology, "Vertex"):
-            return Vertex.Distance(vertex, topology) <= tolerance
-        elif Topology.IsInstance(topology, "Edge"):
-            try:
-                parameter = Edge.ParameterAtVertex(topology, vertex)
-            except:
-                parameter = 400 #arbitrary large number greater than 1
-            if parameter == None:
-                return False
-            return 0 <= parameter <= 1
-        elif Topology.IsInstance(topology, "Wire"):
-            vertices = [v for v in Topology.Vertices(topology) if Vertex.Degree(v, topology) > 1]
-            edges = Wire.Edges(topology)
-            sub_list = vertices + edges
-            for sub in sub_list:
-                if Vertex.IsInternal(vertex, sub, tolerance=tolerance, silent=silent):
-                    return True
-            return False
-        elif Topology.IsInstance(topology, "Face"):
-            # Test the distance first
-            if Vertex.PerpendicularDistance(vertex, topology) > tolerance:
-                return False
-            if Vertex.IsPeripheral(vertex, topology):
+        # --------------------------
+        # Utilities
+        # --------------------------
+        def v_coords(v):
+            return Vertex.X(v), Vertex.Y(v), Vertex.Z(v)
+
+        def vec_sub(a, b):
+            return (a[0]-b[0], a[1]-b[1], a[2]-b[2])
+
+        def vec_dot(a, b):
+            return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
+
+        def vec_cross(a, b):
+            return (a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0])
+
+        def vec_len(a):
+            return (a[0]*a[0]+a[1]*a[1]+a[2]*a[2])**0.5
+
+        def vec_norm(a):
+            l = vec_len(a)
+            if l == 0:
+                return (0.0, 0.0, 0.0)
+            return (a[0]/l, a[1]/l, a[2]/l)
+
+        # Plane from 3 points
+        def face_plane(face):
+            # Returns (n, d) where plane: n·X + d = 0; n is unit normal.
+            # Use first 3 distinct points of the external boundary.
+            w_ext = Face.ExternalBoundary(face)
+            verts = Wire.Vertices(w_ext)
+            pts = [v_coords(v) for v in verts]
+            # Find non-collinear triplet
+            p0 = pts[0]
+            n = None
+            for i in range(1, len(pts)-1):
+                v1 = vec_sub(pts[i], p0)
+                v2 = vec_sub(pts[i+1], p0)
+                n_try = vec_cross(v1, v2)
+                if vec_len(n_try) > 1e-15:
+                    n = vec_norm(n_try)
+                    break
+            if n is None:
+                # Degenerate face; assign arbitrary normal
+                n = (1.0, 0.0, 0.0)
+            d = -vec_dot(n, p0)
+            return n, d
+
+        def dominant_axis(n):
+            # Return axis to drop when projecting to 2D (index 0=x,1=y,2=z)
+            ax = abs(n[0]); ay = abs(n[1]); az = abs(n[2])
+            if ax >= ay and ax >= az:
+                return 0
+            if ay >= ax and ay >= az:
+                return 1
+            return 2
+
+        def project_point(p, drop_axis):
+            if drop_axis == 0:
+                return (p[1], p[2])
+            elif drop_axis == 1:
+                return (p[0], p[2])
+            else:
+                return (p[0], p[1])
+
+        def ray_plane_intersection(orig, dirv, n, d):
+            # Solve n·(orig + t*dir) + d = 0  -> t = -(n·orig + d) / (n·dir)
+            ndotdir = vec_dot(n, dirv)
+            if abs(ndotdir) < 1e-15:
+                return None  # parallel
+            t = -(vec_dot(n, orig) + d) / ndotdir
+            return t
+
+        # 2D point-in-polygon (ray crossing). Polygon is list of 2D points (closed or open).
+        def pip_ray_cross_2d(pt, poly):
+            x, y = pt
+            inside = False
+            n = len(poly)
+            if n < 3:
                 return False
-            normal = Face.Normal(topology)
-            proj_v = Vertex.Project(vertex, topology)
-            v1 = Topology.TranslateByDirectionDistance(proj_v, normal, 1)
-            v2 = Topology.TranslateByDirectionDistance(proj_v, normal, -1)
-            edge = Edge.ByVertices(v1, v2)
-            intersect = edge.Intersect(topology)
-            if intersect == None:
+            for i in range(n):
+                x1, y1 = poly[i]
+                x2, y2 = poly[(i+1) % n]
+                # Check if point is on edge (within tolerance)
+                # Project distance to segment
+                # (cheap check first)
+                minx = min(x1, x2) - 1e-15
+                maxx = max(x1, x2) + 1e-15
+                miny = min(y1, y2) - 1e-15
+                maxy = max(y1, y2) + 1e-15
+                if minx <= x <= maxx and miny <= y <= maxy:
+                    # Cross product close to zero?
+                    dx1, dy1 = x - x1, y - y1
+                    dx2, dy2 = x2 - x1, y2 - y1
+                    cross = dx1 * dy2 - dy1 * dx2
+                    if abs(cross) <= 1e-12:
+                        return True  # on boundary
+                # Ray crossing
+                cond1 = (y1 > y) != (y2 > y)
+                if cond1:
+                    xinters = (x2 - x1) * (y - y1) / (y2 - y1 + 1e-300) + x1
+                    if x <= xinters + 1e-15:
+                        inside = not inside
+            return inside
+
+        def polygon_with_holes_contains_2d(pt, outer, holes):
+            if not pip_ray_cross_2d(pt, outer):
                 return False
+            for hole in holes:
+                if pip_ray_cross_2d(pt, hole):
+                    return False
             return True
-        elif Topology.IsInstance(topology, "Shell"):
-            if Vertex.IsPeripheral(vertex, topology, tolerance=tolerance, silent=silent):
-                return False
+
+        def face_loops_2d(face, drop_axis):
+            # Returns (outer2d, [hole2d,...])
+            w_ext = Face.ExternalBoundary(face)
+            outer_vs = Wire.Vertices(w_ext)
+            outer = [project_point(v_coords(v), drop_axis) for v in outer_vs]
+
+            holes_2d = []
+            try:
+                inner_wires = Face.InternalBoundaries(face) or []
+            except Exception:
+                inner_wires = []
+            for w in inner_wires:
+                vs = Wire.Vertices(w)
+                holes_2d.append([project_point(v_coords(v), drop_axis) for v in vs])
+            return outer, holes_2d
+
+        # Ray casting against one face; returns hit-point (3D) if the ray hits inside the face.
+        def ray_hits_face(orig, dirv, face, tol=1e-12):
+            n, d = face_plane(face)
+            t = ray_plane_intersection(orig, dirv, n, d)
+            if t is None or t < -tol:
+                return None  # behind or parallel
+            # Intersection point
+            ip = (orig[0] + t*dirv[0], orig[1] + t*dirv[1], orig[2] + t*dirv[2])
+            # Project to 2D in face's dominant plane and do PIP against loops
+            ax = dominant_axis(n)
+            outer2d, holes2d = face_loops_2d(face, ax)
+            ip2d = project_point(ip, ax)
+            if polygon_with_holes_contains_2d(ip2d, outer2d, holes2d):
+                return ip
+            return None
+
+        # 2D containment in an Edge
+        def point_in_vertex(vtx, vertex, tol):
+            # Boundary snap first
+            if Vertex.Distance(vtx, vertex) <= tol:
+                return True
+            return False
+        
+        # 2D containment in an Edge
+        def point_in_edge(vtx, edge, tol):
+            # Boundary snap first
+            if Vertex.Distance(vtx, edge) <= tol:
+                return True
+            return False
+        
+        # 2D containment in a Face (vertex assumed coplanar or nearly so)
+        def point_in_face(vtx, face, tol):
+            status = topologic.FaceUtility.IsInside(face, vtx, tol)
+            return status
+
+        # 3D containment in a Cell via ray casting (+X direction)
+        def point_in_cell(vtx, cell, tol):
+            status = Cell.ContainmentStatus(cell, vtx, tolerance = tol)
+            return status == 0
+
+        # --------------------------
+        # Check if inside AABB
+        # --------------------------
+        points = [Vertex.Coordinates(v) for v in Topology.Vertices(topology)]
+        aabb = AABB.from_points(points)
+        if not aabb.contains_point(Vertex.Coordinates(vertex)):
+            return False
+
+        # --------------------------
+        # Collect primitives
+        # --------------------------
+        def collect_cells(topo):
+            if Topology.IsInstance(topo, "cell"):
+                return [topo]
             else:
-                edges = Topology.Edges(topology)
-                for edge in edges:
-                    if Vertex.IsInternal(vertex, edge, tolerance=tolerance, silent=silent):
-                        return True
-                faces = Topology.Faces(topology)
-                for face in faces:
-                    if Vertex.IsInternal(vertex, face, tolerance=tolerance, silent=silent):
-                        return True
-                return False
-        elif Topology.IsInstance(topology, "Cell"):
-            return topologic.CellUtility.Contains(topology, vertex, tolerance) == 0 # Hook to Core
-        elif Topology.IsInstance(topology, "CellComplex"):
-            ext_boundary = CellComplex.ExternalBoundary(topology)
-            return Vertex.IsInternal(vertex, ext_boundary, tolerance=tolerance, silent=silent)
-        elif Topology.IsInstance(topology, "Cluster"):
-            sub_list = Cluster.FreeTopologies(topology)
-            for sub in sub_list:
-                if Vertex.IsInternal(vertex, sub, tolerance=tolerance, silent=silent):
-                    return True
+                return Topology.Cells(topo)
+
+        def collect_faces(topo):
+            if Topology.IsInstance(topo, "face"):
+                return [topo]
+            else:
+                return Topology.Faces(topo)
+
+        def collect_edges(topo):
+            if Topology.IsInstance(topo, "edge"):
+                return [topo]
+            else:
+                return Topology.Edges(topo)
+        def collect_vertices(topo):
+            if Topology.IsInstance(topo, "vertex"):
+                return [topo]
+            else:
+                return Topology.Vertices(topo)
+
+        if Topology.IsInstance(topology, "cluster"):
+            cells = collect_cells(topology)
+            faces = collect_faces(topology)
+            edges = collect_edges(topology)
+            vertices = collect_vertices(topology)
+        else:
+            cells = collect_cells(topology)
+            faces = [] if cells else collect_faces(topology)
+            edges = [] if faces else collect_edges(topology)
+            vertices = [] if edges else collect_vertices(topology)
+        if not cells and not faces and not edges and not vertices:
             return False
+
+        # --------------------------
+        # Build BVH and fetch candidates
+        # --------------------------
+        primitives = []
+        primitives.extend(vertices)
+        primitives.extend(edges)
+        primitives.extend(faces)
+        primitives.extend(cells)
+        bvh = BVH.ByTopologies(primitives, maxLeafSize=maxLeafSize, tolerance=tolerance, silent=True)
+        try:
+            candidates = BVH.Clashes(bvh, vertex, tolernace=tolerance) or []
+        except Exception:
+            # Fallback if your BVH needs a non-degenerate query
+            candidates = primitives
+
+        if not candidates:
+            return False
+
+        # sort by types so that priority is given to lower dimensional types (e.g. vertices, then edges, then faces, then cells)
+        types = [Topology.Type(c) for c in candidates]
+        candidates = Helper.Sort(candidates, types)
+        # --------------------------
+        # Narrow phase
+        # --------------------------
+        for c in candidates:
+            if Topology.IsInstance(c, "cell"):
+                # Exact geometric test
+                try:
+                    if point_in_cell(vertex, c, tolerance):
+                        if identify:
+                            return (True, c)
+                        else:
+                            return True
+                except Exception:
+                    if not silent:
+                        print("Warning: point_in_cell failed on a candidate.")
+            elif Topology.IsInstance(c, "face"):
+                try:
+                    if point_in_face(vertex, c, tolerance):
+                        if identify:
+                            return (True, c)
+                        else:
+                            return True
+                        return True
+                except Exception:
+                    if not silent:
+                        print("Warning: point_in_face failed on a candidate.")
+            elif Topology.IsInstance(c, "edge"):
+                try:
+                    if point_in_edge(vertex, c, tolerance):
+                        if identify:
+                            return (True, c)
+                        else:
+                            return True
+                except Exception:
+                    if not silent:
+                        print("Warning: point_in_edge failed on a candidate.")
+            elif Topology.IsInstance(c, "vertex"):
+                try:
+                    if point_in_vertex(vertex, c, tolerance):
+                        if identify:
+                            return (True, c)
+                        else:
+                            return True
+                except Exception:
+                    if not silent:
+                        print("Warning: point_in_vertex failed on a candidate.")
+        if identify:
+            return (False, None)
         return False
     
     @staticmethod

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.59'
+__version__ = '0.8.71'

{topologicpy-0.8.59.dist-info → topologicpy-0.8.71.dist-info}/METADATA

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

@@ -1,39 +1,39 @@
 topologicpy/ANN.py,sha256=gpflv4lFypOW789vO7mSkMLaMF_ZftVOCqCvtGr6-JA,47873
 topologicpy/Aperture.py,sha256=wNn5miB_IrGCBYuQ18HXQYRva20dUC3id4AJCulL7to,2723
-topologicpy/BVH.py,sha256=JA4bb-9hgMfVZ_syzmSmTL3ueCq-0vMUGMPZxNcawAY,13023
+topologicpy/BVH.py,sha256=ts0Ru24ILjjfHa54SYNhMc8Jkyxwej1DV0Jv7P_6BoU,22513
 topologicpy/CSG.py,sha256=09la1-xzS9vr-WnV7tpJ0I-mkZ-XY0MRSd5iB50Nfgw,15556
-topologicpy/Cell.py,sha256=ndrfovjwEEQTJ0B5DuthuCBDdVg9-1i_MX8Dtj-wD4E,177330
+topologicpy/Cell.py,sha256=xkt9lfutgSwr_1lah1U5n48UnrLIggznNKUmEe2FA2g,177505
 topologicpy/CellComplex.py,sha256=Kbz63rGeE08bJfMXFvB-AptoKHiaCK5OtiV1wz8Y-Fk,68081
 topologicpy/Cluster.py,sha256=G49AuhJHQ1s819cB5MtVdmAGgkag19IC3dRP1ub1Wh4,58608
 topologicpy/Color.py,sha256=hzSmgBWhiuYc55RSipkQNIgGtgyhC5BqY8AakNYEK-U,24486
 topologicpy/Context.py,sha256=G3CwMvN8Jw2rnQRwB-n4MaQq_wLS0vPimbXKwsdMJ80,3055
 topologicpy/DGL.py,sha256=O7r22ss0tgak4kWaACkyExhR_rZ46O_bqIBpxAcwJkw,138918
-topologicpy/Dictionary.py,sha256=Z4YQ88tONWd-0X0dENQ8IZqIOa9mbBqhJkTBsHmft2g,44619
+topologicpy/Dictionary.py,sha256=goODXIM6AoC5Qn_d8LGc5pRoxZKgIWbkn3IOEbsQ4c4,44999
 topologicpy/Edge.py,sha256=DifItuyabFDUFC7CVMlt2DeMFMNaGOqCg43iU9CPP0A,74029
 topologicpy/EnergyModel.py,sha256=hB1aiJe45gdDMFm1AhkBr-1djjtXSzn24iRpQMk43-4,57749
-topologicpy/Face.py,sha256=aX9EcR3JGbLITElhd25J0Z8m9U8KkmbYivGg3oZN-Uw,202296
-topologicpy/Graph.py,sha256=LMK-YceKCPP4-8s32mTF2QPRaxbUiKSwytV3WcpQJIE,756629
+topologicpy/Face.py,sha256=aIo955DwDwPD829ezIxKcWRktOncD3VuSXXAeTXxXcs,201122
+topologicpy/Graph.py,sha256=ytXl9VLj243o9LhY0A8P_gp4_Ce_VrHW5oaC2WK6Mbc,782718
 topologicpy/Grid.py,sha256=3OsBMyHh4w8gpFOTMKHMNTpo62V0CwRNu5cwm87yDUA,18421
 topologicpy/Helper.py,sha256=Nr6pyzl0sZm4Cu11wOqoYKu6yYal5N6A9jErXnaZBJc,31765
 topologicpy/Honeybee.py,sha256=DzaG9wpkJdcDWcjOGXhuN5X0gCqypmZGBa1y5E2MkjU,48964
-topologicpy/Kuzu.py,sha256=THmXfImCVTZhvt0fH0M2-PJeFNyTnmBCf_sjXDxOraE,36305
+topologicpy/Kuzu.py,sha256=fxaDPWM5Xam7Tot0olPZsazS_7xgE_Vo-jf0Sbv3VZE,36298
 topologicpy/Matrix.py,sha256=bOofT34G3YHu9aMIWx60YHAJga4R0GbDjsZBUD4Hu_k,22706
 topologicpy/Neo4j.py,sha256=J8jU_mr5-mWC0Lg_D2dMjMlx1rY_eh8ks_aubUuTdWw,22319
 topologicpy/Plotly.py,sha256=OQvCzAXqu_QYn8iY0rjc8ZB4XwwK70pWjnnoMzDdcc0,123167
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=wOsoBFxMgwZYWjj86OMkz_PJuQ02locV_djhSDD6dVc,109644
 topologicpy/ShapeGrammar.py,sha256=KYsKDLXWdflAcYMAIz84AUF-GMkbTmaBDd2-ovbilqU,23336
-topologicpy/Shell.py,sha256=ioO4raCJfXtYldQg-adpcLVeJPEA6od6cAA5ro7t6r4,96792
+topologicpy/Shell.py,sha256=JBTw3T1CjJt3ZPTjG1eBU2Oe2n_helW9ioML_bYK2_U,98545
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=8S6dhCKfOhUGVny-jEk87Q08anLYMB1JEBKRGCklvbQ,36670
-topologicpy/Topology.py,sha256=_D1E8c8lnbu4Eii4YjkJhWoNb-q2ELdnLIE-xQFloPg,472580
+topologicpy/Topology.py,sha256=9reHlXzUXYbXt0FJbThL3Wr0JEF2oAHuNRerU2BshxM,473587
 topologicpy/Vector.py,sha256=pEC8YY3TeHGfGdeNgvdHjgMDwxGabp5aWjwYC1HSvMk,42236
-topologicpy/Vertex.py,sha256=r_3cicgpino96ymm1ANptfOuqE59b99YWwksxyPOYK4,85914
+topologicpy/Vertex.py,sha256=eO74ZcuQUmiEHy5-Xyn7YDlt3R7YKoqB-BEwF-TUcDM,94101
 topologicpy/Wire.py,sha256=gjgQUGHdBdXUIijgZc_VIW0E39w-smaVhhdl0jF63fQ,230466
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=JBWmeYi_9RclzA_WCIMX3fzJxg3vh3eyKLFiq90X2mA,23
-topologicpy-0.8.59.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.59.dist-info/METADATA,sha256=hEPFnN0ZWkV_YPvQ5wemo_9nnmV9H6qW42XErgpUvSs,10535
-topologicpy-0.8.59.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.59.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.59.dist-info/RECORD,,
+topologicpy/version.py,sha256=49ezdJH-CaZn_7E1pYgol2MJ6KVA4JWjsEILF4g69nI,23
+topologicpy-0.8.71.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.71.dist-info/METADATA,sha256=eJ0CeTYd_RvHdNXNjmyK1IRQzZqzuEDmqSuwbdLAGEY,10535
+topologicpy-0.8.71.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.71.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.71.dist-info/RECORD,,