topologicpy 0.8.40__py3-none-any.whl → 0.8.42__py3-none-any.whl

topologicpy/Cell.py

@@ -2762,7 +2762,7 @@ class Cell():
         return prism
 
     @staticmethod
-    def RemoveCollinearEdges(cell, angTolerance: float = 0.1, tolerance: float = 0.0001):
+    def RemoveCollinearEdges(cell, angTolerance: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
         Removes any collinear edges in the input cell.
 
@@ -2774,6 +2774,8 @@ class Cell():
             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, error and warning messages are suppressed. The default is False.
 
         Returns
         -------
@@ -2786,15 +2788,16 @@ class Cell():
         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])
+            if not silent:
+                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 = []
         for face in faces:
-            clean_faces.append(Face.RemoveCollinearEdges(face, angTolerance=angTolerance, tolerance=tolerance))
+            clean_faces.append(Face.RemoveCollinearEdges(face, angTolerance=angTolerance, tolerance=tolerance, silent=silent))
         return Cell.ByFaces(clean_faces, tolerance=tolerance)
     
     @staticmethod

topologicpy/CellComplex.py

@@ -104,7 +104,7 @@ class CellComplex():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
-                If set to True, error and warning messages are suppressed. The default is False.
+            If set to True, error and warning messages are suppressed. The default is False.
 
         Returns
         -------
@@ -990,7 +990,7 @@ class CellComplex():
             return None
 
     @staticmethod
-    def RemoveCollinearEdges(cellComplex, angTolerance: float = 0.1, tolerance: float = 0.0001):
+    def RemoveCollinearEdges(cellComplex, angTolerance: float = 0.1, tolerance: float = 0.0001, silent: bool = True):
         """
         Removes any collinear edges in the input cellComplex.
 
@@ -1002,6 +1002,8 @@ class CellComplex():
             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, error and warning messages are suppressed. The default is False.
 
         Returns
         -------
@@ -1023,7 +1025,7 @@ class CellComplex():
         cells = CellComplex.Cells(cellComplex)
         clean_cells = []
         for cell in cells:
-            clean_cells.append(Cell.RemoveCollinearEdges(cell, angTolerance=angTolerance, tolerance=tolerance))
+            clean_cells.append(Cell.RemoveCollinearEdges(cell, angTolerance=angTolerance, tolerance=tolerance, silent=silent))
         return CellComplex.ByCells(clean_cells, tolerance=tolerance)
     
     @staticmethod
@@ -1098,6 +1100,8 @@ class CellComplex():
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. The default is False.
         
         Returns
         -------

topologicpy/Edge.py

@@ -256,31 +256,63 @@ class Edge():
     @staticmethod
     def ByOffset2D(edge, offset: float = 1.0, tolerance: float = 0.0001):
         """
-        Creates and edge offset from the input edge. This method is intended for edges that are in the XY plane.
-
-        Parameters
-        ----------
-        edge : topologic_core.Edge
-            The input edge.
-        offset : float , optional
-            The desired offset. The default is 1.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
-
-        Returns
-        -------
-        topologic_core.Edge
-            An edge offset from the input edge.
-
+        Creates an edge offset from the input edge in the XY plane.
         """
         from topologicpy.Topology import Topology
-        from topologicpy.Vector import Vector
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
 
-        n = Edge.Normal(edge)
-        n = Vector.Normalize(n)
-        n = Vector.Multiply(n, offset, tolerance=tolerance)
-        edge = Topology.Translate(edge, n[0], n[1], n[2])
-        return edge
+        sv = Edge.StartVertex(edge)
+        ev = Edge.EndVertex(edge)
+
+        x1, y1, _ = Vertex.Coordinates(sv)
+        x2, y2, _ = Vertex.Coordinates(ev)
+
+        dx = x2 - x1
+        dy = y2 - y1
+        length = (dx**2 + dy**2)**0.5
+        if length < tolerance:
+            return None
+
+        # Perpendicular vector to the left
+        nx = -dy / length
+        ny = dx / length
+
+        ox = nx * offset
+        oy = ny * offset
+
+        new_sv = Vertex.ByCoordinates(x1 + ox, y1 + oy, 0)
+        new_ev = Vertex.ByCoordinates(x2 + ox, y2 + oy, 0)
+
+        return Edge.ByVertices(new_sv, new_ev)
+    # @staticmethod
+    # def ByOffset2D(edge, offset: float = 1.0, tolerance: float = 0.0001):
+    #     """
+    #     Creates and edge offset from the input edge. This method is intended for edges that are in the XY plane.
+
+    #     Parameters
+    #     ----------
+    #     edge : topologic_core.Edge
+    #         The input edge.
+    #     offset : float , optional
+    #         The desired offset. The default is 1.
+    #     tolerance : float , optional
+    #         The desired tolerance. The default is 0.0001.
+
+    #     Returns
+    #     -------
+    #     topologic_core.Edge
+    #         An edge offset from the input edge.
+
+    #     """
+    #     from topologicpy.Topology import Topology
+    #     from topologicpy.Vector import Vector
+
+    #     n = Edge.Normal(edge)
+    #     n = Vector.Normalize(n)
+    #     n = Vector.Multiply(n, offset, tolerance=tolerance)
+    #     edge = Topology.Translate(edge, n[0], n[1], n[2])
+    #     return edge
 
     @staticmethod
     def ByStartVertexEndVertex(vertexA, vertexB, tolerance: float = 0.0001, silent=False):

topologicpy/Face.py

@@ -827,7 +827,7 @@ class Face():
         return Face.ByVertices(vertices, tolerance=tolerance)
 
     @staticmethod
-    def ByWire(wire, tolerance: float = 0.0001, silent=False):
+    def ByWire(wire, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a face from the input closed wire.
 
@@ -942,14 +942,21 @@ class Face():
         """
         from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
+        import inspect
 
         if not Topology.IsInstance(externalBoundary, "Wire"):
             if not silent:
                 print("Face.ByWires - Error: The input externalBoundary parameter is not a valid topologic wire. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         if not Wire.IsClosed(externalBoundary):
             if not silent:
                 print("Face.ByWires - Error: The input externalBoundary parameter is not a closed topologic wire. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         ibList = [x for x in internalBoundaries if Topology.IsInstance(x, "Wire") and Wire.IsClosed(x)]
         face = None
@@ -958,6 +965,9 @@ class Face():
         except:
             if not silent:
                 print("Face.ByWires - Error: The operation failed. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             face = None
         return face
 
@@ -3404,7 +3414,7 @@ class Face():
             return None
         eb = Wire.RemoveCollinearEdges(Face.Wire(face), angTolerance=angTolerance, tolerance=tolerance, silent=silent)
         ib = [Wire.RemoveCollinearEdges(w, angTolerance=angTolerance, tolerance=tolerance, silent=silent) for w in Face.InternalBoundaries(face)]
-        return Face.ByWires(eb, ib)
+        return Face.ByWires(eb, ib, silent=silent)
     
     @staticmethod
     def RHS(origin= None, width: float = 1.0, length: float = 1.0, thickness: float = 0.25, outerFillet: float = 0.0, innerFillet: float = 0.0, sides: int = 16, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001, silent: bool = False):
@@ -3602,35 +3612,51 @@ class Face():
         return Face.RHS(origin = origin, width = size, length = size, thickness = thickness, outerFillet = outerFillet, innerFillet = innerFillet, sides = sides, direction = direction, placement = placement, tolerance = tolerance, silent = silent)
     
     @staticmethod
-    def Simplify(face, tolerance=0.0001):
+    def Simplify(face, method='douglas-peucker', tolerance=0.0001, silent=False):
         """
-        Simplifies the input face edges based on the Douglas Peucker algorthim. See https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm
-        Part of this code was contributed by gaoxipeng. See https://github.com/wassimj/topologicpy/issues/35
+        Simplifies the input wire edges based on the selected algorithm: Douglas-Peucker or Visvalingam–Whyatt.
         
         Parameters
         ----------
         face : topologic_core.Face
             The input face.
+        method : str, optional
+            The simplification method to use: 'douglas-peucker' or 'visvalingam-whyatt' or 'reumann-witkam'.
+            The default is 'douglas-peucker'.
         tolerance : float , optional
-            The desired tolerance. The default is 0.0001. Edges shorter than this length will be removed.
-
+            The desired tolerance.
+            If using the douglas-peucker method, edge lengths shorter than this amount will be removed.
+            If using the visvalingam-whyatt method, triangulare areas less than is amount will be removed.
+            If using the Reumann-Witkam method, the tolerance specifies the maximum perpendicular distance allowed
+            between any point and the current line segment; points falling within this distance are discarded.
+            The default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. The default is False.
+            
         Returns
         -------
         topologic_core.Face
             The simplified face.
+        
         """
         from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(face, "Face"):
-            print("Face.Simplify - Error: The input face parameter is not a valid face. Returning None.")
+            if not silent:
+                print("Face.Simplify - Error: The input face parameter is not a valid face. Returning None.")
             return None
         
         eb = Face.ExternalBoundary(face)
-        eb = Wire.Simplify(eb, tolerance=tolerance)
+        eb = Wire.Simplify(eb, method=method, tolerance=tolerance, silent=silent)
         ibList = Face.InternalBoundaries(face)
-        ibList = [Wire.Simplify(ib) for ib in ibList]
-        return Face.ByWires(eb, ibList)
+        ibList = [Wire.Simplify(ib, method=method, tolerance=tolerance, silent=silent) for ib in ibList]
+        return_face = Face.ByWires(eb, ibList, tolerance=tolerance, silent=silent)
+        if not Topology.IsInstance(return_face, "Face"):
+            if not silent:
+                print("Face.Simplify - Error: Could not simplify the face. Returning the original input face.")
+            return face
+        return return_face
     
     @staticmethod
     def Skeleton(face, boundary: bool = True, tolerance: float = 0.001):

topologicpy/Graph.py

@@ -7751,6 +7751,34 @@ class Graph:
                 edge = Topology.SetDictionary(edge, d)
         return graph
 
+    @staticmethod
+    def IsEmpty(graph, silent: bool = False):
+        """
+        Tests if the input graph is empty (Has no vertices).
+        
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. The default is False.
+        
+        Returns
+        -------
+        bool
+            True if the two input graphs are isomorphic. False otherwise
+
+        """
+        
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.IsEmpty - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        
+        return (len(Graph.Vertices(graph)) == 0)
+    
     @staticmethod
     def IsIsomorphic(graphA, graphB, maxIterations=10, silent=False):
         """
@@ -9192,6 +9220,142 @@ class Graph:
             return None
         return graph.GetGUID()
 
+    @staticmethod
+    def HasseDiagram(topology, types=["vertex", "edge", "wire", "face", "shell", "cell", "cellComplex"], topDown: bool = False, minDistance: float=0.1, vertexLabelKey: str="label", vertexTypeKey: str="type", vertexColorKey: str="color", colorScale: str="viridis", storeBREP: bool = False, tolerance: float=0.0001, silent: bool=False):
+        """
+            Constructs a Hasse diagram from the input topology as a directed graph. See: https://en.wikipedia.org/wiki/Hasse_diagram
+            Vertices represent topologies (vertices, edges, wires, faces, shells, cells, cellComplexes).
+            Edges represent inclusion (e.g. vertex ⊂ edge, edge ⊂ wire).
+
+            Parameters
+            ----------
+            topology : topologic_core.Topology
+                The input topology
+            types : optional, list
+                The list of topology types that you wish to encode in the Hasse diagram.
+                This list must be ordered according to topologic_core's class hierarchy.
+                If you are not interested in representing some topology types. These can be omitted.
+                The default is:
+                ["vertex", "edge", "wire", "face", "shell", "cell", "cellComplex"].
+            topDown : bool , optional
+                If set to True, the graph edges are directed from topologies to their subtopologies.
+                Otherwise, they are directed from topologies to their supertopologies. The default is False. 
+            minDistance : float , optional
+                The desired minimum distance between the vertices of the graph. The default is 0.1.
+            vertexLabelKey: str , optional
+                The desired vertex dictionary key under which to store a unique label (of the form Type_Index). The default is "label".
+            vertexTypeKey: str , optional
+                The desired vertex dictionary key under which to store the topology type (e.g. "vertex", "edge", "wire"). The default is "type".
+            vertexColorKey: str , optional
+                The desired vertex dictionary key under which to store the topology color. The default is "color".
+            colorScale : str , optional
+                The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+                In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
+            storeBREP : bool , optional
+                If set to True, store the BRep of the topology in its representative vertex. The default is False.
+            tolerance : float
+                The desired tolerance. The default is 0.0001.
+            silent : bool , optional
+                    If set to True, error and warning messages are suppressed. The default is False.
+
+            Returns
+            -------
+            topologic_core.Graph
+                The created Hesse diagram graph.
+
+            """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Color import Color
+        from topologicpy.Topology import Topology
+
+        def label(topo, index):
+            cls = Topology.TypeAsString(topo)
+            return f"{cls}_{index}"
+        
+        def collect_topologies(topology, topo_types):
+            """
+            Returns a dict of all sub-topologies by dimension.
+            """
+            topo_by_type = {}
+            for sub_type in topo_types:
+                topo_by_type[sub_type] = Topology.SubTopologies(topology, subTopologyType=sub_type)
+            return topo_by_type
+        
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Graph.HasseDiagram - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        if minDistance <= tolerance:
+            if not silent:
+                print("Graph.HasseDiagram - Error: The input minDistance parameter cannot be less than the input tolerance parameter. Returning None.")
+            return None
+        types = [t.lower() for t in types]
+        for type in types:
+            if type not in ["vertex", "edge", "wire", "face", "shell", "cell", "cellcomplex"]:
+                if not silent:
+                    print("Graph.HasseDiagram - Error: Unknown type found in the types input parameter. Returning None.")
+                return None
+
+        topology_type = Topology.TypeAsString(topology).lower()
+        try:
+            sub_types = types[:types.index(topology_type)]
+        except:
+            sub_types = types
+        topo_by_type = collect_topologies(topology, sub_types)
+        all_topos = []
+        topo_ids = {}
+        index = 0
+
+        # Flatten and assign unique labels
+        for sub_type in sub_types:
+            color = Color.AnyToHex(Color.ByValueInRange(float(types.index(sub_type)), minValue=0, maxValue=6, colorScale=colorScale))
+            lbl_index = 1
+            for t in topo_by_type[sub_type]:
+                lbl = label(t, lbl_index)
+                d = Topology.Dictionary(t)
+                d = Dictionary.SetValuesAtKeys(d, [vertexLabelKey, vertexTypeKey, vertexColorKey], [lbl, sub_type, color])
+                t = Topology.SetDictionary(t, d)
+                all_topos.append(t)
+                topo_ids[lbl] = index
+                index += 1
+                lbl_index += 1
+
+        # Create graph vertices
+        graph_vertices = [Topology.Centroid(_) for _ in all_topos]
+
+        # Add dictionaries to each vertex
+        for i, t in enumerate(all_topos):
+            d = Topology.Dictionary(t)
+            if storeBREP == True:
+                d = Dictionary.SetValueAtKey(d,"brep", Topology.BREPString(t))
+            graph_vertices[i] = Topology.SetDictionary(graph_vertices[i], d)
+        
+        graph_vertices = Vertex.Separate(graph_vertices, minDistance= minDistance, tolerance=tolerance)
+        # Build edges of Hasse diagram
+        graph_edges = []
+        for parent_type in sub_types[1:]:
+            for parent in topo_by_type[parent_type]:
+                parent_label = Dictionary.ValueAtKey(Topology.Dictionary(parent), vertexLabelKey)
+                children = Topology.SubTopologies(parent, subTopologyType=types[types.index(parent_type) - 1])
+                for child in children:
+                    child_label = Dictionary.ValueAtKey(Topology.Dictionary(child), vertexLabelKey)
+                    child_id = topo_ids.get(child_label)
+                    parent_id = topo_ids.get(parent_label)
+                    if child_id is not None and parent_id is not None:
+                        if topDown:
+                            sv = graph_vertices[parent_id]
+                            ev = graph_vertices[child_id]
+                        else:
+                            sv = graph_vertices[child_id]
+                            ev = graph_vertices[parent_id]
+                        graph_edges.append(Edge.ByVertices(sv, ev, tolerance=tolerance, silent=silent))
+
+        return_graph = Graph.ByVerticesEdges(graph_vertices, graph_edges)
+        return_graph = Graph.SetDictionary(return_graph, Topology.Dictionary(topology))
+        return return_graph
+
     @staticmethod
     def IncomingEdges(graph, vertex, directed: bool = False, tolerance: float = 0.0001) -> list:
         """

topologicpy/Plotly.py

@@ -277,6 +277,9 @@ class Plotly:
                     absolute: bool = False,
                     sides: int = 8,
                     angle: float = 0,
+                    directed: bool = False,
+                    arrowSize: int = 0.1,
+                    arrowSizeKey: str = None,
                     vertexColor: str = "black",
                     vertexColorKey: str = None,
                     vertexSize: float = 10,
@@ -330,6 +333,12 @@ class Plotly:
             For example, if the length of the edge is 10, the sagitta is set to 0.5, and absolute is set to False, the sagitta length will be 5. The default is True.
         sides : int , optional
             The number of sides of the arc. The default is 8.
+        directed : bool , optional
+            If set to True, arrowheads are drawn to show direction. The default is False.
+        arrowSize : int, optional
+            The desired size of arrowheads for directed graphs. The default is 0.1.
+        arrowSizeKey: str , optional
+            The edge dictionary key under which to find the arrowhead size. The default is None.
         vertexColor : str , optional
             The desired color of the output vertices. This can be any plotly color string and may be specified as:
             - A hex string (e.g. '#ff0000')
@@ -479,7 +488,7 @@ class Plotly:
                 geo = Topology.Geometry(e_cluster, mantissa=mantissa)
                 vertices = geo['vertices']
                 edges = geo['edges']
-                data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, dash=edgeDash, dashKey=edgeDashKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))        
+                data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, dash=edgeDash, dashKey=edgeDashKey, directed=directed, arrowSize=arrowSize, arrowSizeKey=arrowSizeKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))        
         return data
     
     @staticmethod
@@ -638,11 +647,60 @@ class Plotly:
         return return_value
 
     @staticmethod
-    def edgeData(vertices, edges, dictionaries=None, color="black", colorKey=None, width=1, widthKey=None, dash=False, dashKey=None, labelKey=None, showEdgeLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
+    def edgeData(vertices, edges, dictionaries=None, color="black", colorKey=None, width=1, widthKey=None, dash=False, dashKey=None, directed=False, arrowSize=0.1, arrowSizeKey=None, labelKey=None, showEdgeLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
     
         from topologicpy.Color import Color
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Helper import Helper
+
+        def create_arrowheads(x, y, z, arrowSize=4):
+            import plotly.graph_objects as go
+            import numpy as np
+
+            arrow_traces = []
+
+            # Compute segment directions
+            cone_x, cone_y, cone_z = [], [], []
+            cone_u, cone_v, cone_w = [], [], []
+
+            for i in range(len(x) - 1):
+                if x[i] == None or x[i+1] == None:
+                    continue
+                u = x[i+1] - x[i]
+                v = y[i+1] - y[i]
+                w = z[i+1] - z[i]
+
+                norm = np.linalg.norm([u, v, w])
+                if norm > 0:
+                    u /= norm
+                    v /= norm
+                    w /= norm
+                    cone_x.append(x[i+1])
+                    cone_y.append(y[i+1])
+                    cone_z.append(z[i+1])
+                    cone_u.append(u)
+                    cone_v.append(v)
+                    cone_w.append(w)
+
+            cone_trace = go.Cone(
+                x=cone_x,
+                y=cone_y,
+                z=cone_z,
+                u=cone_u,
+                v=cone_v,
+                w=cone_w,
+                sizemode="raw",
+                sizeref=arrowSize,
+                showscale=False,
+                colorscale=[[0, color], [1, color]],
+                anchor="tip",
+                name="",  # Hide legend
+                hoverinfo="skip",
+                showlegend=False
+            )
+            arrow_traces.append(cone_trace)
+
+            return arrow_traces
         traces = []
         x = []
         y = []
@@ -676,8 +734,8 @@ class Plotly:
             maxGroup = 1
         
 
-        if colorKey or widthKey or labelKey or groupKey or dashKey:
-            keys = [x for x in [colorKey, widthKey, labelKey, groupKey, dashKey] if not x == None]
+        if colorKey or widthKey or labelKey or groupKey or dashKey or arrowSizeKey:
+            keys = [x for x in [colorKey, widthKey, labelKey, groupKey, dashKey, arrowSizeKey] if not x == None]
             temp_dict = Helper.ClusterByKeys(edges, dictionaries, keys, silent=False)
             dict_clusters = temp_dict["dictionaries"]
             elements_clusters = temp_dict['elements']
@@ -685,13 +743,16 @@ class Plotly:
             labels = []
             for j, elements_cluster in enumerate(elements_clusters):
                 d_color = color
+                d_arrowSize = arrowSize
+                d_dash = dash
                 d = dict_clusters[j][0] # All dicitonaries have same values in dictionaries, so take first one.
                 if d:
                     if not colorKey == None:
-                        d_color = Dictionary.ValueAtKey(d, key=colorKey) or color
-                        d_color = Color.AnyToHex(d_color)
+                        d_color = Color.AnyToHex(Dictionary.ValueAtKey(d, key=colorKey, default=color))
                     if not dashKey == None:
-                        d_dash = Dictionary.ValueAtKey(d, key=dashKey) or dash
+                        d_dash = Dictionary.ValueAtKey(d, key=dashKey, default=dash)
+                    if not arrowSizeKey == None:
+                        d_arrowSize = Dictionary.ValueAtKey(d, key=arrowSizeKey, default=arrowSize)
                     if not labelKey == None:
                         labels.append(str(Dictionary.ValueAtKey(d, labelKey, "")))
                     if not widthKey == None:
@@ -727,7 +788,7 @@ class Plotly:
                     marker_width = width[0]*0.25
                 else:
                     marker_width = width*0.25
-                if dash:
+                if d_dash:
                     dot = "dot"
                 else:
                     dot = "solid"
@@ -744,6 +805,9 @@ class Plotly:
                                     text=labels,
                                     hoverinfo='text',
                                     hovertext=labels)
+                if directed:
+                    arrow_traces = create_arrowheads(x, y, z, arrowSize=d_arrowSize)
+                    traces += arrow_traces
                 traces.append(trace)
         else:
             x = []
@@ -775,6 +839,9 @@ class Plotly:
                                 legendrank=legendRank,
                                 text=label,
                                 hoverinfo='text')
+            if directed:
+                arrow_traces = create_arrowheads(x, y, z, arrowSize=arrowSize)
+                traces += arrow_traces
             traces.append(trace)
         return traces
 
@@ -799,6 +866,9 @@ class Plotly:
                        vertexLegendLabel="Topology Vertices",
                        vertexLegendRank=1,
                        vertexLegendGroup=1,
+                       directed=False,
+                       arrowSize=0.1,
+                       arrowSizeKey=None,
                        showEdges=True,
                        edgeWidth=1,
                        edgeWidthKey=None,
@@ -884,7 +954,12 @@ class Plotly:
             The legend rank order of the vertices of this topology. The default is 1.
         vertexLegendGroup : int , optional
             The number of the vertex legend group to which the vertices of this topology belong. The default is 1.
-        
+        directed : bool , optional
+            If set to True, arrowheads are drawn to show direction. The default is False.
+        arrowSize : int, optional
+            The desired size of arrowheads for directed graphs. The default is 0.1.
+        arrowSizeKey: str , optional
+            The edge dictionary key under which to find the arrowhead size. The default is None.
         showEdges : bool , optional
             If set to True the edges will be drawn. Otherwise, they will not be drawn. The default is True.
         edgeWidth : float , optional
@@ -1194,7 +1269,7 @@ class Plotly:
                 vertices = geo['vertices']
                 edges = geo['edges']
                 if len(edges) > 0:
-                    data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
+                    data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, directed=directed, arrowSize=arrowSize, arrowSizeKey=arrowSizeKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
         
         if showFaces and Topology.Type(topology) >= Topology.TypeID("Face"):
             if not faceColorKey == None:

topologicpy/Topology.py

@@ -6992,16 +6992,16 @@ class Topology():
             return_topology = Wire.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance, silent=silent)
             return return_topology
         elif Topology.IsInstance(topology, "Face"):
-            return_topology = Face.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance)
+            return_topology = Face.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance, silent=silent)
             return return_topology
         elif Topology.IsInstance(topology, "Shell"):
-            return_topology = Shell.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance)
+            return_topology = Shell.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance, silent=silent)
             return return_topology
         elif Topology.IsInstance(topology, "Cell"):
-            return_topology = Cell.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance)
+            return_topology = Cell.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance, silent=silent)
             return return_topology
         elif Topology.IsInstance(topology, "CellComplex"):
-            return_topology = CellComplex.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance)
+            return_topology = CellComplex.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance, silent=silent)
             return return_topology
         elif Topology.IsInstance(topology, "Cluster"):
             topologies = []
@@ -7009,7 +7009,7 @@ class Topology():
             topologies += Cluster.FreeEdges(topology)
             faces = Topology.Faces(topology)
             for face in faces:
-                topologies.append(Face.RemoveCollinearEdges(face, angTolerance=angTolerance, tolerance=tolerance))
+                topologies.append(Face.RemoveCollinearEdges(face, angTolerance=angTolerance, tolerance=tolerance, silent=silent))
             return_topology = Topology.SelfMerge(Cluster.ByTopologies(topologies), tolerance=tolerance)
         return return_topology
 
@@ -8162,7 +8162,10 @@ class Topology():
              vertexMaxGroup=None, 
              showVertexLegend=False,
              vertexLegendLabel="Vertices",
-
+             
+             directed=False,
+             arrowSize=0.1,
+             arrowSizeKey=None,
              showEdges=True,
              edgeWidth=None,
              edgeWidthKey=None,
@@ -8281,7 +8284,12 @@ class Topology():
             If set to True, the legend for the vertices of this topology is shown. Otherwise, it isn't. The default is False.
         vertexLegendLabel : str , optional
             The legend label string used to identify vertices. The default is "Topology Vertices".
-        
+        directed : bool , optional
+            If set to True, arrowheads are drawn to show direction. The default is False.
+        arrowSize : int, optional
+            The desired size of arrowheads for directed graphs. The default is 0.1.
+        arrowSizeKey: str , optional
+            The edge dictionary key under which to find the arrowhead size. The default is None.
         showEdges : bool , optional
             If set to True the edges will be drawn. Otherwise, they will not be drawn. The default is True.
         edgeWidth : float , optional
@@ -8470,6 +8478,9 @@ class Topology():
                                            absolute=absolute,
                                            sides=sides,
                                            angle=angle,
+                                           directed=directed,
+                                           arrowSize=arrowSize,
+                                           arrowSizeKey=arrowSizeKey,
                                            vertexColor=vertexColor,
                                            vertexColorKey=vertexColorKey,
                                            vertexSize=vSize,
@@ -8543,6 +8554,9 @@ class Topology():
                                               vertexLegendLabel=str(i+1)+": "+name+" ("+vertexLegendLabel+")",
                                               vertexLegendRank=topology_counter+1,
                                               vertexLegendGroup=topology_counter+1,
+                                              directed=directed,
+                                              arrowSize=arrowSize,
+                                              arrowSizeKey=arrowSizeKey,
                                               showEdges=showEdges,
                                               edgeWidth=eWidth,
                                               edgeWidthKey=edgeWidthKey,

topologicpy/Vertex.py

@@ -1819,7 +1819,7 @@ class Vertex():
         return Vertex.ByCoordinates(pt[0], pt[1], pt[2])
 
     @staticmethod
-    def Separate(*vertices, minDistance: float = 0.0001, silent: bool = False):
+    def Separate(*vertices, minDistance: float = 0.0001, iterations: int = 100, strength: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
         Separates the input vertices such that no two vertices are within the input minimum distance.
 
@@ -1829,6 +1829,12 @@ class Vertex():
             One or more instances of a topologic vertex to be processed.
         minDistance : float , optional
             The desired minimum distance. The default is 0.0001.
+        iterations : int
+            The number of iterations to run the repulsion simulation. The default is 100.
+        strength : float
+            The force multiplier controlling how strongly vertices repel each other. The default is 0.1.
+        tolerance : float
+            The desired tolerance. The default is 0.0001.
         silent : bool , optional
                 If set to True, error and warning messages are suppressed. The default is False.
 
@@ -1840,10 +1846,7 @@ class Vertex():
         """
         from topologicpy.Topology import Topology
         from topologicpy.Helper import Helper
-        from topologicpy.Dictionary import Dictionary
-        from math import sqrt
-        from scipy.spatial import KDTree
-        import numpy as np
+        import math
 
         if len(vertices) == 0:
             if not silent:
@@ -1873,33 +1876,37 @@ class Vertex():
             if not silent:
                 print("Vertex.Separate - Error: The input parameters do not contain any valid vertices. Returning None.")
             return None
-    
-        coords = np.array([[v.X(), v.Y(), v.Z()] for v in vertexList])  # Extract coordinates
-        tree = KDTree(coords)  # Build k-d tree for efficient neighbor search
+
+        minDistance = minDistance + tolerance # Add a bit of a safety factor
+
+        # Convert to mutable coordinates
+        coords = [[v.X(), v.Y(), v.Z()] for v in vertices]
+        
+        for _ in range(iterations):
+            for i in range(len(coords)):
+                for j in range(i + 1, len(coords)):
+                    dx = coords[j][0] - coords[i][0]
+                    dy = coords[j][1] - coords[i][1]
+                    dz = coords[j][2] - coords[i][2]
+                    dist = math.sqrt(dx*dx + dy*dy + dz*dz)
+                    
+                    if dist < minDistance and dist > 1e-9:
+                        # Calculate repulsion vector
+                        repel = (minDistance - dist) / dist * strength
+                        shift = [dx * repel * 0.5, dy * repel * 0.5, dz * repel * 0.5]
+                        coords[i][0] -= shift[0]
+                        coords[i][1] -= shift[1]
+                        coords[i][2] -= shift[2]
+                        coords[j][0] += shift[0]
+                        coords[j][1] += shift[1]
+                        coords[j][2] += shift[2]
         
-        for i, vertex in enumerate(coords):
-            neighbors = tree.query_ball_point(vertex, minDistance)
-            for neighbor_index in neighbors:
-                if neighbor_index != i:  # Avoid self-comparison
-                    direction = coords[neighbor_index] - vertex
-                    distance = np.linalg.norm(direction)
-                    if distance < minDistance:
-                        # Move current vertex away from its neighbor
-                        adjustment = (minDistance - distance) / 2
-                        unit_vector = direction / distance if distance != 0 else np.random.rand(3)
-                        coords[i] -= unit_vector * adjustment
-                        coords[neighbor_index] += unit_vector * adjustment
-
-            # Rebuild the k-d tree after adjustment
-            tree = KDTree(coords)
-
-        # Convert adjusted coordinates back to Vertex objects
-        separated_vertices = [Vertex.ByCoordinates(x, y, z) for x, y, z in coords]
-        for i, vertex in enumerate(vertexList):
-            d = Topology.Dictionary(vertex)
-            if len(Dictionary.Keys(d)) > 0:
-                separated_vertices[i] = Topology.SetDictionary(separated_vertices[i], d)
-        return separated_vertices
+        # Reconstruct TopologicPy Vertex objects
+        new_vertices = [Vertex.ByCoordinates(x, y, z) for x, y, z in coords]
+        # Transfer the dictionaries
+        for i, v in enumerate(new_vertices):
+            v = Topology.SetDictionary(v, Topology.Dictionary(vertices[i]))
+        return new_vertices
 
     @staticmethod
     def Transform(vertex, matrix, mantissa: int = 6, silent: bool = False):

topologicpy/Wire.py

@@ -465,15 +465,13 @@ class Wire():
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Vector import Vector
-        from topologicpy.Helper import Helper
+        from topologicpy.Helper import Helper        
 
         if not Topology.IsInstance(wire, "Wire"):
             if not silent:
                 print("Wire.ByOffset - Error: The input wire parameter is not a valid wire. Returning None.")
                 return None
         
-        #temp_face = Face.ByWire(wire)
-        #original_area = Face.Area(temp_face)
         if reverse == True:
             fac = -1
         else:
@@ -481,13 +479,10 @@ class Wire():
         origin = Topology.Centroid(wire)
         temp_vertices = [Topology.Vertices(wire)[0], Topology.Vertices(wire)[1], Topology.Centroid(wire)]
         temp_face = Face.ByWire(Wire.ByVertices(temp_vertices, close=True, tolerance=tolerance), silent=silent)
-        temp_normal = Face.Normal(temp_face)
-        flat_wire = Topology.Flatten(wire, direction=temp_normal, origin=origin)
         normal = Face.Normal(temp_face)
         flat_wire = Topology.Flatten(wire, direction=normal, origin=origin)
         original_edges = Topology.Edges(wire)
         edges = Topology.Edges(flat_wire)
-        original_edges = Topology.Edges(wire)
         offsets = []
         offset_edges = []
         final_vertices = []
@@ -495,9 +490,7 @@ class Wire():
         edge_dictionaries = []
         for i, edge in enumerate(edges):
             d = Topology.Dictionary(original_edges[i])
-            d_offset = Dictionary.ValueAtKey(d, offsetKey)
-            if d_offset == None:
-                d_offset = offset
+            d_offset = Dictionary.ValueAtKey(d, key=offsetKey, defaultValue=offset)
             d_offset = d_offset*fac
             offsets.append(d_offset)
             offset_edge = Edge.ByOffset2D(edge, d_offset)
@@ -595,23 +588,7 @@ class Wire():
                 v1 = Topology.SetDictionary(v1, Topology.Dictionary(v_a), silent=True)
             if bisectors == True:
                 bisectors_list.append(Edge.ByVertices(v_a, v1))
-        
-        
-        # wire_edges = []
-        # for i in range(len(final_vertices)-1):
-        #     v1 = final_vertices[i]
-        #     v2 = final_vertices[i+1]
-        #     w_e = Edge.ByVertices(v1,v2)
-        #     #w_e = Edge.SetLength(w_e, Edge.Length(w_e)+(2*epsilon), bothSides = True)
-        #     wire_edges.append(w_e)
-        # if Wire.IsClosed(wire):
-        #     v1 = final_vertices[-1]
-        #     v2 = final_vertices[0]
-        #     #w_e = Edge.SetLength(w_e, Edge.Length(w_e)+(2*epsilon), bothSides = True)
-        #     wire_edges.append(w_e)
-        
         return_wire = Wire.ByVertices(final_vertices, close=Wire.IsClosed(wire), tolerance=tolerance, silent=silent)
-        #wire_edges = Topology.Edges(wire_edges)
         wire_edges = [Edge.SetLength(w_e, Edge.Length(w_e)+(2*epsilon), bothSides=True) for w_e in Topology.Edges(return_wire)]
         return_wire_edges = Topology.Edges(return_wire)
         if transferDictionaries == True:
@@ -651,7 +628,6 @@ class Wire():
                     print("Wire.ByOffset - Warning: The resulting wire is non-manifold, please check your offsets.")
                     print("Wire.ByOffset - Warning: Pursuing a workaround, but it might take longer to complete.")
                 
-                #cycles = Wire.Cycles(return_wire, maxVertices = len(final_vertices))
                 temp_wire = Topology.SelfMerge(Cluster.ByTopologies(wire_edges))
                 cycles = Wire.Cycles(temp_wire, maxVertices = len(final_vertices))
                 if len(cycles) > 0:
@@ -679,7 +655,6 @@ class Wire():
                     return_cycle = Topology.TransferDictionariesBySelectors(return_cycle, Topology.Vertices(return_wire), tranVertices=True, tolerance=tolerance, numWorkers=numWorkers)
                     return_cycle = Topology.TransferDictionariesBySelectors(return_cycle, sel_edges, tranEdges=True, tolerance=tolerance, numWorkers=numWorkers)
                     return_wire = return_cycle
-
         return_wire = Topology.Unflatten(return_wire, direction=normal, origin=origin)
         if transferDictionaries == True:
             return_wire = Topology.SetDictionary(return_wire, Topology.Dictionary(wire), silent=True)
@@ -3728,7 +3703,7 @@ class Wire():
             return None
 
         new_wire = cleanup(wire)
-        wires = Wire.Split(new_wire) if not Wire.IsManifold(new_wire) else [new_wire]
+        wires = Wire.Split(new_wire) if not Wire.IsManifold(new_wire, silent=silent) else [new_wire]
 
         processed_wires = [remove_collinear_vertices(w) for w in wires]
 

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.40'
+__version__ = '0.8.42'

{topologicpy-0.8.40.dist-info → topologicpy-0.8.42.dist-info}/METADATA

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

@@ -2,37 +2,37 @@ topologicpy/ANN.py,sha256=DrNAhNHp-jSvsPc1fb7KVPU46cYmejAvghhknOM430Y,47932
 topologicpy/Aperture.py,sha256=wNn5miB_IrGCBYuQ18HXQYRva20dUC3id4AJCulL7to,2723
 topologicpy/BVH.py,sha256=Iwp_8VDG8ETE4330k7ifWxdI4jmWmv9h8e8IIIZZFGY,13043
 topologicpy/CSG.py,sha256=uDkOSmc8m1V_k7T3UCerODhOSyYNO4FRDzoOqt0kEt8,15590
-topologicpy/Cell.py,sha256=3et98bv27m1-7OqFCeD4cLMBgC_BAsSGyxHi_4PgJ4Y,176072
-topologicpy/CellComplex.py,sha256=NP6yptbkGXYmlfBv9fRimOnNle0mkjV8Yo_ug5NKpKE,60877
+topologicpy/Cell.py,sha256=M4Xv4gabSgtKYYA-Wh0lgYEbRNRVF9zr4DYejOXJc-4,176278
+topologicpy/CellComplex.py,sha256=c2B3mF1c3iwOfT-V0JWt9qNcFdd6DPR0aBOE2UnZTn4,61165
 topologicpy/Cluster.py,sha256=wvfMAx6aPrSAt5nQ4--KnqD4EK9MGjch6Dg985WF7JQ,58748
 topologicpy/Color.py,sha256=FcR0-__giyGQqvgiOrG8GkA65arHbiS33Si-QbUADPI,23362
 topologicpy/Context.py,sha256=G3CwMvN8Jw2rnQRwB-n4MaQq_wLS0vPimbXKwsdMJ80,3055
 topologicpy/DGL.py,sha256=HQXy9iDnrvWGDxaBfe5pRbweQ2zLBvAf6UdjfhKkQYI,139041
 topologicpy/Dictionary.py,sha256=2Sxm8twR1W4ksZho0YXQB_EltK2qbZWK4UHskP3jvFQ,40846
-topologicpy/Edge.py,sha256=CPdQKaE7ft6zgh0vxekkfGRRUY_yEqkEJ14NvjSgJOA,73190
+topologicpy/Edge.py,sha256=dLoAPuRKbjVg_dzloTgjRnQyv_05U9nfrtLO3tqyuys,74167
 topologicpy/EnergyModel.py,sha256=Pyb28gDDwhzlQIH0xqAygqS0P3SJxWyyV7OWS_AAfRs,53856
-topologicpy/Face.py,sha256=BT_5ymb7-s-Wb1tuaBtkopJpeNg-RbooTUk_-KInQ6c,201618
-topologicpy/Graph.py,sha256=z_9TeMkmwFXlCfVDW9Z56PX0sHxGj8iVKlCdJLreMo0,639785
+topologicpy/Face.py,sha256=pN1fssyDLYWf1vU0NOBRx69DaUL958wRSxT-7VBCuCg,203184
+topologicpy/Graph.py,sha256=GykBbB8KKcy2oPV2Dsnz_vkyWGgczxLi0puVx5NJUYU,648088
 topologicpy/Grid.py,sha256=EbI2NcYhQDpD5mItd7A1Lpr8Puuf87vZPWuoh7_gChQ,18483
 topologicpy/Helper.py,sha256=qEsE4yaboEGW94q9lFCff0I_JwwTTQnDAFXw006yHaQ,31203
 topologicpy/Honeybee.py,sha256=yctkwfdupKnp7bAOjP1Z4YaYpRrWoMEb4gz9Z5zaWwE,21751
 topologicpy/Matrix.py,sha256=LqVckk2qTwKwEo79eyNsOrHVSHdO82JCREcfy6WIk4I,22716
 topologicpy/Neo4j.py,sha256=ELKmON7R16j1kQD8xRHDGGCvzjIM2HGHNekdaXDUw6w,22371
-topologicpy/Plotly.py,sha256=Dmy9i9puSfvB42mrBUip3v0TCXIzHpAETWDUCDxfqNA,120556
+topologicpy/Plotly.py,sha256=SqoQOFqchfDY52_mTGyBOqE_OPEfBI48YI3OyuJ7JQw,123758
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
 topologicpy/ShapeGrammar.py,sha256=UVb8VPwVKd6V3zDTNzpBecQPgYo1EjSsS10XJ8k5YcI,23364
 topologicpy/Shell.py,sha256=fx0WTndC8blkvWe38nKsJsI_AmklOA0qsjU0gbZp4b4,90501
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=_VBBAUIDhvpkp72JBZlv7k9qx9jYubm3yM56UZ1Nc6c,36837
-topologicpy/Topology.py,sha256=G6KtKRKabV1gNUKCZ3rzZJkCogGkOJDnCl-_S7DuHKc,466648
+topologicpy/Topology.py,sha256=FnDunqk4uq0iAqtOiQtjNArETXflx6cRBHMYv7NJqC8,467594
 topologicpy/Vector.py,sha256=X12eqskn28bdB7sLY1EZhq3noPYzPbNEgHPb4a959ss,42302
-topologicpy/Vertex.py,sha256=epBfbD7fm87T-TZ0WuwrioXdYqg9NgRlHn_qUFtVbkc,84562
-topologicpy/Wire.py,sha256=vE6IoObVucOZVTFMPiHuNN4DDezRHHyFbwhF5WRBm3s,231547
+topologicpy/Vertex.py,sha256=RlGQnxQSb_kAus3tJgXd-v-Ptubtt09PQPA9IMwfXmI,84835
+topologicpy/Wire.py,sha256=sJE8qwqYOomvN3snMWmj2P2-Sq25ul_OQ95YFz6DFUw,230553
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=9UtSkYQrOL8TXxQBwLoy5jvQKNWp84nSX32fmM7V0Ac,23
-topologicpy-0.8.40.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.40.dist-info/METADATA,sha256=8YuR3I1XDjArnIbbajaveZEDc7Q8eVk4aBOvtaLhULA,10535
-topologicpy-0.8.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.40.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.40.dist-info/RECORD,,
+topologicpy/version.py,sha256=zx8I7AqRXGv-YmSUcQeFeKLCO2nWXVogDC-GQVEnTsI,23
+topologicpy-0.8.42.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.42.dist-info/METADATA,sha256=YEn71WRNeRaM0zD1L8Uh4HSmaxe_JJPkC5lBpaawXcc,10535
+topologicpy-0.8.42.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.42.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.42.dist-info/RECORD,,