Tangent Intersection Guidance (TIG) for UAV Planning

• TIG is a UAV path-planning algorithm that incrementally generates collision-free waypoints using local tangent intersections on safety-inflated elliptical obstacles.
• It refines candidate sub-paths via a compact heuristic score and applies quadratic Bézier curve smoothing to ensure UAV feasibility and smooth directional changes.
• TIG demonstrates notable performance improvements, achieving up to 11% shorter paths and up to 93% lower turning angles compared to traditional planning methods.

Searching arXiv for TIG and related UAV path-planning papers to ground the article in current literature. Tangent Intersection Guidance (TIG) is a UAV path-planning algorithm for static, partially known, and completely unknown environments in which obstacles are modeled as safety-inflated ellipses and avoidance decisions are generated from local tangent geometry rather than from a full roadmap or visibility graph. In its 2025 formulation, TIG generates two sub-paths for each encountered threat, ranks them with a heuristic rule, iteratively refines the route until the target is reached, and then applies a modified smoothing technique based on quadratic Bézier curves to reduce abrupt heading changes while preserving obstacle-avoidance structure (Cheriet et al., 26 Aug 2025). Within the broader lineage of tangent-based UAV planners, TIG is closely related to the earlier APPATT framework, which also used elliptic tangent construction and target guidance, but employed different selection rules and cubic B-spline smoothing (Liu et al., 2020).

1. Origins and methodological position

TIG was introduced to address a specific combination of requirements in low-altitude UAV navigation: collision avoidance, short path length, limited turning angle or turning radius, and low computation time in environments containing buildings, trees, bridges, and other obstacles (Cheriet et al., 26 Aug 2025). The method is presented against several established baselines whose drawbacks are explicitly identified in the literature: A* can produce jagged, UAV-unfriendly grid paths and may incur large computation time in large maps; PRM and RRT* can be costly or produce poor-quality paths with many turns; traditional tangent graph and visibility graph methods often require constructing tangents or visible edges for the entire map; APPATT can still generate infeasible paths and may fail in dense cases or become trapped in waypoint selection issues; and APF is vulnerable to local minima (Cheriet et al., 26 Aug 2025).

The immediate precursor is APPATT, the “Autonomous Path Planning Method for Unmanned Aerial Vehicle based on a Tangent Intersection and Target Guidance Strategy,” which introduced static and dynamic elliptic tangent graph variants denoted SETG-TG and DETG-TG (Liu et al., 2020). APPATT already embodied the core tangent-intersection idea: when the straight connection from the current origin to the current destination is blocked by the first-collided obstacle, the planner inflates that obstacle to an ellipse, draws tangents from origin and destination, forms two candidate sub-paths, and selects one by heuristic target-guidance rules. TIG retains the same local, obstacle-by-obstacle planning philosophy but redefines waypoint generation and branch selection around a virtual ellipse and a compact heuristic score. This suggests that TIG is best understood as a refinement of the elliptic tangent planning family rather than as an unrelated planner.

A central conceptual distinction separates TIG from full tangent-graph methods. TIG does not search the whole map and does not construct a complete global graph. Instead, it expands only what is needed around the currently encountered obstacle, using local tangent intersections and heuristic pruning (Cheriet et al., 26 Aug 2025). This incremental design is the principal reason the method is reported to be much faster than conventional tangent graph methods in dense environments.

2. Geometric representation and tangent-intersection construction

The geometric core of TIG is the representation of each obstacle as an ellipse enlarged by a safety margin. In the 2025 formulation, an obstacle centered at $(x_k,y_k)$ with semi-axes $a,b$ and rotation angle $\theta$ is modeled by an inflated ellipse with added safety distance $r_{\text{safe}}$, and the planner works with a further “virtual ellipse” defined by

$$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$

This choice makes tangent-based route construction mathematically tractable while keeping the trajectory at a safer distance from obstacles (Cheriet et al., 26 Aug 2025).

At each planning step, TIG examines the direct line segment from the current node $N$ to the target $T$. If that line of sight is blocked, the algorithm selects the first collided obstacle and draws two tangents from $N$ to that obstacle. For each tangent, it computes a candidate waypoint from the intersections between the tangent line and the virtual ellipse. Because a tangent line may intersect the virtual ellipse in two points, TIG chooses the intersection point farther along the path, namely the one satisfying the criterion that the distance from the current point to the tangent point is smaller than the distance from the current point to the chosen intersection point (Cheriet et al., 26 Aug 2025).

The virtual-ellipse construction is introduced to stabilize cases in which a simpler tangent-intersection scheme can fail. The paper explicitly notes several failure modes: tangent lines may be parallel, may intersect at a poor location, or may fail to intersect at all. The virtual ellipse and the associated waypoint-selection rule are intended to handle those cases more robustly and to reduce sharp turns (Cheriet et al., 26 Aug 2025).

This obstacle model is continuous and geometric rather than grid-based. In APPATT, the same family of methods described obstacles as inflated ellipses and treated a waypoint $P_i(x_i,y_i)$ as collision-free when it lay outside the inflated ellipse (Liu et al., 2020). TIG preserves that geometric safety-envelope interpretation but shifts the operational emphasis from a more explicit origin–destination tangent construction to local tangent intersections around the current obstacle. A plausible implication is that TIG trades some global geometric completeness for lower online expansion cost.

3. Static TIG as an incremental tangent-intersection planner

The static version, S-TIG, is used when the full environment is known in advance. Its operation is incremental and resembles a best-first search, but its expansion primitive is not a grid neighbor or roadmap vertex; it is a tangent-generated waypoint (Cheriet et al., 26 Aug 2025). Initialization places the start node $S$ in CurrentSet and maintains three working sets: CurrentSet for candidate nodes or waypoints to expand, ClosedSet for explored nodes, and treatedSet for tangent points already processed.

The main loop begins by extracting from CurrentSet the node $a,b$0 with minimum heuristic value and adding $a,b$1 to ClosedSet. If $a,b$2, the planner attempts to connect $a,b$3 to a temporary target $a,b$4, initially the real target or, recursively, a generated waypoint. If the straight segment is collision-free and the turn angle is acceptable, the node is accepted as a waypoint. Otherwise, the planner identifies the first collided obstacle, draws two tangents from $a,b$5, computes a candidate waypoint from each tangent using the virtual-ellipse rule, inserts those waypoints into CurrentSet with heuristic scores, and repeats until the target is reached. The final path is then reconstructed from parent links stored in ClosedSet (Cheriet et al., 26 Aug 2025).

The heuristic used for branch selection is

$a,b$6

where $a,b$7 is the distance from the current node $a,b$8 to waypoint $a,b$9, $\theta$0 is the distance from $\theta$1 to the target $\theta$2, $\theta$3 is the number of obstacles intersecting the tangent line from $\theta$4 to $\theta$5, and $\theta$6 is a weighting parameter controlling the influence of obstacle count (Cheriet et al., 26 Aug 2025). The intended effect is explicit: shorter geometric distance is preferred, fewer obstacle interactions are preferred, and $\theta$7 balances directness against safety or feasibility. The paper states that including $\theta$8 discourages sub-paths that require many obstacle interactions, producing shorter and smoother routes and reducing the chance of dead ends or repeated tangential detours.

In the example sequence given in the paper, an initially blocked path $\theta$9 is diverted by obstacle $r_{\text{safe}}$0, which creates two tangential branches; one branch can then lead to another obstacle such as $r_{\text{safe}}$1 or $r_{\text{safe}}$2, followed by further recursion around $r_{\text{safe}}$3, until a clear chain to the target is found. The illustrated final route has the form

$r_{\text{safe}}$4

The paper summarizes this behavior as generating two sub-paths for each obstacle and using a heuristic rule to keep only the more promising one (Cheriet et al., 26 Aug 2025).

The distinction from APPATT is instructive. APPATT also generated two tangent-based sub-paths, but selected between them using four ordered priority rules: avoiding backtracking to the last avoided obstacle, minimizing collisions on the origin-tangent, minimizing collisions on the destination-tangent, and then preferring the shorter estimated sub-path (Liu et al., 2020). TIG replaces that rule cascade with the single score $r_{\text{safe}}$5, making the selection mechanism more compact.

4. Dynamic TIG in partially known and completely unknown environments

The dynamic extension, D-TIG, is designed for environments in which obstacles move, appear unexpectedly, or are initially unknown. In a partially known environment, the UAV first computes a static TIG path and then follows it while sensors continuously detect changes. If an obstacle appears or changes position and renders a sub-path infeasible, only the collided segment is replanned, while the unaffected portion of the route is retained (Cheriet et al., 26 Aug 2025). This local replanning strategy is explicitly contrasted with full recomputation of a global map.

In a completely unknown environment, only $r_{\text{safe}}$6 and $r_{\text{safe}}$7 are known initially. Planning occurs only within the sensor range $r_{\text{safe}}$8, using newly observed sub-environments. If obstacles are detected within range, tangent-based replanning is applied locally. If the next waypoint or the target lies beyond the sensor horizon, the algorithm creates a maximum range waypoint at the intersection of the line toward the target and the sensor perimeter (Cheriet et al., 26 Aug 2025). This produces a range-limited stepping behavior in which the UAV advances toward the goal while continuously updating local environment information.

Operationally, the dynamic planner runs the static planner on the currently known sub-map, moves the UAV to the next waypoint, clips that waypoint to the sensor-circle boundary if it lies beyond range, updates environmental information, and reruns the static planner from the new current position if the environment has changed (Cheriet et al., 26 Aug 2025). The retained principle is incremental tangency generation only when necessary.

APPATT’s DETG-TG variant anticipated the same broad structure. In pop-up obstacle mode, DETG-TG followed an offline path and replanned only the conflicting sub-path when a newly detected obstacle intersected the current route; in completely unknown environments, it updated environmental information at each waypoint using sensors and behaved as a local planner with limited lookahead (Liu et al., 2020). TIG’s dynamic formulation can therefore be read as a continuation of the same local replanning paradigm, but with the TIG-specific waypoint geometry and quadratic Bézier smoothing.

5. Smoothing, objectives, and feasibility constraints

The raw TIG route is a chain of waypoints and tangent intersections. Although collision-free, this polyline may contain angular turns that are not ideal for UAV kinematics. To address that issue, TIG applies a modified smoothing technique using quadratic Bézier curves (Cheriet et al., 26 Aug 2025). For each turn, the algorithm considers three successive points—previous waypoint, current waypoint, and next waypoint—creates temporary points before and after the waypoint, and uses those points as Bézier control geometry to replace the sharp corner with a smooth arc.

The quadratic Bézier segment is written in standard form as

$r_{\text{safe}}$9

Here $$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$0 and $$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$1 are adjacent waypoints and $$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$2 is the control point derived from the local turn geometry (Cheriet et al., 26 Aug 2025). The paper does not provide a more detailed closed-form derivation of the control-point placement, but it explicitly states the intended role of smoothing: to reduce abrupt heading changes, preserve UAV feasibility, and keep the curve away from obstacles. It also notes that generic smoothing methods can create collisions if applied carelessly, which is why TIG smooths waypoint sequences already produced by the geometric planner rather than arbitrary raw paths.

The planner evaluates routes using three objectives. Path length is measured by

$$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$3

The sum of turning angles is measured by

$$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$4

Algorithm execution time is measured by

$$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$5

In addition, the pseudocode for the static planner includes checks that the line segment must be clear, the turn angle must be below a threshold $$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$6, and the waypoint must not already be in treatedSet (Cheriet et al., 26 Aug 2025). These checks enforce feasibility and reduce repeated tangent exploration.

A useful comparison again comes from APPATT. That earlier method smoothed waypoint chains using cubic B-splines rather than quadratic Bézier curves, with basis functions $$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$7 through $$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$8 and an explicit matrix form for the spline segment (Liu et al., 2020). APPATT linked smoothing to maximum range constraint, minimum route leg length, and minimum turning radius. TIG does not replace those UAV-feasibility concerns; instead, it uses a different local curve family to operationalize them.

6. Reported performance, limitations, and related interpretations

The 2025 TIG paper reports strong performance across static, completely unknown, and partially known environments. In static environments, S-TIG is reported to produce paths about 11% shorter on average than competing static planners, reduce the number of turns by about 70%, and run in about 0.1 s on average, with some cases starting at 0.01 s (Cheriet et al., 26 Aug 2025). Against specific baselines, S-TIG path length is reported as about 5% shorter than A*, 6.98% shorter than PRM, 22.80% shorter than RRT*, 7.55% shorter than APPATT, and roughly comparable to Tangent Graph with about 0.18% difference. Execution time is reported as about 98.08% lower than A*, 98.29% lower than PRM, 47% lower than RRT*, 7% lower than APPATT, and 88.25% lower than Tangent Graph. Turning-angle reductions are reported as 93.39% vs A*, 65.15% vs PRM, 84.27% vs RRT*, and 35.41% vs APPATT. Representative table entries include C1, where S-TIG has path length 493.84, time 0.01 s, and turning radius 0.53, and C5, where S-TIG has path length 1004.14, time 0.02 s, and turning radius 0.14.

In completely unknown environments, D-TIG is compared with APF and APPATT. The paper reports that D-TIG reduces path length by about 20.55% vs APF, achieves roughly the same or slightly better path length than APPATT, produces far fewer turning angles, and plans in about 0.01 s on average (Cheriet et al., 26 Aug 2025). It also reports turning angles about 87% lower than APF and about 34.11% lower than APPATT. In partially known environments with pop-up obstacles, D-TIG is reported to produce about 5.63% shorter paths on average than APPATT, about 25.55% lower turning radius, and replanning times under 0.08 s. The tables show cases in which APPATT returns N/A while D-TIG still succeeds, especially in dense or changing scenes.

The paper is equally explicit about limitations. TIG does not guarantee strict global optimality, especially in dynamic environments. The method is evaluated in 2D, not full 3D. The smoothing stage may require further tuning for stronger collision guarantees. Heuristic admissibility and the best choice of the weight $$a_{\text{vir}} = a + d, \qquad b_{\text{vir}} = b + d.$$9 are identified as open questions. Scalability to richer 3D UAV scenarios is left for future work (Cheriet et al., 26 Aug 2025). These caveats also clarify a common misconception: TIG is not presented as an exact shortest-path solver, but as a fast incremental planner that trades strict global optimality for runtime, feasibility, and path smoothness.

A second misconception concerns its relationship to APPATT. TIG and APPATT are closely related, but they are not identical. APPATT reported that SETG-TG “always generates the shortest path” across its tested static instances, required less than 0.05 seconds per instance in static environments, and used cubic B-spline smoothing; in dynamic settings it reported shorter and smoother pop-up-obstacle paths than VFH, about 90% reduced replanning time, about 4% shorter path length, and successful operation in completely unknown environments with DETG-TG runtimes on the order of about $N$0–$N$1 s in the more difficult cases (Liu et al., 2020). TIG extends that line of work with a different waypoint-generation rule, a different heuristic, different smoothing, and a broader comparison set that includes A*, PRM, RRT*, Tangent Graph, APF, and APPATT itself.

Beyond UAV planning, a more abstract tangent-intersection perspective appears in optimization over manifold intersections. The method GOTD, proposed for problems of the form $N$2 subject to $N$3 and $N$4, keeps iterates on one manifold via a retraction and updates along two orthogonal tangent directions, one for feasibility and one for objective decrease (Yang et al., 21 May 2026). That work proves that intrinsic transversality and clean intersection are equivalent for $N$5 embedded submanifolds and derives a computable projection onto the tangent space $N$6 under the stated regularity conditions. It is not the UAV TIG algorithm, and the acronym TIG is not used there, but it illustrates a broader mathematical pattern in which “tangent-intersection-guided” updates are used to navigate constrained geometric structure.

In the UAV literature proper, TIG therefore denotes a specific class of local tangent-based planners: obstacles are inflated into ellipses, only the first blocking obstacle is expanded, two candidate tangential sub-paths are generated, one is selected by a target-directed heuristic, and the resulting waypoint chain is smoothed into a UAV-feasible path (Cheriet et al., 26 Aug 2025). Its significance lies less in a claim of exact optimality than in the synthesis of geometric tractability, local replanning, safety margin control, and reported real-time performance.