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

topologicpy/Edge.py

@@ -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.
 
@@ -485,12 +576,14 @@ class Edge():
         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)
@@ -533,8 +631,8 @@ class Edge():
         if intVertex:
             return Edge.ByVertices([v1, intVertex], tolerance=tolerance, silent=True)
         if not silent:
-            print("Edge.ExtendToEdge - Error: The operation failed. Returning None.")
-        return None
+            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):
@@ -614,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:
         """

topologicpy/Wire.py

@@ -348,20 +348,21 @@ class Wire(Topology):
             if not silent:
                 print("Wire.ByOffset - Error: The input wire parameter is not a valid wire. Returning None.")
                 return None
+        
         origin = Vertex.Origin()
         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_edge = Face.NormalEdge(temp_face, length=4)
         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)
-        original_edges = Topology.Edges(wire)
         edges = Topology.Edges(flat_wire)
         offsets = []
         offset_edges = []
+        final_vertices = []
+        bisectors_list = []
         for edge in edges:
             d = Topology.Dictionary(edge)
             d_offset = Dictionary.ValueAtKey(d, offsetKey)
@@ -369,77 +370,68 @@ class Wire(Topology):
                 d_offset = offset
             offsets.append(d_offset)
             offset_edge = Edge.ByOffset2D(edge, d_offset)
-            offset_edge = Edge.Extend(offset_edge, distance=Edge.Length(offset_edge)*4)
             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:
-                    ex_start = offsets[i]
-                    ex_end = offsets[i+1]
-                    prev_edge = Edge.NormalEdge(edges[i], u=0, length=5+Edge.Length(edges[i])+offsets[i])
-                    direc = Edge.Direction(prev_edge)
-                    prev_edge = Topology.TranslateByDirectionDistance(prev_edge, distance=Edge.Length(prev_edge)*0.5, direction=Vector.Reverse(direc))
-                    next_edge = offset_edges[i+1]
+                    v1 = Edge.StartVertex(offset_edges[0])
+                    final_vertices.append(v1)
+                    if bisectors == True:
+                        bisectors_list.append(Edge.ByVertices(v_a, v1))
                 else:
-                    ex_start = offsets[-1]
-                    ex_end = offsets[i+1]
                     prev_edge = offset_edges[-1]
-                    next_edge = offset_edges[i+1]
-            elif i == len(edges)-1:
-                if Wire.IsClosed(wire) == False:
-                    ex_start = offsets[i-1]
-                    ex_end = offsets[i]
-                    prev_edge = offset_edges[i-1]
-                    next_edge = Edge.NormalEdge(edges[i], u=1, length=Edge.Length(edges[i]))
-                else:
-                    ex_start = offsets[i-1]
-                    ex_end = offsets[0]
-                    prev_edge = offset_edges[i-1]
-                    next_edge = offset_edges[0]
             else:
-                ex_start = offsets[i-1]
-                ex_end = offsets[i+1]
                 prev_edge = offset_edges[i-1]
-                next_edge = offset_edges[i+1]
-            temp_edge = Edge.TrimByEdge(o_edge_a, prev_edge, reverse=True, tolerance=tolerance) or o_edge_a
-            temp_edge = Edge.TrimByEdge(temp_edge, next_edge, reverse=True, tolerance=tolerance) or temp_edge
-            temp_edge = Edge.ExtendToEdge(temp_edge, next_edge, tolerance=tolerance, silent=False) or temp_edge
-            temp_edge = Edge.ExtendToEdge(temp_edge, prev_edge, tolerance=tolerance, silent=False) or temp_edge
-            if temp_edge:
-                temp_edge = Edge.Reverse(temp_edge)
-                if bisectors:
-                    if abs(ex_start) > tolerance and abs(offsets[i]) > tolerance :
-                        sv1 = Edge.StartVertex(edge_a)
-                        sv2 = Edge.StartVertex(temp_edge)
-                        bisector = Edge.ByVertices(sv1, sv2)
-                        o_edges.append(bisector)
-                        if i == len(edges)-1:
-                            ev1 = Edge.EndVertex(edge_a)
-                            ev2 = Edge.EndVertex(temp_edge)
-                            bisector = Edge.ByVertices(ev1, ev2)
-                            o_edges.append(bisector)
-                o_edges.append(temp_edge)
-        cluster = Cluster.ByTopologies(o_edges)
-        vertices = Topology.Vertices(cluster)
-        verts = [Vertex.Coordinates(v) for v in vertices]
-        geo = Topology.Geometry(cluster)
-        eds = geo['edges']
-        verts = geo['vertices']
-        vertices = [Vertex.ByCoordinates(coord) for coord in verts]
-        vertices = Vertex.Fuse(vertices, tolerance=tolerance)
-        verts = [Vertex.Coordinates(v, mantissa=4) for v in vertices]
-        return_wire = Topology.SelfMerge(Topology.ByGeometry(vertices=verts, edges=eds, faces=[]), tolerance=tolerance)
+                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))
+        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(return_wire)
                 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 not well-formed, please check your offsets.")
+                    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
 

topologicpy/version.py

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

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

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

@@ -7,7 +7,7 @@ topologicpy/Color.py,sha256=UlmRcCSOhqcM_OyMWz4t3Kr75KcgXDhz3uctAJ2n7Ic,18031
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
 topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
 topologicpy/Dictionary.py,sha256=KqJ29YyE23Y3Xc6XmKLSCZXRfBvm-OEOxlMZ4dt-rfM,27094
-topologicpy/Edge.py,sha256=4Ok25UtwFB9Wu32lfcvNeldTYGZ6MMGIU-_qsPrBmwQ,58424
+topologicpy/Edge.py,sha256=vhYHkobSLGSWV-oe2oJFFDobqFToDyb7s71yQ840AAA,65166
 topologicpy/EnergyModel.py,sha256=ni0H1JgvLl1-q90yK9Sm1qj5P1fTuidlimEIcwuj6qE,53287
 topologicpy/Face.py,sha256=u-DPS5guhzfwxZUuUNYqtPJG6OdeHpY1XQHRSKn6rqk,110148
 topologicpy/Graph.py,sha256=ZU4etwhj6-_JUci3-CK5AoMUoFaTMtVvRWdSHW52SR0,391660
@@ -24,11 +24,11 @@ topologicpy/Sun.py,sha256=_gZfVyH0SDLQmmt775UeeAJ_BtwXO1STQnUMV1qkU0s,37161
 topologicpy/Topology.py,sha256=Z-zddTGL_wkQmhrkXlredpQxx7Myd4Xp-yNw2d95iks,361647
 topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
 topologicpy/Vertex.py,sha256=xnCoPG7BTKBG-JU3C0e11KcpDJbDt9t1Ahj4f5Ul13I,71151
-topologicpy/Wire.py,sha256=CBSJlkJ9VcH-OaD3MRdr--637mc6yUNmDrHcoih2kZM,148075
+topologicpy/Wire.py,sha256=mxwx6170ylBnSP2CRAuUZ6xWtISR-frAG5QAVMtS_ZE,147316
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=EGarFuMvAZwQ5J027Oe6eX7nnDQVQjAGSr5X1azQ_es,23
-topologicpy-0.7.27.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.27.dist-info/METADATA,sha256=ofrlCW4SD94Qw0h5_6CIufST2V0M711KzAkrr8lduio,10916
-topologicpy-0.7.27.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-topologicpy-0.7.27.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.27.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.27.dist-info → topologicpy-0.7.28.dist-info}/WHEEL

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