topologicpy 0.8.88__py3-none-any.whl → 0.8.90__py3-none-any.whl

topologicpy/Graph.py

@@ -4756,12 +4756,13 @@ class Graph:
         include: list = ["contains", "coveredBy", "covers", "crosses", "disjoint", "equals", "overlaps", "touches","within", "proximity"],
         proximityValues = [1, 5, 10],
         proximityLabels = ["near", "intermediate", "far"],
-        useInternalVertex = False,
-        vertexIDKey = "id",
-        edgeKeyFwd = "relFwd",
-        edgeKeyBwd = "relBwd",
-        connectsKey = "connects",
-        storeBREP = False,
+        useShortestDistance: bool = False,
+        useInternalVertex: bool = False,
+        vertexIDKey: str = "id",
+        edgeKeyFwd: str = "relFwd",
+        edgeKeyBwd: str = "relBwd",
+        connectsKey:str = "connects",
+        storeBREP: bool = False,
         mantissa: int = 6,
         tolerance: float = 0.0001,
         silent: bool = False
@@ -4785,7 +4786,8 @@ class Graph:
         proximityLabels: list , optional
             The list of range labels (e.g. "near", "intermediate", "far") that correspond to the proximityValues list.
             The list must have the same number of elements as the proximityValues list. Default is ["near", "intermediate", "far"]
-
+        useShortestDistance: bool , optional
+            If set to True, the shortest distance between objects is used. Otherwise, the distance between their centroids is used. Default is False.
         useInternalVertex: bool , optional
             If set to True, an internal vertex of the represented topology will be used as a graph node.
             Otherwise, its centroid will be used. Default is False.
@@ -4814,6 +4816,7 @@ class Graph:
         """
         from topologicpy.Graph import Graph
         from topologicpy.BVH import BVH
+        from topologicpy.Cell import Cell
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
@@ -4850,6 +4853,234 @@ class Graph:
             v = Topology.SetDictionary(v, Topology.Dictionary(topologyList[0]))
             return Graph.ByVerticesEdges([v], [])
 
+        # ---------- Calculate Proximity ------------
+
+        def _calc_proximity(topologies: list,
+                            ranges: list,
+                            labels: list,
+                            useShortestDistance: bool = True,
+                            tolerance: float = 0.0001,
+                            silent: bool = False):
+            """
+            Creates a proximity graph from a list of topologies using a BVH
+            to prune distance checks for large input sets.
+
+            Each topology is represented by a vertex in the graph.
+            An edge is created between two vertices if the distance between
+            their corresponding topologies is <= max(ranges).
+
+            A BVH is used as a broad-phase accelerator: for each topology,
+            a query box centred at its centroid and sized to cover the
+            maximum proximity range is used to retrieve only nearby
+            candidates. Exact distances are then computed only for those
+            candidates.
+
+            Parameters
+            ----------
+            topologies : list of topologic_core.Topology
+                The input topologies to be represented as vertices.
+            ranges : list of float
+                A list of positive numeric thresholds (e.g. [1.0, 3.0, 5.0]).
+                Interpreted as upper bounds of proximity bands.
+                Distances larger than max(ranges) are ignored (no edge).
+            labels : list of str
+                A list of proximity labels, same length as `ranges`.
+                For a pair distance d:
+                    - d <= ranges[0] -> labels[0]
+                    - ranges[0] < d <= ranges[1] -> labels[1]
+                    - ...
+            useShortestDistance : bool , optional
+                If True, use Topology.ShortestDistance(topologyA, topologyB)
+                if available. If False (or if that fails), fall back to the
+                distance between the centroids of the two topologies.
+                Default is True.
+            tolerance : float , optional
+                A small numeric tolerance used when comparing distances to
+                range bounds. Default is 0.0001.
+            silent : bool , optional
+                If False, basic sanity-check warnings are printed.
+                Default is False.
+
+            Returns
+            -------
+            graph : topologic_core.Graph
+                A graph whose vertices correspond to the input topologies
+                and whose edges connect topologies that fall within the
+                supplied distance ranges. Each edge dictionary contains:
+                    - "distance"  : float  (actual distance)
+                    - "proximity" : str    (label from `labels`)
+                    - "range_max" : float  (upper bound used for the bin)
+                    - "source_index" : int
+                    - "target_index" : int
+
+            Notes
+            -----
+            - Complexity is approximately O(n log n + k) where k is the
+                number of candidate pairs returned by the BVH.
+            - BVH is used only as a broad-phase filter; exact distance
+                tests still guarantee correctness with respect to `ranges`.
+            """
+
+            # Basic validation
+            if not isinstance(topologies, list) or len(topologies) < 2:
+                if not silent:
+                    print("Graph.BySpatialRelationships - Error: Need a list of at least two topologies.")
+                return None
+
+            if not isinstance(ranges, list) or not isinstance(labels, list):
+                if not silent:
+                    print("Graph.BySpatialRelationships - Error: 'proximityValues' and 'proximityLabels' must be lists.")
+                return None
+
+            if len(ranges) == 0 or len(ranges) != len(labels):
+                if not silent:
+                    print("Graph.BySpatialRelationships - Error: 'proximityValues' must be non-empty and "
+                            "have the same length as 'labels'.")
+                return None
+
+            # Sort ranges and labels together (ascending by range)
+            try:
+                rl = sorted(zip(ranges, labels), key=lambda x: x[0])
+            except Exception:
+                if not silent:
+                    print("Graph.BySpatialRelationships - Error: Could not sort ranges; check they are numeric.")
+                return None
+
+            sorted_ranges = [r for (r, _) in rl]
+            sorted_labels = [lab for (_, lab) in rl]
+
+            max_range = sorted_ranges[-1]
+
+            # Precompute representative vertices (centroids) for each topology
+            vertices = []
+            n = len(topologies)
+            for i, topo in enumerate(topologies):
+                if not topo:
+                    if not silent:
+                        print(f"Graph.BySpatialRelationships - Warning: Ignoring None topology at index {i}.")
+                    vertices.append(None)
+                    continue
+                try:
+                    c_vtx = Topology.Centroid(topo)
+                except Exception:
+                    # Fallback if centroid fails
+                    if not silent:
+                        print(f"Graph.BySpatialRelationships - Error: Failed to compute centroid for topology {i}, "
+                                f"using origin as placeholder.")
+                    c_vtx = Vertex.ByCoordinates(0, 0, 0)
+
+                # Attach index dictionary to the vertex (not to the original topology)
+                d_keys = ["index"]
+                d_vals = [i]
+                v_dict = Dictionary.ByKeysValues(d_keys, d_vals)
+                c_vtx = Topology.SetDictionary(c_vtx, v_dict)
+                vertices.append(c_vtx)
+
+            # Build BVH on the original topologies
+            try:
+                bvh = BVH.ByTopologies(topologies)
+            except Exception as e:
+                if not silent:
+                    print(f"Graph.BySpatialRelationships - Error: Failed to build BVH, falling back to O(n^2): {e}")
+                # Fallback: use the non-BVH variant if you like,
+                # or just early-return None. Here we just bail out.
+                return None
+
+            # Map from topology identity to index for fast lookup
+            id_to_index = {id(topo): i for i, topo in enumerate(topologies)}
+
+            # Helper to compute distance between two topologies
+            def _distance(topoA, topoB, vA, vB):
+                d_val = None
+                if useShortestDistance:
+                    try:
+                        d_val = Topology.ShortestDistance(topoA, topoB)
+                    except Exception:
+                        d_val = None
+                if d_val is None:
+                    try:
+                        d_val = Vertex.Distance(vA, vB)
+                    except Exception:
+                        d_val = None
+                return d_val
+
+            edges = []
+
+            # Main loop: for each topology, query BVH for candidates within
+            # a bounding box of size 2*max_range around its centroid.
+            for i in range(n):
+                topo_i = topologies[i]
+                v_i = vertices[i]
+                if topo_i is None or v_i is None:
+                    continue
+
+                # Build a query box centered at the centroid with size 2 * max_range
+                try:
+                    query_box = Cell.Prism(
+                        origin=v_i,
+                        width=2 * max_range,
+                        length=2 * max_range,
+                        height=2 * max_range
+                    )
+                except Exception as q_err:
+                    if not silent:
+                        print(f"Graph.BySpatialRelationships - Error: Failed to build query box for {i}: {q_err}")
+                    continue
+
+                try:
+                    candidates = BVH.Clashes(bvh, query_box)
+                except Exception as c_err:
+                    if not silent:
+                        print(f"Graph.BySpatialRelationships - Error: BVH.Clashes failed for {i}: {c_err}")
+                    continue
+
+                if not candidates:
+                    continue
+
+                for cand in candidates:
+                    j = id_to_index.get(id(cand), None)
+                    if j is None:
+                        continue
+                    # Enforce i < j to avoid duplicate edges
+                    if j <= i:
+                        continue
+
+                    topo_j = topologies[j]
+                    v_j = vertices[j]
+                    if topo_j is None or v_j is None:
+                        continue
+
+                    # Compute exact distance
+                    d = _distance(topo_i, topo_j, v_i, v_j)
+                    if d is None:
+                        if not silent:
+                            print(f"Graph.BySpatialRelationships - Error: Could not compute distance between "
+                                    f"{i} and {j}.")
+                        continue
+
+                    # Skip if beyond max range (plus tolerance)
+                    if d > max_range + tolerance:
+                        continue
+
+                    # Bin the distance into the appropriate range/label
+                    label = None
+                    range_max = None
+                    for r, lab in zip(sorted_ranges, sorted_labels):
+                        if d <= r + tolerance:
+                            label = lab
+                            range_max = r
+                            break
+
+                    if label is None:
+                        continue
+
+                    e_keys = ["distance", "proximity", "range_max", "source_index", "target_index"]
+                    e_values = [float(d), str(label), float(range_max), i, j]
+                    d = Dictionary.ByKeysValues(e_keys, e_values)
+                    edges.append(d)
+
+            return edges
+
         # ---------- BVH once ----------
         bvh = BVH.ByTopologies(topologyList, silent=True)
 
@@ -4924,31 +5155,23 @@ class Graph:
                     ))
 
         # ---------- main loops (each unordered pair once) ----------
-        used = []
-        proximity_edges = []
+        if "proximity" in include:
+            prox_dicts = _calc_proximity(topologies = topologyList,
+                            ranges = proximityValues,
+                            labels = proximityLabels,
+                            useShortestDistance = useShortestDistance,
+                            tolerance = tolerance,
+                            silent = silent)
+            for prox_dict in prox_dicts:
+                ai = Dictionary.ValueAtKey(prox_dict, "source_index")
+                bj = Dictionary.ValueAtKey(prox_dict, "target_index")
+                rel = Dictionary.ValueAtKey(prox_dict, "proximity")
+                if (rel in proximityLabels):
+                    _add_edge(ai, bj, rel)
+        
         for i, a in enumerate(topologyList):
             candidates = []
             ai = i
-            if "proximity" in include:
-                for j, b in enumerate(topologyList):
-                    bj = index_of.get(id(b))
-                    if i == bj or (i,bj) in used or (bj,i) in used:
-                        continue
-                    else:
-                        used.append((i,bj))
-                        used.append((bj,i))
-                        rel = Topology.SpatialRelationship( a,
-                                                        b,
-                                                        include=["proximity"],
-                                                        proximityValues = proximityValues,
-                                                        proximityLabels = proximityLabels,
-                                                        mantissa=mantissa,
-                                                        tolerance=tolerance,
-                                                        silent=True
-                                                        )
-                        rel_ok = (rel in proximityLabels)
-                        if rel_ok:
-                            _add_edge(ai, bj, rel)
             candidates = BVH.Clashes(bvh, a) or []
             if not candidates:
                 # If you want to connect "disjoint" to *all* non-candidates, that would be O(n) per i.
@@ -5028,7 +5251,8 @@ class Graph:
                    useInternalVertex: bool = False,
                    storeBREP: bool =False,
                    mantissa: int = 6,
-                   tolerance: float = 0.0001):
+                   tolerance: float = 0.0001,
+                   silent: float = False):
         """
         Creates a graph.See https://en.wikipedia.org/wiki/Graph_(discrete_mathematics).
 
@@ -5082,6 +5306,8 @@ class Graph:
             If set to True, store the BRep of the subtopology in its representative vertex. Default is False.
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
 
         Returns
         -------
@@ -5096,6 +5322,10 @@ class Graph:
         from topologicpy.Topology import Topology
         from topologicpy.Aperture import Aperture
         
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Graph.ByTopology - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
         def _viaSharedTopologies(vt, sharedTops):
             verts = []
             eds = []
@@ -15354,7 +15584,7 @@ class Graph:
         try:
             gsv = Graph.NearestVertex(graph, vertexA)
             gev = Graph.NearestVertex(graph, vertexB)
-            shortest_path = graph.ShortestPath(gsv, gev, vertexKey, edgeKey)
+            shortest_path = graph.ShortestPath(gsv, gev, vertexKey, edgeKey) # Hook to Core
             if not shortest_path == None:
                 if Topology.IsInstance(shortest_path, "Edge"):
                         shortest_path = Wire.ByEdges([shortest_path])
@@ -15367,6 +15597,70 @@ class Graph:
         except:
             return None
 
+    @staticmethod
+    def shortestPathInFace(graph, face, vertexA, vertexB, mode: int = 0, meshSize: float = None, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns the shortest path that connects the input vertices.
+
+        Parameters
+        ----------
+        face : topologic_core.Face
+            The input face. This is assumed to be planar and resting on the XY plane (z = 0)
+        vertexA : topologic_core.Vertex
+            The first input vertex.
+        vertexB : topologic_core.Vertex
+            The second input vertex.
+        mode : int , optional
+                The desired mode of meshing algorithm. Several options are available:
+                0: Classic
+                1: MeshAdapt
+                3: Initial Mesh Only
+                5: Delaunay
+                6: Frontal-Delaunay
+                7: BAMG
+                8: Fontal-Delaunay for Quads
+                9: Packing of Parallelograms
+                All options other than 0 (Classic) use the gmsh library. See https://gmsh.info/doc/texinfo/gmsh.html#Mesh-options
+                WARNING: The options that use gmsh can be very time consuming and can create very heavy geometry.
+        meshSize : float , optional
+            The desired size of the mesh when using the "mesh" option. If set to None, it will be
+            calculated automatically and set to 10% of the overall size of the face.
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+                If set to True, error and warning messages are suppressed. Default is False.
+        
+        Returns
+        -------
+        topologic_core.Wire
+            The shortest path between the input vertices.
+
+        """
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(face, "face"):
+            if not silent:
+                print("Face.ShortestPath - Error: The input face parameter is not a topologic face. Returning None.")
+            return None
+        if not Topology.IsInstance(vertexA, "vertex"):
+            if not silent:
+                print("Face.ShortestPath - Error: The input vertexA parameter is not a topologic vertex. Returning None.")
+            return None
+        if not Topology.IsInstance(vertexB, "vertex"):
+            if not silent:
+                print("Face.ShortestPath - Error: The input vertexB parameter is not a topologic vertex. Returning None.")
+            return None
+
+        sp = Graph.ShortestPath(graph, vertexA, vertexB)
+        if sp == None:
+            if not silent:
+                print("Face.ShortestPath - Error: Could not find the shortest path. Returning None.")
+            return None
+
+        new_path = Wire.StraightenInFace(sp, face, tolerance = tolerance)
+        return new_path
+
     @staticmethod
     def ShortestPaths(graph, vertexA, vertexB, vertexKey="", edgeKey="length", timeLimit=10,
                            pathLimit=10, tolerance=0.0001):

topologicpy/Wire.py

@@ -331,16 +331,19 @@ class Wire():
                         
         else:
             best_br = boundingRectangle
-        x_min, y_min, maxX, maxY = best_br
+        x_min, y_min, x_max, y_max = best_br
         vb1 = Vertex.ByCoordinates(x_min, y_min, 0)
-        vb2 = Vertex.ByCoordinates(maxX, y_min, 0)
-        vb3 = Vertex.ByCoordinates(maxX, maxY, 0)
-        vb4 = Vertex.ByCoordinates(x_min, maxY, 0)
+        vb2 = Vertex.ByCoordinates(x_max, y_min, 0)
+        vb3 = Vertex.ByCoordinates(x_max, y_max, 0)
+        vb4 = Vertex.ByCoordinates(x_min, y_max, 0)
 
         boundingRectangle = Wire.ByVertices([vb1, vb2, vb3, vb4], close=True, tolerance=tolerance, silent=silent)
         boundingRectangle = Topology.Rotate(boundingRectangle, origin=origin, axis=[0, 0, 1], angle=-best_z)
         boundingRectangle = Topology.Unflatten(boundingRectangle, origin=f_origin, direction=normal)
-        dictionary = Dictionary.ByKeysValues(["zrot"], [best_z])
+        dictionary = Dictionary.ByKeysValues(["zrot", "xmin", "ymin", "xmax", "ymax", "width", "length"],
+                                             [best_z, x_min, y_min, x_max, y_max, (x_max - x_min), (y_max - y_min)])
+
+        #dictionary = Dictionary.ByKeysValues(["zrot"], [best_z])
         boundingRectangle = Topology.SetDictionary(boundingRectangle, dictionary)
         return boundingRectangle
 
@@ -2426,7 +2429,254 @@ class Wire():
         # Unflatten the wire
         return_wire = Topology.Unflatten(flat_wire, origin=Vertex.Origin(), direction=normal)
         return return_wire
-    
+
+    @staticmethod
+    def Funnel(face,
+                vertexA,
+                vertexB,
+                portals,
+                tolerance: float = 0.0001,
+                silent: float = False):
+        """
+        Returns a Wire representing a smoothed path inside the given face using
+        the funnel (string-pulling) algorithm.
+
+        The algorithm assumes that a corridor has already been computed, and is
+        provided as an ordered list of "portals" (pairs of vertices) that lie
+        on the face between the start and end locations.
+
+        Parameters
+        ----------
+        face : topologic_core.Face
+            The planar face on which navigation occurs. All vertices must lie
+            on this face.
+        vertexA : topologic_core.Vertex
+            The start point of the path.
+        vertexB : topologic_core.Vertex
+            The end point of the path.
+        portals : list of tuple(Vertex, Vertex)
+            Ordered list of corridor edges. Each item is (leftVertex, rightVertex)
+            describing the visible "portal" between two consecutive regions along
+            the navmesh path.
+        tolerance : float , optional
+            Numerical tolerance used when comparing orientations and distances.
+            Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+
+        Returns
+        -------
+        wire : topologic_core.Wire
+            A Wire representing the smoothed path from startVertex to endVertex
+            that stays inside the navigation corridor on the face.
+        """
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(face, "face"):
+            if not silent:
+                print("Wire.Funnel - Error: The input face parameter is not a topologic face. Returning None.")
+            return None
+        if not Topology.IsInstance(vertexA, "vertex"):
+            if not silent:
+                print("Wire.Funnel - Error: The input vertexA parameter is not a topologic vertex. Returning None.")
+            return None
+        if not Topology.IsInstance(vertexB, "vertex"):
+            if not silent:
+                print("Wire.Funnel - Error: The input vertexB parameter is not a topologic vertex. Returning None.")
+            return None
+
+        # ------------------------------------------------------------
+        # 1. Basic helpers
+        # ------------------------------------------------------------
+        def _norm(v):
+            return math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2])
+
+        def _normalize(v):
+            n = _norm(v)
+            if n < tolerance:
+                return (0.0, 0.0, 0.0)
+            return (v[0] / n, v[1] / n, v[2] / n)
+
+        def _dot(a, b):
+            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+
+        def _cross(a, b):
+            return (
+                a[1] * b[2] - a[2] * b[1],
+                a[2] * b[0] - a[0] * b[2],
+                a[0] * b[1] - a[1] * b[0],
+            )
+
+        def _sub(a, b):
+            return (a[0] - b[0], a[1] - b[1], a[2] - b[2])
+
+        def _tri_area2(a2, b2, c2):
+            """
+            Twice the signed area of triangle (a, b, c) in 2D.
+            Positive => c is to the left of ab
+            Negative => c is to the right of ab
+            """
+            return (b2[0] - a2[0]) * (c2[1] - a2[1]) - (b2[1] - a2[1]) * (c2[0] - a2[0])
+
+        def _coords3d(v):
+            x, y, z = Vertex.Coordinates(v)
+            return (x, y, z)
+
+        # ------------------------------------------------------------
+        # 2. Build a local 2D coordinate system on the face
+        # ------------------------------------------------------------
+        # Face normal
+        n_vec = Face.Normal(face)  # [nx, ny, nz]
+        n = _normalize((n_vec[0], n_vec[1], n_vec[2]))
+
+        # Choose an arbitrary vector not parallel to n
+        if abs(n[0]) < 0.9:
+            arbitrary = (1.0, 0.0, 0.0)
+        else:
+            arbitrary = (0.0, 1.0, 0.0)
+
+        u = _normalize(_cross(n, arbitrary))  # tangent
+        v = _cross(n, u)                      # bitangent, already orthogonal and normalized
+
+        def _project_to_2d(vertex):
+            p = _coords3d(vertex)
+            # project onto basis (u, v)
+            return (_dot(p, u), _dot(p, v))
+
+        # Precompute 2D coords for start, end and all portal vertices
+        start2d = _project_to_2d(vertexA)
+        end2d = _project_to_2d(vertexB)
+
+        portal2d = []
+        for l_v, r_v in portals:
+            portal2d.append((_project_to_2d(l_v), _project_to_2d(r_v)))
+
+        # ------------------------------------------------------------
+        # 3. Funnel algorithm in 2D
+        #   (based on classic Recast / string-pulling implementation)
+        # ------------------------------------------------------------
+        path_vertices = [vertexA]
+
+        apex2d = start2d
+        apexVertex = vertexA
+        apexIndex = -1
+
+        left2d = start2d
+        right2d = start2d
+        leftVertex = vertexA
+        rightVertex = vertexB
+        leftIndex = -1
+        rightIndex = -1
+
+        n_portals = len(portals)
+        i = 0
+
+        # We will process all portals, and then a final "portal" at the goal (end, end)
+        while i <= n_portals:
+            if i < n_portals:
+                newLeft2d, newRight2d = portal2d[i]
+                newLeftVertex, newRightVertex = portals[i]
+            else:
+                # last "portal" is the goal point itself
+                newLeft2d = end2d
+                newRight2d = end2d
+                newLeftVertex = vertexB
+                newRightVertex = vertexB
+
+            # --------------------------------------------------------
+            # Update right side of funnel
+            # --------------------------------------------------------
+            area_apex_right_newRight = _tri_area2(apex2d, right2d, newRight2d)
+            if area_apex_right_newRight <= tolerance:
+                # New right vertex is "inside" or tightening the funnel
+                area_apex_left_newRight = _tri_area2(apex2d, left2d, newRight2d)
+                if (apexVertex == rightVertex) or (area_apex_left_newRight > tolerance):
+                    # Tighten the funnel on the right side
+                    right2d = newRight2d
+                    rightVertex = newRightVertex
+                    rightIndex = i
+                else:
+                    # Right over left, so left becomes the new apex
+                    path_vertices.append(leftVertex)
+                    apex2d = _project_to_2d(leftVertex)
+                    apexVertex = leftVertex
+                    apexIndex = leftIndex
+
+                    # Reset funnel
+                    left2d = apex2d
+                    right2d = apex2d
+                    leftVertex = apexVertex
+                    rightVertex = apexVertex
+                    leftIndex = apexIndex
+                    rightIndex = apexIndex
+
+                    # Restart from the new apex
+                    i = apexIndex + 1
+                    continue
+
+            # --------------------------------------------------------
+            # Update left side of funnel
+            # --------------------------------------------------------
+            area_apex_left_newLeft = _tri_area2(apex2d, left2d, newLeft2d)
+            if area_apex_left_newLeft >= -tolerance:
+                # New left vertex is "inside" or tightening the funnel
+                area_apex_right_newLeft = _tri_area2(apex2d, right2d, newLeft2d)
+                if (apexVertex == leftVertex) or (area_apex_right_newLeft < -tolerance):
+                    # Tighten funnel on the left side
+                    left2d = newLeft2d
+                    leftVertex = newLeftVertex
+                    leftIndex = i
+                else:
+                    # Left over right, so right becomes the new apex
+                    path_vertices.append(rightVertex)
+                    apex2d = _project_to_2d(rightVertex)
+                    apexVertex = rightVertex
+                    apexIndex = rightIndex
+
+                    # Reset funnel
+                    left2d = apex2d
+                    right2d = apex2d
+                    leftVertex = apexVertex
+                    rightVertex = apexVertex
+                    leftIndex = apexIndex
+                    rightIndex = apexIndex
+
+                    # Restart from the new apex
+                    i = apexIndex + 1
+                    continue
+
+            i += 1
+
+        # Finally, add the end point if it is not already in the path
+        if path_vertices[-1] is not vertexB:
+            path_vertices.append(vertexB)
+
+        # ------------------------------------------------------------
+        # 4. Build and return the Topologic wire
+        # ------------------------------------------------------------
+        return_wire = Wire.ByVertices(path_vertices, close=False, silent=True)
+        bb = Wire.BoundingRectangle(face)
+        d = Topology.Dictionary(bb)
+        width = Dictionary.ValueAtKey(d, "width")
+        length = Dictionary.ValueAtKey(d, "length")
+        size = max(width, length)
+        percentage = 0.25 # Start with 25% of the total size
+        is_ok = False
+        while is_ok == False and percentage > 0:
+            new_wire = Wire.Simplify(return_wire, tolerance=size*percentage, silent=True)
+            test_wire = Topology.Scale(new_wire, Topology.Centroid(new_wire), 0.95, 0.95, 1)
+            result = Topology.Difference(test_wire, face, tolerance=tolerance, silent=True)
+            if result is None:
+                is_ok = True
+                return_wire = new_wire
+            percentage -= 0.01
+        print("Wire.Funnel - Result:", result)
+        print("Wire.Funnel - Percentage:", percentage)
+        return new_wire
+
     @staticmethod
     def InteriorAngles(wire, tolerance: float = 0.0001, mantissa: int = 6) -> list:
         """
@@ -4188,7 +4438,7 @@ class Wire():
             if not silent:
                 print("Wire.Simplify - Warning: Could not generate enough vertices for a simplified wire. Returning the original wire.")
             wire
-        new_wire = Wire.ByVertices(new_vertices, close=Wire.IsClosed(wire), tolerance=tolerance)
+        new_wire = Wire.ByVertices(new_vertices, close=Wire.IsClosed(wire), tolerance=tolerance, silent=True)
         if not Topology.IsInstance(new_wire, "wire"):
             if not silent:
                 print("Wire.Simplify - Warning: Could not generate a simplified wire. Returning the original wire.")
@@ -4713,6 +4963,124 @@ class Wire():
         sv, ev = Wire.StartEndVertices(wire, silent=silent)
         return sv
 
+    @staticmethod
+    def StraightenInFace(wire, face, tolerance: float = 0.0001):
+        """
+        Returns a new Wire obtained by recursively replacing segments of the
+        input wire with the longest possible straight edge that is fully
+        embedded in the given face.
+
+        For each starting vertex v_i along the wire, this method searches for
+        the furthest vertex v_j (j > i) such that the straight Edge between
+        v_i and v_j satisfies:
+
+            Topology.Difference(edge, face) == None
+
+        i.e. the edge lies completely within (or on the boundary of) the face.
+        All edges of the original wire between vertex indices i and j are then
+        replaced by this straight edge, and the process is repeated recursively
+        from index j.
+
+        Parameters
+        ----------
+        wire : topologic_core.Wire
+            The input path wire whose vertices define the route to be
+            straightened.
+        face : topologic_core.Face
+            The face within which the straightened edges must lie.
+        tolerance : float , optional
+            Numerical tolerance used for internal robustness checks. The
+            Topology.Difference call itself is left with its default tolerance.
+            Default is 1e-6.
+
+        Returns
+        -------
+        wire : topologic_core.Wire
+            A new Wire whose vertices define the recursively straightened path.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+        # Get ordered vertices of the wire
+        vertices = Topology.Vertices(wire)
+        n = len(vertices)
+
+        if n <= 2:
+            # Nothing to straighten
+            return wire
+
+        def _edge_inside_face(v_start, v_end):
+            """
+            Returns True if the straight edge between v_start and v_end is
+            fully embedded in the face, i.e. Topology.Difference(edge, face)
+            returns None.
+            """
+            if v_start is v_end:
+                return True
+            edge = Edge.ByStartVertexEndVertex(v_start, v_end)
+            diff = Topology.Difference(edge, face)
+            return diff is None
+
+        def _find_longest_valid_index(start_idx):
+            """
+            For a fixed start_idx, search for the largest index j >= start_idx+1
+            such that the direct edge (vertices[start_idx], vertices[j]) is
+            fully inside the face.
+
+            If for any reason no such j exists (which should not happen if the
+            original wire lies in the face), it falls back to start_idx + 1.
+            """
+            v_start = vertices[start_idx]
+            best_j = None
+
+            for j in range(start_idx + 1, n):
+                v_end = vertices[j]
+                if _edge_inside_face(v_start, v_end):
+                    best_j = j
+                # Do NOT break on failure: a further vertex might still
+                # be reachable by a straight edge that stays in the face.
+
+            if best_j is None:
+                # Fallback: use the immediate next vertex to avoid stalling
+                best_j = min(start_idx + 1, n - 1)
+
+            return best_j
+
+        def _straighten_recursive(start_idx, out_vertices):
+            """
+            Recursive helper.
+
+            Appends the chosen vertices to out_vertices. At each step, it
+            decides how far it can jump from start_idx with a single straight
+            edge inside the face, then recurses from that new index.
+            """
+            # Base case: we are at the last vertex
+            if start_idx == n - 1:
+                out_vertices.append(vertices[start_idx])
+                return
+
+            # Find furthest valid index reachable from start_idx
+            next_idx = _find_longest_valid_index(start_idx)
+
+            # Add the starting vertex for this segment
+            out_vertices.append(vertices[start_idx])
+
+            # Recurse from the chosen furthest index
+            _straighten_recursive(next_idx, out_vertices)
+
+        # Run the recursion
+        new_vertices = []
+        _straighten_recursive(0, new_vertices)
+
+        # In case of any numerical quirks, ensure the last original vertex is present
+        if new_vertices[-1] is not vertices[-1]:
+            new_vertices.append(vertices[-1])
+
+        # Build the new straightened wire
+        return Wire.ByVertices(new_vertices, close=False)
+
     @staticmethod
     def Trapezoid(origin= None, widthA: float = 1.0, widthB: float = 0.75, offsetA: float = 0.0, offsetB: float = 0.0, length: float = 1.0, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.88'
+__version__ = '0.8.90'

{topologicpy-0.8.88.dist-info → topologicpy-0.8.90.dist-info}/METADATA

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

@@ -12,7 +12,7 @@ topologicpy/Dictionary.py,sha256=goODXIM6AoC5Qn_d8LGc5pRoxZKgIWbkn3IOEbsQ4c4,449
 topologicpy/Edge.py,sha256=aiRd1xZgG2GGYHxva0bM-kDy3AVmwGA_S2pMur8EeMg,74911
 topologicpy/EnergyModel.py,sha256=MEai1GF1hINeH5bhclJj_lpMU3asFTvW2RlPm40GNj4,57794
 topologicpy/Face.py,sha256=qAl36LcwiyRclMM2pI9NyWHzmgNlaykXiJx1wu10RmA,201317
-topologicpy/Graph.py,sha256=oDzAX_lmM10ayRA8mNenlccJu-oe-FYwW2GHbAp9x5s,798255
+topologicpy/Graph.py,sha256=c-n_9xKXizbyGGWBw62fECsqMo-UoqvQJz6nw82DWgA,811337
 topologicpy/Grid.py,sha256=3OsBMyHh4w8gpFOTMKHMNTpo62V0CwRNu5cwm87yDUA,18421
 topologicpy/Helper.py,sha256=NsmMlbbKFPRX6jfoko-ZQVQ7MBsfVp9FD0ZvC2U7q-8,32002
 topologicpy/Honeybee.py,sha256=dBk01jIvxjQMGHqSarM1Cukv16ot4Op7Dwlitn2OMoc,48990
@@ -29,11 +29,11 @@ topologicpy/Sun.py,sha256=ezisiHfc2nd7A_8w0Ykq2VgbS0A9WNSg-tBwvfTQAVM,36735
 topologicpy/Topology.py,sha256=E_AyPPCIx_Eq-UT74QS3LKFXIwdwekRjJJGTo1CRMRY,548577
 topologicpy/Vector.py,sha256=pEC8YY3TeHGfGdeNgvdHjgMDwxGabp5aWjwYC1HSvMk,42236
 topologicpy/Vertex.py,sha256=26TrlX9OCZUN-lMlZG3g4RHTWBqw69NW4AOEgRz_YMo,91269
-topologicpy/Wire.py,sha256=au0ZkuuZgVzHYE5E1fRwflRT3win0yTivHKOhonAzUk,234116
+topologicpy/Wire.py,sha256=Rhqw0CGEWIMVL1ICQqkCp9G-VnhhHLhEiDDR00fAn_s,248919
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=qAXCd2Ric5BF00XcziW6Y7EfWidI5Yii7_q1vhA8if4,23
-topologicpy-0.8.88.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.88.dist-info/METADATA,sha256=TmanTsL4EPrwo0Fd1oWarCyWzj91C3AWRbJE0LMxbag,10535
-topologicpy-0.8.88.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.88.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.88.dist-info/RECORD,,
+topologicpy/version.py,sha256=Vg4EZKvQvJEbHjPwL_FRDJq1bK9YEoQB3n1ijcuv9Dk,23
+topologicpy-0.8.90.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.90.dist-info/METADATA,sha256=Zk31JGzXHHQe7HU4kLuQ6SvCj6EnOW3PolmmmV1EepE,10535
+topologicpy-0.8.90.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.90.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.90.dist-info/RECORD,,