topologicpy 0.7.26__py3-none-any.whl → 0.7.28__py3-none-any.whl

topologicpy/Cell.py

@@ -99,7 +99,7 @@ class Cell():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -384,7 +384,7 @@ class Cell():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Raises
         ------

topologicpy/Cluster.py

@@ -154,7 +154,8 @@ class Cluster():
         transferDictionaries : bool , optional
             If set to True, the dictionaries from the input topologies are merged and transferred to the cluster. Otherwise they are not. The default is False.
         silent : bool , optional
-            If set to True, error and warning messages are not displayed. Otherwise, they are. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
         Returns
         -------
         topologic_core.Cluster

topologicpy/Dictionary.py

@@ -162,7 +162,7 @@ class Dictionary():
         dictionaries : list or comma separated dictionaries
             The input list of dictionaries to be merged.
         silent : bool , optional
-            If set to True, error and warning messages are not displayed. Otherwise, they are. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------

topologicpy/Edge.py

@@ -232,7 +232,7 @@ class Edge():
         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 False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
         
         Returns
         -------
@@ -280,7 +280,7 @@ class Edge():
         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, error and warning messages are printed. Otherwise, they are not. The default is True.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -355,6 +355,48 @@ class Edge():
             return None
         return Edge.ByStartVertexEndVertex(vertexList[0], vertexList[-1], tolerance=tolerance)
 
+    @staticmethod
+    def Connection(edgeA, edgeB, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns the edge representing the connection between the first input edge to the second input edge using the two closest vertices.
+
+        Parameters
+        ----------
+        edgeA : topologic_core.Edge
+            The first input edge. This edge will be extended to meet edgeB.
+        edgeB : topologic_core.Edge
+            The second input edge. This edge will be used to extend edgeA.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic_core.Edge or topologic_core.Wire
+            The connected edge. Since it is made of two edges, this method returns a Wire.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Helper import Helper
+
+        sva = Edge.StartVertex(edgeA)
+        eva = Edge.EndVertex(edgeA)
+        svb = Edge.StartVertex(edgeB)
+        evb = Edge.EndVertex(edgeB)
+        v_list = [[sva, svb], [sva, evb], [eva, svb], [eva, evb]]
+        distances = []
+        for pair in v_list:
+            distances.append(Vertex.Distance(pair[0], pair[1]))
+        v_list = Helper.Sort(v_list, distances)
+        closest_pair = v_list[0]
+        return_edge = Edge.ByVertices(closest_pair, silent=silent)
+        if return_edge == None:
+            if not silent:
+                print("Edge.ConnectToEdge - Warning: Could not connect the two edges. Returning None.")
+            return None
+        return return_edge
+    
     @staticmethod
     def Direction(edge, mantissa: int = 6) -> list:
         """
@@ -419,6 +461,55 @@ class Edge():
             vert = None
         return vert
     
+    @staticmethod
+    def Equation2D(edge, mantissa=6):
+        """
+        Returns the 2D equation of the input edge. This is assumed to be in the XY plane.
+
+        Parameters
+        ----------
+        edge : topologic_core.Edge
+            The input edge.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+
+        Returns
+        -------
+        dict
+            The equation of the edge stored in a dictionary. The dictionary has the following keys:
+            "slope": The slope of the line. This can be float('inf')
+            "x_intercept": The X axis intercept. This can be None.
+            "y_intercept": The Y axis intercept. This can be None.
+
+        """
+        from topologicpy.Vertex import Vertex
+
+        # Extract the start and end vertices
+        sv = Edge.StartVertex(edge)
+        ev = Edge.EndVertex(edge)
+        
+        # Extract coordinates of the vertices
+        x1, y1 = Vertex.X(sv, mantissa=mantissa), Vertex.Y(sv, mantissa=mantissa)
+        x2, y2 = Vertex.X(ev, mantissa=mantissa), Vertex.Y(ev, mantissa=mantissa)
+        
+        # Calculate the slope (m) and y-intercept (c)
+        if x2 - x1 != 0:
+            m = round((y2 - y1) / (x2 - x1), mantissa)
+            c = round(y1 - m * x1, mantissa)
+            return {
+                "slope": m,
+                "x_intercept": None,
+                "y_intercept": c
+            }
+        else:
+            # The line is vertical, slope is undefined
+            return {
+                "slope": float('inf'),
+                "x_intercept": x1,
+                "y_intercept": None
+            }
+
+
     @staticmethod
     def Extend(edge, distance: float = 1.0, bothSides: bool = True, reverse: bool = False, tolerance: float = 0.0001):
         """
@@ -465,7 +556,7 @@ class Edge():
         return Edge.ByVertices([sve, eve], tolerance=tolerance, silent=True)
 
     @staticmethod
-    def ExtendToEdge(edgeA, edgeB, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+    def ExtendToEdge(edgeA, edgeB, mantissa: int = 6, step: bool = True, tolerance: float = 0.0001, silent: bool = False):
         """
         Extends the first input edge to meet the second input edge.
 
@@ -480,17 +571,19 @@ class Edge():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to True, not error or warning messages are printed. Otherwise, they are. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
         
         Returns
         -------
         topologic_core.Edge
-            The trimmed edge.
+            The extended edge.
 
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Vector import Vector
+        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
 
         if not Topology.IsInstance(edgeA, "Edge"):
             if not silent:
@@ -504,10 +597,15 @@ class Edge():
             if not silent:
                 print("Edge.ExtendToEdge - Error: The input edges are not coplanar. Returning the original edge.")
             return edgeA
+        if Edge.IsCollinear(edgeA, edgeB, tolerance=tolerance):
+            if not silent:
+                print("Edge.ExtendToEdge - Warning: The input edges are collinear. Connecting the edges instead. Check return value.")
+            return Edge.ConnectToEdge(edgeA, edgeB, tolerance=tolerance)
         if Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
             if not silent:
-                print("Edge.ExtendToEdge - Error: The input edges are parallel. Returning the original edge.")
-            return edgeA
+                print("Edge.ExtendToEdge - Warning: The input edges are parallel. Connecting the edges instead. Returning a Wire.")
+            return Edge.ConnectToEdge(edgeA, edgeB, tolerance=tolerance)
+        
         
         sva = Edge.StartVertex(edgeA)
         eva = Edge.EndVertex(edgeA)
@@ -532,8 +630,9 @@ class Edge():
         intVertex = Topology.Intersect(new_edge, edgeB, tolerance=tolerance)
         if intVertex:
             return Edge.ByVertices([v1, intVertex], tolerance=tolerance, silent=True)
-        print("Edge.ExtendToEdge - Error: The operation failed. Returning None.")
-        return None
+        if not silent:
+            print("Edge.ExtendToEdge - Warning: The operation failed. Connecting the edges instead. Returning a Wire.")
+        return Edge.ConnectToEdge(edgeA, edgeB, tolerance=tolerance)
     
     @staticmethod
     def ExternalBoundary(edge):
@@ -613,6 +712,70 @@ class Edge():
                     return i
         return None
 
+    @staticmethod
+    def Intersect2D(edgeA, edgeB, silent: bool = False, mantissa: int = 6, tolerance: float = 0.0001):
+        """
+        Returns the intersection vertex of the two input edges. This is assumed to be in the XY plane.
+        The intersection vertex does not necessarily fall within the extents of either edge.
+
+        Parameters
+        ----------
+        edgeA : topologic_core.Edge
+            The first input edge.
+        edgeB : topologic_core.Edge
+            The second input edge.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+
+        Returns
+        -------
+        topologic_core.Vertex
+            The intersection vertex or None if the edges are parallel or collinear.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Helper import Helper
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+
+        sva = Edge.StartVertex(edgeA)
+        eva = Edge.EndVertex(edgeA)
+        svb = Edge.StartVertex(edgeB)
+        evb = Edge.EndVertex(edgeB)
+        v_list = [[sva, svb], [sva, evb], [eva, svb], [eva, evb]]
+        distances = []
+        for pair in v_list:
+            distances.append(Vertex.Distance(pair[0], pair[1]))
+        v_list = Helper.Sort(v_list, distances)
+        closest_pair = v_list[0]
+        if Vertex.Distance(closest_pair[0], closest_pair[1]) < tolerance:
+            return Topology.Centroid(Cluster.ByTopologies(closest_pair))
+        
+        if Edge.IsCollinear(edgeA, edgeB, tolerance=tolerance):
+            if not silent:
+                print("Edge.Intersect2D - Error: The input edges are collinear and overlapping. An intersection vertex cannot be found. Returning None.")
+            return None
+        if Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
+            if not silent:
+                print("Edge.Intersect2D - Error: The input edges are parallel. An intersection vertex cannot be found. Returning None.")
+            return None
+        
+        eq1 = Edge.Equation2D(edgeA, mantissa=mantissa)
+        eq2 = Edge.Equation2D(edgeB, mantissa=mantissa)
+        if eq1["slope"] == float('inf'):
+            x = eq1["x_intercept"]
+            y = eq2["slope"] * x + eq2["y_intercept"]
+        elif eq2["slope"] == float('inf'):
+            x = eq2["x_intercept"]
+            y = eq1["slope"] * x + eq1["y_intercept"]
+        else:
+            x = (eq2["y_intercept"] - eq1["y_intercept"]) / (eq1["slope"] - eq2["slope"])
+            y = eq1["slope"] * x + eq1["y_intercept"]
+        
+        return Vertex.ByCoordinates(x,y,0)
+
     @staticmethod
     def IsCollinear(edgeA, edgeB, mantissa: int = 6, tolerance: float = 0.0001) -> bool:
         """
@@ -936,11 +1099,11 @@ class Edge():
         if not Topology.IsInstance(edge, "Edge"):
             print("Edge.Normal - Error: The input edge parameter is not a valid edge. Returning None.")
             return None
-        normal_edge = Edge.NormalAsEdge(edge, length=1.0, u=0.5, angle=angle)
+        normal_edge = Edge.NormalEdge(edge, length=1.0, u=0.5, angle=angle)
         return Edge.Direction(normal_edge)
 
     @staticmethod
-    def NormalAsEdge(edge, length: float = 1.0, u: float = 0.5, angle: float = 0.0):
+    def NormalEdge(edge, length: float = 1.0, u: float = 0.5, angle: float = 0.0):
         """
         Returns the normal (perpendicular) vector to the input edge as an edge.
 
@@ -996,10 +1159,10 @@ class Edge():
             return start_vertex, list(normal_end_vertex)
 
         if not Topology.IsInstance(edge, "Edge"):
-            print("Edge.NormalAsEdge - Error: The input edge parameter is not a valid edge. Returning None.")
+            print("Edge.NormalEdge - Error: The input edge parameter is not a valid edge. Returning None.")
             return None
         if length <= 0.0:
-            print("Edge.NormalAsEdge - Error: The input length parameter is not a positive number greater than zero. Returning None.")
+            print("Edge.NormalEdge - Error: The input length parameter is not a positive number greater than zero. Returning None.")
             return None
         edge_direction = Edge.Direction(edge)
         x, y, z = edge_direction
@@ -1062,7 +1225,7 @@ class Edge():
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -1238,7 +1401,7 @@ class Edge():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to True, not error or warning messages are printed. Otherwise, they are. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
         
         Returns
         -------

topologicpy/Face.py

@@ -563,8 +563,8 @@ class Face():
             The input wire.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
-        silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+         silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -652,7 +652,7 @@ class Face():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to False, error messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -695,7 +695,7 @@ class Face():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to False, error messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
         
         Returns
         -------
@@ -1123,7 +1123,7 @@ class Face():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------

topologicpy/Graph.py

@@ -3991,8 +3991,8 @@ class Graph:
         maxColors : int , optional
             The desired maximum number of colors to test against. The default is 3.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
-        
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+       
         Returns
         -------
         int

topologicpy/Shell.py

@@ -389,8 +389,8 @@ class Shell():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
-        
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+       
         Returns
         -------
         topologic_core.Shell
@@ -485,7 +485,7 @@ class Shell():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------

topologicpy/Topology.py

@@ -999,8 +999,6 @@ class Topology():
             else:
                 cellsB_2.append(cellB)
         
-        print("cellsA_2", cellsA_2)
-        print("cellsB_2", cellsB_2)
         for cellA in cellsA_2:
             for cellB in cellsB_2:
                 cellC = cellA.Intersect(cellB)
@@ -2036,7 +2034,7 @@ class Topology():
         try:
             import ezdxf
         except:
-            print("Topology.ExportToDXF - Information: Installing required ezdxf library.")
+            print("Topology.ByDXFPath - Information: Installing required ezdxf library.")
             try:
                 os.system("pip install ezdxf")
             except:
@@ -6525,7 +6523,7 @@ class Topology():
         return return_topology
 
     @staticmethod
-    def SetDictionary(topology, dictionary):
+    def SetDictionary(topology, dictionary, silent=False):
         """
         Sets the input topology's dictionary to the input dictionary
 
@@ -6535,6 +6533,8 @@ class Topology():
             The input topology.
         dictionary : topologic_core.Dictionary
             The input dictionary.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -6545,15 +6545,18 @@ class Topology():
         from topologicpy.Dictionary import Dictionary
 
         if not Topology.IsInstance(topology, "Topology") and not Topology.IsInstance(topology, "Graph"):
-            print("Topology.SetDictionary - Error: the input topology parameter is not a valid topology or graph. Returning None.")
+            if not silent:
+                print("Topology.SetDictionary - Error: the input topology parameter is not a valid topology or graph. Returning None.")
             return None
         if isinstance(dictionary, dict):
             dictionary = Dictionary.ByPythonDictionary(dictionary)
         if not Topology.IsInstance(dictionary, "Dictionary"):
-            print("Topology.SetDictionary - Warning: the input dictionary parameter is not a valid dictionary. Returning original input.")
+            if not silent:
+                print("Topology.SetDictionary - Warning: the input dictionary parameter is not a valid dictionary. Returning original input.")
             return topology
         if len(dictionary.Keys()) < 1:
-            print("Topology.SetDictionary - Warning: the input dictionary parameter is empty. Returning original input.")
+            if not silent:
+                print("Topology.SetDictionary - Warning: the input dictionary parameter is empty. Returning original input.")
             return topology
         _ = topology.SetDictionary(dictionary)
         return topology

topologicpy/Vertex.py

@@ -1008,7 +1008,7 @@ class Vertex():
         tolerance : float , optional
             The tolerance for computing if the input vertex is external to the input topology. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -1042,7 +1042,7 @@ class Vertex():
         tolerance : float , optional
             The tolerance for computing if the input vertex is internal to the input topology. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -1153,7 +1153,7 @@ class Vertex():
         tolerance : float , optional
             The tolerance for computing if the input vertex is peripheral to the input topology. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------

topologicpy/Wire.py

@@ -49,96 +49,66 @@ class Wire(Topology):
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Face import Face
-        from topologicpy.Topology import Topology
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Vector import Vector
+        import numpy as np
+        
 
-        def segmented_arc(x1, y1, x2, y2, x3, y3, sides):
-            import math
+        def calculate_circle_center_and_radius(sv, mv, ev):
             """
-            Generates a segmented arc passing through the three given points.
-
-            Arguments:
-            x1, y1: Coordinates of the first point
-            x2, y2: Coordinates of the second point
-            x3, y3: Coordinates of the third point
-            sides: Number of sides to divide the arc
-
+            Calculate the center and radius of the circle passing through three points.
+            
+            Parameters:
+            sv (tuple): The start vertex as (x, y, z).
+            mv (tuple): The middle vertex as (x, y, z).
+            ev (tuple): The end vertex as (x, y, z).
+            
             Returns:
-            List of tuples [x, y] representing the segmented arc passing through the points
+            tuple: The center of the circle as (x, y, z) and the radius.
             """
-
-            # Calculate the center of the circle
-            A = x2 - x1
-            B = y2 - y1
-            C = x3 - x1
-            D = y3 - y1
-            E = A * (x1 + x2) + B * (y1 + y2)
-            F = C * (x1 + x3) + D * (y1 + y3)
-            G = 2 * (A * (y3 - y2) - B * (x3 - x2))
-            if G == 0:
-                center_x = 0
-                center_y = 0
-            else:
-                center_x = (D * E - B * F) / G
-                center_y = (A * F - C * E) / G
-
-            # Calculate the radius of the circle
-            radius = math.sqrt((center_x - x1) ** 2 + (center_y - y1) ** 2)
-
-            # Calculate the angles between the center and the three points
-            angle1 = math.atan2(y1 - center_y, x1 - center_x)
-            angle3 = math.atan2(y3 - center_y, x3 - center_x)
-
-            # Calculate the angle between points 1 and 3
-            angle13 = (angle3 - angle1) % (2 * math.pi)
-            if angle13 < 0:
-                angle13 += 2 * math.pi
-
-            # Determine the direction of the arc based on the angle between points 1 and 3
-            if angle13 < math.pi:
-                start_angle = angle3
-                end_angle = angle1
-            else:
-                start_angle = angle1
-                end_angle = angle3
-
-            # Calculate the angle increment
-            angle_increment = (end_angle - start_angle) / sides
-
-            # Generate the points of the arc passing through the points
-            arc_points = []
-            for i in range(sides + 1):
-                angle = start_angle + i * angle_increment
-                x = center_x + radius * math.cos(angle)
-                y = center_y + radius * math.sin(angle)
-                arc_points.append([x, y])
-
-            return arc_points
-        if not Topology.IsInstance(startVertex, "Vertex"):
-            print("Wire.Arc - Error: The startVertex parameter is not a valid vertex. Returning None.")
-            return None
-        if not Topology.IsInstance(middleVertex, "Vertex"):
-            print("Wire.Arc - Error: The middleVertex parameter is not a valid vertex. Returning None.")
-            return None
-        if not Topology.IsInstance(endVertex, "Vertex"):
-            print("Wire.Arc - Error: The endVertex parameter is not a valid vertex. Returning None.")
-            return None
-        if Vertex.AreCollinear([startVertex, middleVertex, endVertex], tolerance = tolerance):
-            return Wire.ByVertices([startVertex, middleVertex, endVertex], close=False)
+            # Convert points to numpy arrays for easier manipulation
+            A = np.array(sv)
+            B = np.array(mv)
+            C = np.array(ev)
+            
+            # Calculate the lengths of the sides of the triangle
+            a = np.linalg.norm(B - C)
+            b = np.linalg.norm(C - A)
+            c = np.linalg.norm(A - B)
+            
+            # Calculate the circumcenter using the formula
+            D = 2 * (A[0] * (B[1] - C[1]) + B[0] * (C[1] - A[1]) + C[0] * (A[1] - B[1]))
+            Ux = ((A[0]**2 + A[1]**2) * (B[1] - C[1]) + (B[0]**2 + B[1]**2) * (C[1] - A[1]) + (C[0]**2 + C[1]**2) * (A[1] - B[1])) / D
+            Uy = ((A[0]**2 + A[1]**2) * (C[0] - B[0]) + (B[0]**2 + B[1]**2) * (A[0] - C[0]) + (C[0]**2 + C[1]**2) * (B[0] - A[0])) / D
+            center = np.array([Ux, Uy, A[2]])
+            
+            # Calculate the radius
+            radius = np.linalg.norm(center - A)
+            
+            return center, radius
         
-        w = Wire.ByVertices([startVertex, middleVertex, endVertex], close=True)
-        f = Face.ByWire(w, tolerance=tolerance)
-        normal = Face.Normal(f)
-        flat_w = Topology.Flatten(w, origin=startVertex, direction=normal)
-        v1, v2, v3 = Topology.Vertices(flat_w)
-        x1, y1, z1 = Vertex.Coordinates(v1)
-        x2, y2, z2 = Vertex.Coordinates(v2)
-        x3, y3, z3 = Vertex.Coordinates(v3)
-        arc_points = segmented_arc(x1, y1, x2, y2, x3, y3, sides)
-        arc_verts = [Vertex.ByCoordinates(coord[0], coord[1], 0) for coord in arc_points]
-        arc = Wire.ByVertices(arc_verts, close=close)
-        # Unflatten the arc
-        arc = Topology.Unflatten(arc, origin=startVertex, direction=normal)
+        
+        e2 = Edge.ByVertices(middleVertex, endVertex)
+        
+        center, radius = calculate_circle_center_and_radius(Vertex.Coordinates(startVertex), Vertex.Coordinates(middleVertex), Vertex.Coordinates(endVertex))
+        center = Vertex.ByCoordinates(list(center))
+        
+        e1 = Edge.ByVertices(center, startVertex)
+        e2 = Edge.ByVertices(center, endVertex)
+        ang1 = Vector.CompassAngle(Vector.North(), Edge.Direction(e1))
+        ang2 = Vector.CompassAngle(Vector.North(), Edge.Direction(e2))
+        arc1 = Wire.Circle(origin=center, radius=radius, fromAngle=ang1, toAngle=ang2, sides=sides*4, close=False)
+        arc2 = Wire.Circle(origin=center, radius=radius, fromAngle=ang2, toAngle=ang1, sides=sides*4, close=False)
+        if Vertex.IsInternal(middleVertex, arc1):
+            arc = arc1
+        else:
+            arc = arc2
+        final_vertices = []
+        for i in range(sides+1):
+            v = Wire.VertexByParameter(arc, float(i)/float(sides))
+            final_vertices.append(v)
+        arc = Wire.ByVertices(final_vertices, close=close)
         return arc
     
     @staticmethod
@@ -340,9 +310,9 @@ class Wire(Topology):
         return Wire.ByEdges(edges, tolerance=tolerance)
 
     @staticmethod
-    def ByOffset(wire, offset: float = 1.0, bisectors: bool = False, tolerance: float = 0.0001):
+    def ByOffset(wire, offset: float = 1.0, offsetKey: str = "offset", bisectors: bool = False, tolerance: float = 0.0001,  silent: bool = False):
         """
-        Creates an offset wire from the input wire. A positive offset value results in an offset to the interior of the anti-clockwise wire.
+        Creates an offset wire from the input wire. A positive offset value results in an offset to the interior of an anti-clockwise wire.
 
         Parameters
         ----------
@@ -350,10 +320,14 @@ class Wire(Topology):
             The input wire.
         offset : float , optional
             The desired offset distance. The default is 1.0.
+        offsetKey : str , optional
+            The edge dictionary key under which to find the offset value. If a value cannot be found, the offset input parameter value is used instead. The default is "offset".
         bisectors : bool , optional
             If set to True, The bisectors (seams) edges will be included in the returned wire. The default is False.
         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
         -------
@@ -361,74 +335,104 @@ class Wire(Topology):
             The created wire.
 
         """
-        def compute_h(alpha, offset):
-            import math
-            alpha = math.radians(alpha) *0.5
-            h = offset/math.cos(alpha)
-            return h
-        
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
         from topologicpy.Face import Face
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Wire import Wire
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Vector import Vector
-        import math
 
         if not Topology.IsInstance(wire, "Wire"):
-            print("Wire.ByOffset - Error: The input wire parameter is not a valid wire. Returning None")
-            return None
-        if abs(offset) < tolerance:
-            return wire
-        vertices = Topology.Vertices(wire)
-        if len(vertices) < 3:
-            print("Wire.ByOffset - Error: The input wire parameter contains less than three vertices. Cannot proceed. Returning None")
-            return None
-        if not Wire.IsClosed(wire):
-            w = Wire.ByVertices(vertices, close=True)
-        else:
-            w = wire
-        three_vertices = Wire.Vertices(w)[0:3]
-        temp_w = Wire.ByVertices(three_vertices, close=True)
-        flat_face = Face.ByWire(temp_w, tolerance=tolerance)
+            if not silent:
+                print("Wire.ByOffset - Error: The input wire parameter is not a valid wire. Returning None.")
+                return None
+        
         origin = Vertex.Origin()
-        normal = Face.Normal(flat_face)
-        flat_wire = Topology.Flatten(w, origin=origin, direction=normal)
-        edges = Wire.Edges(flat_wire)
-        vertices = Wire.Vertices(flat_wire)
-        int_angles = Wire.InteriorAngles(flat_wire)
-        bisector_list = []
+        temp_vertices = [Topology.Vertices(wire)[0], Topology.Vertices(wire)[1], Topology.Centroid(wire)]
+        temp_face = Face.ByWire(Wire.ByVertices(temp_vertices, close=True))
+        temp_normal = Face.Normal(temp_face)
+        flat_wire = Topology.Flatten(wire, direction=temp_normal, origin=origin)
+        normal = Face.Normal(temp_face)
+        if normal[2] < 0:
+            wire = Wire.Reverse(wire, transferDictionaries=True)
+        flat_wire = Topology.Flatten(wire, direction=normal, origin=origin)
+        edges = Topology.Edges(flat_wire)
+        offsets = []
+        offset_edges = []
         final_vertices = []
-        for i in range(len(vertices)):
-            v_edges = Topology.SuperTopologies(vertices[i], flat_wire, topologyType="edge")
-            if len(v_edges) < 2:
-                continue
-            bisector = Edge.Bisect(v_edges[0], v_edges[1], length=offset, placement=1)
-            if int_angles[i] > 180:
-                bisector = Topology.TranslateByDirectionDistance(bisector, Vector.Reverse(Edge.Direction(bisector)), distance=abs(offset))
-                bisector = Edge.Reverse(bisector)
-            
-            h = abs(compute_h(180-int_angles[i], abs(offset)))
-            bisector = Edge.SetLength(bisector, length=h, bothSides=False)
-            final_vertices.append(Edge.EndVertex(bisector))        
-            bisector_list.append(bisector)
+        bisectors_list = []
+        for edge in edges:
+            d = Topology.Dictionary(edge)
+            d_offset = Dictionary.ValueAtKey(d, offsetKey)
+            if d_offset == None:
+                d_offset = offset
+            offsets.append(d_offset)
+            offset_edge = Edge.ByOffset2D(edge, d_offset)
+            offset_edges.append(offset_edge)
+        o_edges = []
+        for i in range(len(edges)):
+            edge_a = edges[i]
+            o_edge_a = offset_edges[i]
+            v_a = Edge.StartVertex(edges[i])
+            if i == 0:
+                if Wire.IsClosed(wire) == False:
+                    v1 = Edge.StartVertex(offset_edges[0])
+                    final_vertices.append(v1)
+                    if bisectors == True:
+                        bisectors_list.append(Edge.ByVertices(v_a, v1))
+                else:
+                    prev_edge = offset_edges[-1]
+            else:
+                prev_edge = offset_edges[i-1]
+                v1 = Edge.Intersect2D(prev_edge, o_edge_a, silent=True)
+                if Topology.IsInstance(v1, "Vertex"):
+                    if bisectors == True:
+                        bisectors_list.append(Edge.ByVertices(v_a, v1))
+                    final_vertices.append(v1)
+                else:
+                    connection = Edge.Connection(prev_edge, o_edge_a)
+                    if Topology.IsInstance(connection, "Edge"):
+                        v1_1 = Edge.StartVertex(connection)
+                        v1_2 = Edge.EndVertex(connection)
+                        bisectors_list.append(Edge.ByVertices(v_a, v1_1))
+                        bisectors_list.append(Edge.ByVertices(v_a, v1_2))
+                        final_vertices.append(v1_1)
+                        final_vertices.append(v1_2)
+        if Wire.IsClosed(wire) == False:
+            v_a = Edge.EndVertex(edges[-1])
+            v1 = Edge.EndVertex(offset_edges[-1])
+            final_vertices.append(v1)
+            if bisectors == True:
+                bisectors_list.append(Edge.ByVertices(v_a, v1))
+        else:
+            v1 = Edge.Intersect2D(o_edge_a, offset_edges[0], silent=True)
+            if Topology.IsInstance(v1, "Vertex"):
+                if bisectors == True:
+                    bisectors_list.append(Edge.ByVertices(Edge.StartVertex(edges[0]), v1))
+                final_vertices.append(v1)
+            else:
+                connection = Edge.Connection(offset_edges[0], o_edge_a)
+                if Topology.IsInstance(connection, "Edge"):
+                    v1_1 = Edge.StartVertex(connection)
+                    v1_2 = Edge.EndVertex(connection)
+                    bisectors_list.append(Edge.ByVertices(v_a, v1_1))
+                    bisectors_list.append(Edge.ByVertices(v_a, v1_2))
+                    final_vertices.append(v1_1)
+                    final_vertices.append(v1_2)
+        
         return_wire = Wire.ByVertices(final_vertices, close=Wire.IsClosed(wire))
-        vertices = Topology.Vertices(return_wire)
-        if not Wire.IsClosed(wire):
-            sv = Topology.Vertices(flat_wire)[0]
-            ev = Topology.Vertices(flat_wire)[-1]
-            first_edge = Topology.SuperTopologies(sv, flat_wire, topologyType="edge")[0]
-            first_normal = Edge.NormalAsEdge(first_edge, length=abs(offset), u = 0)
-            last_edge = Topology.SuperTopologies(ev, flat_wire, topologyType="edge")[0]
-            last_normal = Edge.NormalAsEdge(last_edge, length=abs(offset), u = 1.0)
-            sv1 = Edge.EndVertex(first_normal)
-            ev1 = Edge.EndVertex(last_normal)
-            vertices = [sv1] + vertices[1:-1] + [ev1]
-            bisector_list = [first_normal] + bisector_list[1:-1] + [last_normal]
-        return_wire = Wire.ByVertices(vertices, close=Wire.IsClosed(wire))
-        if bisectors:
-            return_wire = Topology.SelfMerge(Cluster.ByTopologies(bisector_list, Topology.Edges(return_wire)))
-        return_wire = Topology.Unflatten(return_wire, origin=origin, direction=normal)
+        if bisectors == True:
+            return_wire = Topology.SelfMerge(Cluster.ByTopologies(bisectors_list+Topology.Edges(return_wire)))
+        if not Topology.IsInstance(return_wire, "Wire"):
+            if not silent:
+                print("Wire.ByOffset - Warning: The resulting wire is not well-formed, please check your offsets.")
+        else:
+            if not Wire.IsManifold(return_wire) and bisectors == False:
+                if not silent:
+                    print("Wire.ByOffset - Warning: The resulting wire is non-manifold, please check your offsets.")
+        return_wire = Topology.Unflatten(return_wire, direction=normal, origin=origin)
         return return_wire
 
     @staticmethod
@@ -1274,7 +1278,7 @@ class Wire(Topology):
         return Cluster.ByTopologies([v for v in Topology.Vertices(wire) if (Vertex.Degree(v, wire, topologyType="edge") == 1)])
     
     @staticmethod
-    def Fillet(wire, radius: float = 0, radiusKey: str = None, tolerance: float = 0.0001, silent: bool = False):
+    def Fillet(wire, radius: float = 0, sides: int = 16, radiusKey: str = None, tolerance: float = 0.0001, silent: bool = False):
         """
         Fillets (rounds) the interior and exterior corners of the input wire given the input radius. See https://en.wikipedia.org/wiki/Fillet_(mechanics)
 
@@ -1286,10 +1290,12 @@ class Wire(Topology):
             The desired radius of the fillet.
         radiusKey : str , optional
             If specified, the dictionary of the vertices will be queried for this key to specify the desired fillet radius. The default is None.
+        sides : int , optional
+            The number of sides (segments) of the fillet. The default is 16.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -1316,7 +1322,6 @@ class Wire(Topology):
         from topologicpy.Edge import Edge
         from topologicpy.Wire import Wire
         from topologicpy.Face import Face
-        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Vector import Vector
         from topologicpy.Dictionary import Dictionary
@@ -1340,7 +1345,6 @@ class Wire(Topology):
         flat_wire = Topology.Flatten(wire, origin=Vertex.Origin(), direction=normal)
         vertices = Topology.Vertices(flat_wire)
         final_vertices = []
-        fillets = []
         for v in vertices:
             radius = orig_radius
             edges = Topology.SuperTopologies(v, flat_wire, topologyType="edge")
@@ -1374,22 +1378,11 @@ class Wire(Topology):
                             v1 = Topology.TranslateByDirectionDistance(v, dir1, a)
                             center = Topology.TranslateByDirectionDistance(v, dir_bisector, h)
                             v2 = Topology.TranslateByDirectionDistance(v, dir2, a)
-                            r1 = Edge.ByVertices(center, v1)
-                            dir1 = Edge.Direction(r1)
-                            r2 = Edge.ByVertices(center, v2)
-                            dir2 = Edge.Direction(r2)
-                            compass1 = Vector.CompassAngle(Vector.East(), dir1)*-1
-                            compass2 = Vector.CompassAngle(Vector.East(), dir2)*-1
-                            if compass2 < compass1:
-                                temp = compass2
-                                compass2 = compass1
-                                compass1 = temp
-                            w1 = Wire.Circle(origin=center, radius=radius, fromAngle=compass1, toAngle=compass2, close=False)
-                            w2 = Wire.Circle(origin=center, radius=radius, fromAngle=compass2, toAngle=compass1, close=False)
-                            if Wire.Length(w1) < Wire.Length(w2):
-                                fillet = w1
-                            else:
-                                fillet = w2
+                            fillet = Wire.Circle(origin=center, radius=radius, close=True)
+                            bisector = Edge.ByVertices(v, center)
+                            mid_vertex = Topology.Slice(bisector, fillet)
+                            mid_vertex = Topology.Vertices(mid_vertex)[1]
+                            fillet = Wire.Arc(v1, mid_vertex, v2, sides=sides, close= False)
                             f_sv = Wire.StartVertex(fillet)
                             if Vertex.Distance(f_sv, edge1) < Vertex.Distance(f_sv, edge0):
                                 fillet = Wire.Reverse(fillet)
@@ -1869,7 +1862,7 @@ class Wire(Topology):
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -2071,7 +2064,7 @@ class Wire(Topology):
         return return_normal
     
     @staticmethod
-    def OrientEdges(wire, vertexA, tolerance=0.0001):
+    def OrientEdges(wire, vertexA, transferDictionaries = False, tolerance=0.0001):
         """
         Returns a correctly oriented head-to-tail version of the input wire. The input wire must be manifold.
 
@@ -2081,6 +2074,8 @@ class Wire(Topology):
             The input wire.
         vertexA : topologic_core.Vertex
             The desired start vertex of the wire.
+        transferDictionaries : bool , optional
+            If set to True, the dictionaries of the original wire are transfered to the new wire. Otherwise, they are not. The default is False.
         tolerance : float, optional
             The desired tolerance. The default is 0.0001.
 
@@ -2092,6 +2087,8 @@ class Wire(Topology):
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(wire, "Wire"):
             print("Wire.OrientEdges - Error: The input wire parameter is not a valid wire. Returning None.")
@@ -2104,6 +2101,15 @@ class Wire(Topology):
             return None
         oriented_edges = []
         remaining_edges = Topology.Edges(wire)
+        original_vertices = Topology.Vertices(wire)
+        if transferDictionaries:
+            edge_selectors = []
+            for i, e_s in enumerate(remaining_edges):
+                s = Topology.Centroid(e_s)
+                d = Topology.Dictionary(e_s)
+                s = Topology.SetDictionary(s, d)
+                edge_selectors.append(s)
+
         current_vertex = vertexA
         while remaining_edges:
             next_edge = None
@@ -2126,7 +2132,12 @@ class Wire(Topology):
         for i, edge in enumerate(oriented_edges):
             vertices.append(Edge.EndVertex(edge))
             
-        return Wire.ByVertices(vertices, close=Wire.IsClosed(wire))
+        return_wire = Wire.ByVertices(vertices, close=Wire.IsClosed(wire))
+        if transferDictionaries:
+            return_wire = Topology.TransferDictionariesBySelectors(return_wire, selectors=edge_selectors, tranEdges=True)
+            return_wire = Topology.TransferDictionariesBySelectors(return_wire, selectors=original_vertices, tranVertices=True)
+        return_wire = Topology.SetDictionary(return_wire, Topology.Dictionary(wire), silent=True)
+        return return_wire
 
     @staticmethod
     def Planarize(wire, origin= None, mantissa: int = 6, tolerance: float = 0.0001):
@@ -2420,7 +2431,7 @@ class Wire(Topology):
             return wire
     
     @staticmethod
-    def Reverse(wire, tolerance: float = 0.0001):
+    def Reverse(wire, transferDictionaries = False, tolerance: float = 0.0001):
         """
         Creates a wire that has the reverse direction of the input wire.
 
@@ -2428,6 +2439,8 @@ class Wire(Topology):
         ----------
         wire : topologic_core.Wire
             The input wire.
+        transferDictionaries : bool , optional
+            If set to True the dictionaries of the input wire are transferred to the new wire. Othwerwise, they are not. The default is False.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -2446,10 +2459,23 @@ class Wire(Topology):
             print("Wire.Reverse - Error: The input wire parameter is not a manifold wire. Returning None.")
             return None
         
+        original_vertices = Topology.Vertices(wire)
+        edges = Topology.Edges(wire)
+        if transferDictionaries:
+            edge_selectors = []
+            for i, e_s in enumerate(edges):
+                s = Topology.Centroid(e_s)
+                d = Topology.Dictionary(e_s)
+                s = Topology.SetDictionary(s, d)
+                edge_selectors.append(s)
         vertices = Topology.Vertices(wire)
         vertices.reverse()
-        new_wire = Wire.ByVertices(vertices, close=Wire.IsClosed(wire), tolerance=tolerance)
-        return new_wire
+        return_wire = Wire.ByVertices(vertices, close=Wire.IsClosed(wire), tolerance=tolerance)
+        if transferDictionaries:
+            return_wire = Topology.TransferDictionariesBySelectors(return_wire, selectors=edge_selectors, tranEdges=True)
+            return_wire = Topology.TransferDictionariesBySelectors(return_wire, selectors=original_vertices, tranVertices=True)
+        return_wire = Topology.SetDictionary(return_wire, Topology.Dictionary(wire), silent=True)
+        return return_wire
 
     @staticmethod
     def Roof(face, angle: float = 45, tolerance: float = 0.001):
@@ -3365,13 +3391,13 @@ class Wire(Topology):
         from topologicpy.Edge import Edge
 
         if not Topology.IsInstance(wire, "Wire"):
-            print("Wire.VertexAtParameter - Error: The input wire parameter is not a valid topologic wire. Returning None.")
+            print("Wire.VertexByParameter - Error: The input wire parameter is not a valid topologic wire. Returning None.")
             return None
         if u < 0 or u > 1:
-            print("Wire.VertexAtParameter - Error: The input u parameter is not within the valid range of [0, 1]. Returning None.")
+            print("Wire.VertexByParameter - Error: The input u parameter is not within the valid range of [0, 1]. Returning None.")
             return None
         if not Wire.IsManifold(wire):
-            print("Wire.VertexAtParameter - Error: The input wire parameter is non-manifold. Returning None.")
+            print("Wire.VertexByParameter - Error: The input wire parameter is non-manifold. Returning None.")
             return None
         
         if u == 0:

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.26'
+__version__ = '0.7.28'

{topologicpy-0.7.26.dist-info → topologicpy-0.7.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.26
+Version: 0.7.28
 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

{topologicpy-0.7.26.dist-info → topologicpy-0.7.28.dist-info}/RECORD

@@ -1,16 +1,16 @@
 topologicpy/ANN.py,sha256=A7k3RZ6rVccLLzJhQMz_5xaDUnLJDgJMQTtnG_Bsc-s,49166
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
-topologicpy/Cell.py,sha256=NjcKAqZywkr7DouYP4MGLhG6grWrXYfEpzDgUN-qAC0,99802
+topologicpy/Cell.py,sha256=c6LeEY6-gMNByIHGC_rb2wm9ogg93VhwYK3zJ8IB78U,99798
 topologicpy/CellComplex.py,sha256=x474N-lo1krpdIGrWRAFRdDup5a_1V-mLORTS6ZGZ7M,48227
-topologicpy/Cluster.py,sha256=mwQVNXnh20VHms0ZqPzTROP8bUdVt8CTKtaNobAqHsE,54993
+topologicpy/Cluster.py,sha256=TZXuxzdaUr6OHSWnjWpjCOMlVj6YHBH8aUVbDVsncVA,54999
 topologicpy/Color.py,sha256=UlmRcCSOhqcM_OyMWz4t3Kr75KcgXDhz3uctAJ2n7Ic,18031
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
 topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
-topologicpy/Dictionary.py,sha256=4VtIT1p4UHWButzRUnajj16V0DY-d5RaENbXLNTbCYU,27097
-topologicpy/Edge.py,sha256=H5UVhdQ9hjBdipx0AL6U8XQXula_1pBajFB_JI_LIak,58409
+topologicpy/Dictionary.py,sha256=KqJ29YyE23Y3Xc6XmKLSCZXRfBvm-OEOxlMZ4dt-rfM,27094
+topologicpy/Edge.py,sha256=vhYHkobSLGSWV-oe2oJFFDobqFToDyb7s71yQ840AAA,65166
 topologicpy/EnergyModel.py,sha256=ni0H1JgvLl1-q90yK9Sm1qj5P1fTuidlimEIcwuj6qE,53287
-topologicpy/Face.py,sha256=gJNOzaTBxMcd71A-FAzQ3sQFKbsL35cpkGzgtNu6tmo,110131
-topologicpy/Graph.py,sha256=rYUhw7XP6LVogbIZfAsrYEZoilN1BabloZHdcWskrMo,391663
+topologicpy/Face.py,sha256=u-DPS5guhzfwxZUuUNYqtPJG6OdeHpY1XQHRSKn6rqk,110148
+topologicpy/Graph.py,sha256=ZU4etwhj6-_JUci3-CK5AoMUoFaTMtVvRWdSHW52SR0,391660
 topologicpy/Grid.py,sha256=Q-2WNBkvIsJks7pbGkzzkRWVB4fTMYgWipG3lcDXbpE,18496
 topologicpy/Helper.py,sha256=mLwJmhyc-d-JqW82MBf7JwM91zWHVx8RzOmndPWHm-k,17717
 topologicpy/Honeybee.py,sha256=vcBECJlgWVjNNdD9ZmjNik_pA1Y_ZNoOorsQb2CiyGA,21965
@@ -18,17 +18,17 @@ topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=Gy2PS4Ky8BNhohKreoV4zgzW9OXCjhSwiZF_Aq21_wU,19589
 topologicpy/Plotly.py,sha256=iJ7zCoe2V1PqGH7GzTTvSfCXY5aRCG0fdYf4Sh6igZ8,98844
 topologicpy/Polyskel.py,sha256=4R5_DEdfrmi-4gR6axHNoHTCSAE2TCekOyN8jvb7bHQ,19722
-topologicpy/Shell.py,sha256=szuwRbQeHH9jd2X-DA9UhYAL_mzgfr_ctGrrQL2reWg,79917
+topologicpy/Shell.py,sha256=n91gViexVMcH3Iors6xeC_Wnn38E40KLqKq5MXQiDU4,79912
 topologicpy/Speckle.py,sha256=rUS6PCaxIjEF5_fUruxvMH47FMKg-ohcoU0qAUb-yNM,14267
 topologicpy/Sun.py,sha256=_gZfVyH0SDLQmmt775UeeAJ_BtwXO1STQnUMV1qkU0s,37161
-topologicpy/Topology.py,sha256=PkuCetAUADmEuu17-R19ACoub7iZijA8S_v3t0YLL3s,361467
+topologicpy/Topology.py,sha256=Z-zddTGL_wkQmhrkXlredpQxx7Myd4Xp-yNw2d95iks,361647
 topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
-topologicpy/Vertex.py,sha256=deOrCOvvGJYAludUE4Tm_L4Bx0ykQzO_ddnYSrUzsBs,71157
-topologicpy/Wire.py,sha256=_-0s6lFCStTGEjK5M-_w79UCQoPVFH1Ou8PdH_urvT0,145180
+topologicpy/Vertex.py,sha256=xnCoPG7BTKBG-JU3C0e11KcpDJbDt9t1Ahj4f5Ul13I,71151
+topologicpy/Wire.py,sha256=mxwx6170ylBnSP2CRAuUZ6xWtISR-frAG5QAVMtS_ZE,147316
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=mExVIZTppRZKivnNYLkY3fXqANuLsLtYbD1gMqdgaXM,23
-topologicpy-0.7.26.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.26.dist-info/METADATA,sha256=s84QUjxqFTjnzTZGzBs-L1GzOLxH63nzrUVVx7DrC2I,10916
-topologicpy-0.7.26.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-topologicpy-0.7.26.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.26.dist-info/RECORD,,
+topologicpy/version.py,sha256=wuEtkjyrjapFyP-8kysuud97ywxtz0wWW7TfbCk_q1g,23
+topologicpy-0.7.28.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
+topologicpy-0.7.28.dist-info/METADATA,sha256=5Q_QWybjO0mzQG8ikrtZ6g9s2IQ3n1-0l4at8o8yJeI,10916
+topologicpy-0.7.28.dist-info/WHEEL,sha256=rWxmBtp7hEUqVLOnTaDOPpR-cZpCDkzhhcBce-Zyd5k,91
+topologicpy-0.7.28.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.28.dist-info/RECORD,,

{topologicpy-0.7.26.dist-info → topologicpy-0.7.28.dist-info}/WHEEL

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