In this work, we study the problem of finding minimal-time collision-free paths for curvature-constrained systems with variable speed. Curvature constraints are prevalent in a variety of systems (see, e.g., [12, 28, 20, 6]). Unfortunately, determining whether a collision-free curvature-constrained path exists is NP-hard even for a planar system . As a result, this continuous problem can be discretized into a graph data structure using sampling-based  or search-based approaches , which is then queried to obtain a discrete path representing a curvature-constrained solution in the continuous space. The graph’s vertices correspond to robot configurations (i.e., -dimensional points that uniquely describe the robot’s position and orientation) and edges correspond to local motions taken by the robot.
Interestingly, the computational bottleneck in these search algorithms is a frequent computation of local time-optimal transitions between neighboring vertices, obtained using numerical optimization. Our key insight, depicted in Fig. 1, is that computing all the time-optimal transitions is both (i) computationally expensive and (ii) unnecessary for many problem instances. We introduce a novel algorithmic framework, which we call T*, that allows finding bounded-suboptimal solutions while reducing planning times by orders of magnitude compared to the state-of-the-art.
Our framework consists of three algorithmic components. The first component assumes that we have an efficient-to-compute lower bound on the cost of the optimal transition between two configurations. In Sec. VI, we demonstrate two such bounds—when the environment does not and does contain dynamics such as wind currents. The second algorithmic component is the A*-based search algorithm  that uses these lower bounds on optimal transitions, together with a user-provided approximation factor , to choose which edges to consider. Roughly speaking, the search attempts to use only transitions for which the true (computationally expensive) cost was computed while guaranteeing the bound on the quality of the solution obtained. Finally, the third component is a heuristic approach to pre-compute a small set of transitions that are likely to be used in an optimal path.
Using efficient-to-compute lower bounds on the cost of local transitions is a common technique to speed up motion-planning algorithms (see, e.g., [2, 10, 3, 21, 15]). These are used to minimize the computation time taken to compute the cost of an edge or transition, also known as an edge evaluation. Typically, edge evaluation corresponds to computing if a robot intersects an obstacle while performing some local motion (also known as collision detection ). Thus, the computationally expensive operation of edge evaluation is applied to each edge individually. Indeed, it can be shown that under some mild assumptions, these approaches allow minimizing the number of edges evaluated .
In our case, we plan in a discretized space; thus, the setting is somewhat different. There is a fixed set of transitions that can be taken from any given configuration. Since these transitions are computationally expensive to compute, it is natural to try and re-use transitions that have already been computed. The challenge is how this should be done while ensuring that the cost of the path found is within a given multiplicative bound of the cost of an optimal path.
As we demonstrate in simulation (Sec. VI), our planning framework allows to compute only a small fraction of transitions, which, in turn, allows us to reduce the runtime by several orders of magnitude compared to the state-of-the-art, especially in dynamic conditions.
Ii Related Work
We now continue to review related work on planning for minimum-time planar curvature-constrained systems. When the system is constrained to travel at a single speed, an optimal path connecting two configurations (i.e., two planar locations, each associated with its angular heading) can be computed analytically . In this setting, an optimal path, also known as Dubins path, is one of six types: RSR, RSL, LSR, LSL, RLR, and LRL, where R and L refer to right and left turns, respectively, and S refers to going straight. As the system travels at a single speed, the shortest and the time-optimal paths are identical.
The kinematic model considered in this work is the setting where the system can travel at some range of speeds but with unbounded acceleration (i.e., transitioning between low and high-speed can be done instantaneously). It is not hard to see that, in such a setting, the shortest path is attained by computing the optimal Dubins path, assuming that the system travels at the minimum speed (as the system can travel using the smallest turning radius possible and can thus better maneuver). Computing the time-optimal path requires alternating between low-speed (to allow for tighter turns) and high-speed motions (to allow for faster progress).
Wolek et al.  showed that it is sufficient to consider only the two extreme speeds and identified a sufficient set of 34 candidate paths (in contrast to the six-candidate paths when the system travels at a single speed). Each candidate path contains circular arcs and straight-line segments on which the vehicle can travel at either of the two extreme speeds. However, in contrast to Dubins paths, which can be computed analytically, computing these time-optimal paths for a variable-speed system requires a numerical optimization that is (i) much more computationally expensive and (ii) may return locally optimal solutions (and not globally optimal ones). Kučerová et al.  showed an efficient heuristic approach to find high-quality paths when considering time as the cost function by using multiple turning radii. However, there is no guarantee regarding the quality of these paths.
For each model mentioned above, motion-planning algorithms that account for environmental obstacles were introduced. These include both sampling-based approaches such as the work by Wilson et al. , search-based methods such as the work by Song et al. , and hybrid methods that borrow ideas from both motion-planning disciplines . Of specific interest to the presented work is T* , a time-optimal risk-aware motion-planning algorithm that obtains a time-optimal solution but requires a time-consuming preprocessing phase. As our work builds upon the algorithmic foundation of T*, we describe it in Sec. IV. Following T*, Wilson et al.  developed a fast motion-planning algorithm that uses Dubins paths of various speeds to reduce the computational effort and runtime of T*. For the settings evaluated, the costs of solutions obtained by this algorithm are near-optimal, but there are no guarantees regarding the quality of solutions.
The aforementioned kinematic model can be extended to account for external dynamic changes such as wind or ocean currents. For such systems, a minimum-time path can be computed similarly to the setting where no wind exists . However, only two candidate path types have analytic solutions (RSR and LSL). Mittal et al.  used those two types to compute a path between two vehicle poses under ocean currents. These kinematic models were used not only in the context of single-goal motion planning problems but also in the settings where the objective is to reach multiple goals  and further extended to account for some notion of rewards .
Iii Problem Statement
Our problem formulation follows Song et al. . Specifically, we assume a variable-speed curvature-constrained planar robotic system with unbounded acceleration. The system’s dynamics can be described by
Here, is the robot’s placement and orientation, is the robot’s speed (which is considered as a control input) and is the second control input dictating the system’s turning rate via maximal lateral acceleration that is determined for the specific system111For example, for fixed-wing vehicles, where is the gravitational acceleration and the maximum allowed bang angle. as
The speed is limited by some minimum and maximum values denoted by and , respectively. W.l.o.g., we assume that . Thus, the system is constrained to travel between two extreme radii:
We assume that the continuous workspace is discretized into a grid according to a predefined resolution. Each cell can be categorized as free or forbidden corresponding to locations that the system can and cannot occupy, respectively. In addition, we assume that every robot motion starts and ends at the center of a cell. Specifically, at each step, the robot transitions to one of its eight neighbors and with one of eight possible orientations.
A path is a sequence of configurations where the transition between them obeys the system’s dynamics and constraints (Eq. 1). It is said to be collision free if it only occupies free cells. The cost of a path is the step-wise cost of the transitions between any consecutive configurations in . It can be computed using the system velocity along . Namely,
where refers to the speed along the path segment .
Given start and goal configurations , a collision-free path is said to be optimal if it (i) starts at and ends at ; and (ii) there is no path connecting and such that . Similarly, it is said to be bounded-suboptimal for some approximation factor if it (i) starts at and ends at ; and (ii) for any path connecting and , .
While previous works (see, e.g., ) were concerned with finding optimal paths, in this work, we are interested in finding bounded-suboptimal paths for a user-provided approximation factor . As we will see, the extra flexibility obtained by finding bounded-suboptimal paths allows us to reduce running times by orders of magnitude with little compromise on the path quality in practice.
Iv Algorithmic Background
Iv-a A* A-star epsilon)
A* (also known as Focal search)  is a bounded-suboptimal search algorithm based on the celebrated A* algorithm . Like A*, it searches a graph by continuously expanding nodes, starting from the start node until the goal node is reached. To ensure optimality, A* orders nodes in a priority list called Open. Nodes in the Open list are ordered according to their -value that is the sum of the cost to reach the node from the source (also known as the cost-to-come or -value and denoted by for a node
) added to a conservative estimate of the cost to reach the goal (also known as the cost-to-go or-value and denoted by for a node ). Namely for a node , its -value is
Unlike A*, A* also uses a so-called Focal list containing all nodes from the Open list whose -values are no larger than times the smallest -value in the Open list. It can be shown that expanding any sequence of nodes from the Focal list ensures that the cost of the final solution will indeed be bounded by a factor of when compared to the cost of the optimal solution.
Iv-B T* (T-star)
T*  builds on the approach by Wolek et al.  that allows finding an optimal222 To be precise, the solutions computed are only an approximation of the time-optimal solutions since the computation is based on numerical optimizations, which may not converge to a global optimum. Thus, the optimality of T* and the bounded-suboptimality of T* is only with respect to (w.r.t.) the quality of the local-optimization. solution for the time-optimal transition between any two configurations in an obstacle-free space. These transitions are used to compute all possible motions for an agent in a discretized eight-connected grid. In this space, there is a finite set of possible transition types. For example, a transition can be moving from configuration to configuration , which corresponds to moving diagonally in the NE direction while changing the system’s heading.
To this end, there are a total of possible transitions (eight possible start and target orientations and eight neighboring cells). However, after accounting for symmetry and rotation, there are only 68 unique transitions.
After pre-computing all possible transitions, an A*-like search is used to find a minimal-cost path. In their original work, Song et al.  consider both minimal-time paths and a cost-function that balances the time and the risk of colliding with an obstacle. However, we consider only minimum-time paths in this work and refer to T* as the search algorithm that optimizes this criterion.
It is important to note that in many settings it is not possible to pre-compute all transitions in an offline phase. This is because optimization-related parameters might be available only when a query is provided. For example, in the presence of wind conditions, which affect the system’s dynamics and hence the transitions’ computation, wind parameters are only available to the planner when a query is provided. For further details, see Sec. VI.
Interestingly, after extensive empirical evaluation, we noticed that: (i) pre-computing all possible transitions last two orders of magnitude more than the A*-like search; (ii) only a small fraction of all possible time-optimal transitions are part of an optimal path found by T*; and (iii) Dubins path computed using the minimal speed (whose cost is a lower bound on the length of the time-optimal path) is often in the same homotopy class as the optimal path and shares a significant portion of its transitions. These observations are key to our algorithmic framework described in the following section.
V Algorithmic framework—T*sec:tstareps
Let denote a set of possible transitions. By a slight abuse of notation, we assume that we have access to two functions and . The first, which is expensive-to-compute, corresponds to evaluating the true cost of the transition according to Eq. 4. The second, which is fast-to-compute, corresponds to evaluating a lower bound on the transition cost. Namely, . Once the cost of a transition is evaluated using , the value is stored in a cache-like data structure for later use. Thus, there is no need to compute it again when evaluating the same transition later.
To this end, let be an indicator function corresponding to the cases where the cost of a transition (i) has not been evaluated using , i.e., or (ii) has been evaluated using , i.e., . We start our algorithm with the setting that .333The reason we chose to define in this manner is that we start with for all nodes and order nodes lexicographically in the Focal list where lower means better.
V-B Algorithmic Description
Our algorithmic framework, summarized in Alg. 1, consists of the following two main steps.
Heuristically computing the true cost for a small set of transitions.
Finding a bounded-suboptimal solution while trying to minimize the number of calls to .
In the first step S1 (lines LABEL:tstareps-shortest–LABEL:tstareps-update_kappa), we start by finding the shortestcollision-free Dubins path (line LABEL:tstareps-shortest) from to that uses the minimum speed . For every transition taken along this path, we compute its true cost , cache it, and set (lines LABEL:tstareps-for_each_transition–LABEL:tstareps-update_kappa).
In the second step S2 (lines LABEL:tstareps-astareps–LABEL:tstareps-set_g), we run an A*-like search to find a bounded-suboptimal path from to given some approximation factor . We base our search algorithm on A* because we can use it to heuristically guide the search to expand nodes for which the incoming time-optimal transition has already been computed.
Formally, each node considered by the search is associated with a parent node except for the start node associated with , which has no parent. In addition, each node stores the time-optimal transition used to get from to . When expanding a node (namely, computing successor nodes and inserting them into the OPEN list), the true cost of the time-optimal transition leading to is computed. However, the cost used to reach a successor node via transition is (i) if and (ii) if . Note that for some nodes in the Open list, the true cost of the time-optimal transition associated with them may not have been computed. However, for all expanded nodes, the true cost of the incoming time-optimal transition is computed at some point.
To this end, if we set to be the cost-to-come (-value) of the start node, then the cost-to-come of any other node in the Open list is
The -value of the node (denoted by and used to prioritize nodes in the Open list) is defined in Eq. 5. can be any admissible estimate of the cost to reach the goal. In our setting, we use the length of the minimum speed Dubins path divided by the vehicle’s maximum speed.
Recall (Sec. IV) that A* uses a Focal list that contains all nodes whose -value is at most times the -value of the minimal-cost node in the Open list. In our setting, nodes in Focal are lexicographically sorted using the following key (from low to high):
Thus, any node for which (i.e., the true cost of the transition leading to has been computed) is always prioritized before any node for which (i.e., the true cost of the transition leading to has not been computed), regardless of their respective -values. Among all nodes with identical values of , nodes with smaller -values are prioritized. Once a node is chosen for expansion, the true cost of is computed if it has not been computed beforehand. Finally, a path is found once a node associated with the goal configuration is removed from the Open list.
Following the theoretic properties of A*  and using the fact that we have the following Corollary.
Let and be some function that bounds from below the true cost of any time-optimal transition. T*, using is bounded-suboptimal with an approximation factor of .
In this section, we report on empirical evaluation of our approach in a simulated environment inspired by Song et al. . We start (Sec. VI-A) by evaluating our heuristic approach for computing the true cost for a small set of transitions (step S1). Then we continue (Sec. VI-B) to demonstrate how the lower bound needs to be both informative (i.e., as close as possible to the real cost ) and computationally cheap-to-compute (as its main purpose is to save computation time) by evaluating several different lower bounds that balance these two traits. We then move to compare our motion-planning approach with T* in static environmental conditions (Sec. VI-C), i.e., when the system dynamics are known before the query is provided and are independent of the specific location at which the robot resides, and in dynamic environmental conditions such as when wind currents exist (Sec. VI-D). Finally, we briefly discuss and qualitatively compare T* with alternative approaches to find paths that attempt to minimize the execution time (Sec. VI-E).
All experiments were run on a Intel Core i9 processor with of memory. Benchmarks, system parameters, and C++ implementation of all the algorithms used in our work are publicly available444 https://github.com/CRL-Technion/tstar-epsilon.. Throughout Sec. VI-A–VI-C, we test the performance of our algorithm across randomly generated scenarios of cells and using
, where for a given scenario, each cell has a probability ofof being blocked, and the start and goal configurations are chosen uniformly at random while ensuring that a solution exists. When reporting algorithmic attributes, e.g., solution cost or runtime, the values represent the average across the VI-D, we provide additional information on the experiment setup.
Vi-a Evaluating the Efficacy of step S1
To evaluate the efficacy of the step S1, wherein we provide a heuristic approach for computing the true cost for a small set of transitions, we report the number of calls to by T* as a function of the approximation factor with and without this initial step (Fig. 2).
Observe that for values of larger than , using S1 allows reducing the average number of calls to by roughly . Moreover, in this case, for large approximation factors, the average calls to converges to the number of transitions in . When the step S1 is not invoked, T* is not “bootstrapped” with a good set of pre-computed time-optimal and thus evaluates unnecessary transitions.
Vi-B Computing Lower Bounds—Balancing Computation Time with Informative Lower Bounds
Recall that in Sec. LABEL:sec:tstareps, we assumed that we have access to —an efficient-to-compute tight lower bound on , the true cost of the time-optimal transition. However, there is an inherent tradeoff between how informative a lower bound is (which immediately corresponds to how accurately it can guide the search) and its computation time (which can negate the effectiveness of the lower bound).
We evaluated T* using three different lower bounds that demonstrate this behavior: (i) Euclidean distance divided by ; (ii) length of minimum-speed Dubins path divided by ; and (iii) length of minimum-speed Dubins path divided by while accounting for environment obstacles. Note that all lower bounds are divided by , thus always underestimating the true cost of a transition. In addition, they are ordered from low to high according to their computation time and how informative they are.
We compare (Fig. 3) the three lower bounds w.r.t. the number of time-optimal transitions computed by T* and its running time. As expected, the Euclidean distance is the least-informative lower bound, thus resulting in the maximal number of time-optimal transitions computed for all values of . Moreover, even though it is efficient-to-compute, it does a poor job in guiding the search, and thus the runtime is high. Computing Dubins path while accounting for obstacles is more informative but also more expensive-to-compute. It does result in the smallest number of calls to but has longer running times when compared to using Dubins paths that do not account for obstacles. The latter also has a comparable number of calls to . Thus, we use Dubins paths without obstacles as the lower bound in the rest of the evaluation.
Vi-C Motion Planning in Static Environmental Conditions
We compare T* with T* in static environmental conditions, i.e., where the system dynamics are invariant to the robot’s placement and orientation in the scenario. As we can see in Fig. (c)c, computing time-optimal transitions dominate the running time of all algorithms. If the system dynamics are known in advance, these can be pre-computed in an offline step by T*, and it outperforms T* for all by a factor of between and . However, if we account for this preprocessing time, T* dramatically reduce the run time by a factor ranging between and . It is worth noting that in either case, T* finds a solution with an average cost that is much lower than the guaranteed suboptimality bound.
Vi-D Motion Planning in Dynamic Environmental Conditions
In the previous section, we considered static environmental conditions and showed that using an approximation factor allows reducing T*’s planning times dramatically. However, if the system’s dynamics are known in advance, T* may perform all its computationally-expensive operations in a preprocessing stage. In contrast, this is not the case when the system’s dynamics are not known in advance. It can be due to changes in the maximal speed that the system can take (due to, e.g., payload changes of the system or regulatory changes happening just before a query is received) or due to dynamic environmental conditions such as wind currents whose magnitude and direction is known only when a query is received. We use the latter case to demonstrate the efficacy of T*. In particular, we assume that the magnitude of wind currents is uniform across a given scenario.
It is worth noting that this dynamic setting, analyzed by Techy and Woolsey , can be seen as a generalization of the setting described in Sec. III and by Mittal et al. . To account for this more-involved dynamic setting, we first note that one cannot use rotation and symmetry between transitions to reduce the total amount of unique transitions. Thus, in this setting, the total number of time-optimal transitions is 512. Moreover, this requires an adaptation of how time-optimal transitions are computed (see the Appendix for a description of the new model). This adaptation, based on the code for computing time-optimal transitions , is publicly available555https://github.com/CRL-Technion/Variable-speed-Dubins-with-wind. The second notable change is that computing lower bounds (namely, when calling , requires some care, and the modifications are detailed in the Appendix.
For dynamic environmental conditions, we used the same randomly generated scenarios as described earlier. For each such scenario, we generated instances with varying wind and minimum velocity values. In particular, we sampled wind conditions from and minimum velocity values . In total, we ran experiments and the averaged results appear in Fig. 5. The most computationally demanding component in both T* and T* is still computing the time-optimal transitions, which requires two orders of magnitude more time than any other algorithmic component. However, we observe that the approximation factor allows for a dramatic reduction of the running time with little compromise on the quality of the solution. For example, as it can be seen in Fig (c)c, using , T* guarantees a solution whose cost is at most twice the cost of the optimal solution, but returns a path whose average cost is no more than . It is done while obtaining a speedup in run time by an average factor of . In general, as depicted in Fig. (c)c, increasing results in a dramatic running-time improvement at the cost of slightly lower solution quality.
Vi-E Discussion—Alternative Approaches
Wilson et al.  reduced computational effort by allowing the system to follow Dubins paths but using several radii, and evaluated this approach when using three different radii. This heuristic approach reduces runtime, produces near-optimal solutions but with no guarantees regarding their quality. From our comparison of T* and Wilson’s model in static environments, we found that running times are faster by several orders of magnitude, but path costs are larger by an average of . However, when evaluating their approach in windy conditions, the speedup in running time is comparable to T* (as local transitions cannot be computed analytically and a computationally expensive root-finding problem needs to be solved ), and the quality of paths remain higher (again, with no formal guarantees).
An alternative approach is to compare our work with the approach by Mittal et al.  that specifically accounted for efficient computation of paths in dynamic environments. However, the main objective of their approach is online motion-planning under ocean currents, and no importance was given to the quality of paths. When comparing T* with their approach on representative environments, the path quality obtained by T* was higher (lower execution times) by a factor of more than .
Vii Conclusions and Future Work
In this work, we present T*, a novel algorithmic framework for efficiently finding bounded-suboptimal solutions for time-optimal motion-planning. This is done by minimizing the number of computations of time-optimal transitions used by the system. When one cannot pre-compute the time-optimal transitions in advance, this reduces the planning times by orders of magnitude compared to the state-of-the-art.
Future work includes adapting our work for efficient re-planing (e.g., when the wind changes while the system is in motion or dramatic payload changes during trajectory execution changing the system’s constraint). Here, we plan to adapt LPA*  to account for minimizing the number of transitions used.
Another natural extension is to account for settings when the approximation factor cannot be determined a priori by the user. Here, it is natural to use an anytime  approach. Instead of providing a fixed , the user would provide an upper bound for the algorithm’s running time. We suggest starting with an initially high value of the approximation factor to compute an initial solution quickly and then progressively decreases as the time permits while reusing transitions computed in earlier search episodes.
To consider the setting where we need to account for wind currents, we detail the updated dynamics model and present two approaches to compute lower bounds on transitions cost-efficiently.
Vii-a Updated Model
We assume that there is a constant wind that changes the original system dynamics (Eq. 1) to
Furthermore, we assume that regardless of the magnitude of the wind, the vehicle will move forward. It is ensured by the additional assumption that the wind magnitude is smaller than the minimum speed of the system , i.e.,
Vii-B Updated Lower Bounds
The wind component may significantly influence the turning capabilities (in the reference frame of the ground). The smallest turning radius is obtained when flying directly against the wind. We denote it by , the lower bound radius, and have that
To this end, a lower bound on the true length of the path between two configurations and can be determined based on the length of Dubins path with the lower bound radius . Now, if this value is divided by an upper bound on the effective maximal speed in the reference frame of the ground, it provides a lower bound on the true cost (i.e., the travel time).
We suggest two lower bounds based on how is determined. The first approach assumes that . Namely, the effective maximal speed is the sum of the system’s maximum speed and the wind magnitude. Thus, the first lower bound is defined as
The second lower bound considers the direction between the start and end configurations ( and , respectively) by computing the ground speed in the given direction . The direction is determined based on the configurations and as , where stands for the coordinates of the configuration . The ground speed vector can be expressed by the system’s aerial speed and wind as .
Following Eq. 9, the maximum ground speed occurs at the system’s maximum speed, i.e., . The angle between and can be written as Subsequently, the ground speed can be expressed using the cosine rule as Finally, the second lower bound is defined as
Fig. 6 shows the average ratio between each lower bounds and the true cost as a function of the wind force. For both lower bounds, their estimation of the true cost becomes looser as the wind force increases. Notice that is more informative than because accounting for the direction enables reducing the upper bound on the ground speed. In addition, notice that both lower bounds reduce to the system’s minimum-speed Dubins path divided by the maximum speed in static environmental conditions. Thus, we used as lower bound for dynamic environmental conditions.
-  (2002) Curvature-constrained shortest paths in a convex polygon. SIAM J. Comput. 31 (6), pp. 1814–1851. Cited by: §I.
-  (2000) Path planning using lazy PRM. In ICRA, Vol. 1, pp. 521–528. Cited by: §I.
-  (2016) A unifying formalism for shortest path problems with expensive edge evaluations via lazy best-first search over paths with edge selectors. In ICAPS, Vol. 26. Cited by: §I.
-  (1957) On curves of minimal length with a constraint on average curvature, and with prescribed initial and terminal positions and tangents. Am. J. Math. 79 (3), pp. 497–516. Cited by: §II.
-  (2017) On solution of the dubins touring problem. In ECMR, pp. 1–6. Cited by: §II.
-  (2009) Path planning for autonomous underwater vehicles in realistic oceanic current fields: application to gliders in the western mediterranean sea. J. Marit. Res. 6 (2), pp. 5–22. Cited by: §I.
-  (2018) The provable virtue of laziness in motion planning. In ICAPS, Vol. 28. Cited by: §I.
-  (2007) Anytime heuristic search. J. Artif. Intell. Res. 28, pp. 267–297. Cited by: §VII.
-  (1968) A formal basis for the heuristic determination of minimum cost paths. IEEE Trans. Syst. Man Cybern. 4 (2), pp. 100–107. Cited by: §IV-A.
-  (2015) Lazy collision checking in asymptotically-optimal motion planning. In ICRA, pp. 2951–2957. Cited by: §I.
-  (2004) Lifelong planning A*. Artif. Intell. 155 (1-2), pp. 93–146. Cited by: §VII.
-  (2011) Toward robotic needle steering in lung biopsy: a tendon-actuated approach. In Medical Imaging: Image-Guided Procedures, Vol. 7964, pp. 79641I. Cited by: §I.
-  (2021) Variable-speed traveling salesman problem for vehicles with curvature constrained trajectories. In IROS, pp. 4714–47194714–4719. External Links: Cited by: §II.
-  (2006) Planning algorithms. Cambridge University Press. External Links: Cited by: §I.
-  (2019) Generalized lazy search for robot motion planning: interleaving search and edge evaluation via event-based toggles. In ICAPS, Vol. 29, pp. 745–753. Cited by: §I.
-  (2020) Rapid path planning for dubins vehicles under environmental currents. Robotics Auton. Syst. 134, pp. 103646. Cited by: §II, §VI-D, §VI-E.
-  (1982) Studies in semi-admissible heuristics. IEEE Trans. Pattern Anal. Mach. Intell (4), pp. 392–399. Cited by: §I, §IV-A, §IV, §V-B.
-  (2019) Physical orienteering problem for unmanned aerial vehicle data collection planning in environments with obstacles. RA-L 4 (3), pp. 3005–3012. Cited by: §II.
-  (2013) Robot motion planning with dynamics as hybrid search. In AAAI, Cited by: §II.
-  (2016) Planning for autonomous cars that leverage effects on human actions. In RSS, Vol. 2, pp. 1–9. Cited by: §I.
-  (2016) Asymptotically near-optimal RRT for fast, high-quality motion planning. IEEE Trans. Robotics 32 (3), pp. 473–483. Cited by: §I.
-  (2018) T: time-optimal risk-aware motion planning for curvature-constrained vehicles. RA-L 4 (1), pp. 33–40. Cited by: Fig. 1, §II, §III, §III, §IV-B, §IV-B, §IV, §VI.
-  (2009) Minimum-time path planning for unmanned aerial vehicles in steady uniform winds. J. Guid. Control Dyn. 32 (6), pp. 1736–1746. Cited by: §II, §VI-D, §VI-E.
-  (2010) Near optimal path planning for vehicle with heading and curvature constraints. In WCICA, pp. 4514–4519. Cited by: §I.
-  (2019) Novel motion models for time-optimal risk-aware motion planning for variable-speed AUVs. In OCEANS MTS/IEEE, pp. 1–5. Cited by: §II, §VI-E.
-  (2020) T-lite: a fast time-risk optimal motion planning algorithm for multi-speed autonomous vehicles. In OCEANS MTS/IEEE, pp. 1–6. Cited by: §II.
-  (2016) Time-optimal path planning for a kinematic car with variable speed. J. Guid. Control Dyn. 39 (10), pp. 2374–2390. Cited by: §II, §IV-B, §VI-D.
-  (2011) Development of a low-cost agricultural remote sensing system based on an autonomous unmanned aerial vehicle (UAV). Biosystems Engineering 108 (2), pp. 174–190. Cited by: §I.
-  (2015) A survey on path planning for persistent autonomy of autonomous underwater vehicles. O.E. 110, pp. 303–313. Cited by: §I.