Available online at www.sciencedirect.com
ScienceDirect Procedia CIRP 67 (2018) 24 – 29
11th CIRP Conference on Intelligent Computation in Manufacturing Engineering, CIRP ICME '17
Iterative path adaption (IPA): Predictive trajectory-estimation using static pathfinding algorithms Felix Gaisbauera,c,*, Philipp Agethena,c, Rüdiger Lundeb, Enrico Rukzioc a Daimler AG, Wilhelm-Runge-Str. 11, 89081 Ulm, Germany Ulm University of Applied Sciences, Prittwitzstraße 10, 89075 Ulm, Germany c Ulm University, James-Franck-Ring, 89081 Ulm, Germany
b
* Corresponding author. Tel.: +49-731-5052414; E-mail address:
[email protected]
Abstract Nowadays the automotive industry is facing a growing demand for mass customization, while continually extending the product range in order to remain competitive. This trend leads to a higher diversity of the assembly processes and consequently to a rising complexity for production planning. Non-value-adding tasks are usually considered within the efficiency assessment of assembly lines. Since these are primarily walking tasks, it is becoming increasingly important to simulate realistic two-dimensional trajectories of assembly operators. However, most tools being currently used for that purpose are primary based on static path planners which do not consider dynamic obstacles. Consequently, simulated walk paths may significantly differ from their corresponding plan or even lead to collisions. Moreover, recent works present dynamic path planners generating trajectories while avoiding collisions in a dynamic environment. However, these approaches are not broadly available since their higher code complexity showed to be a major hurdle for commercial planning tools. In order to bridge the gap between widely spread static and primarily neglected time-dynamic planners, this paper contributes to a utilization of static path planners in dynamic environments. While maintaining the simplicity of static path planners, the novel heuristic method allows to model the time sensitive change of the surrounding regardless of the specific path planner implementations. The validity of the proposed approach has been proven using 5000 procedurally generated test scenarios. Moreover, the benefits of the proposed method were further outlined in an exemplary use case, representing a realistic production scenario. ©2017 2017The The Authors. Published by Elsevier B.V. © Authors. Published by Elsevier B.V. This is an open access article under the CC BY-NC-ND license Peer-review under responsibility of the scientific committee of the 11th CIRP Conference on Intelligent Computation in Manufacturing (http://creativecommons.org/licenses/by-nc-nd/4.0/). Engineering. under responsibility of the scientific committee of the 11th CIRP Conference on Intelligent Computation in Manufacturing Engineering Peer-review Keywords:Dynamic path planning; Factory planning; Intelligent agent; Artifical intelligence; Production planning; A*; Lazy theta*
1. Introduction Trying to keep up with market demands for mass customization, automotive industry is currently producing an increasing number of model variants on mixed-model assembly lines [1]. This development induces a rising complexity for production planning departments, since assembly tasks within one assembly station may vary for each produced car. Therefore, tools enabling a realistic and efficient simulation of actual human work in an assembly line are becoming increasingly important. However, numerous traditional planning models tend to decreasingly reflect reality due to changing preconditions - especially for walk path of assembly operators (see [2]). Consequently, it is crucial to apply tailored
planning models to ensure accurate assembly plans. Tools being currently used for walk paths simulation (i.e. [3]) rely on algorithms calculating a collision-free humanlike trajectory between a start and an end point. In particular, two-dimensional path planner such as A* [4] or Lazy Theta [5] are mainly utilized. These approaches, however, do not consider the movement of dynamic obstacles (i.e. cars), thus under/overestimating walk paths length to a large extent (see [2]) as depicted in Figure1. Apart from the time-static path planner, literature presents various approaches (such as [6,7]) generating trajectories while explicitly avoiding collisions in a dynamic environment.
2212-8271 © 2017 The Authors. Published by Elsevier B.V. This is an open access article under the CC BY-NC-ND license (http://creativecommons.org/licenses/by-nc-nd/4.0/). Peer-review under responsibility of the scientific committee of the 11th CIRP Conference on Intelligent Computation in Manufacturing Engineering
doi:10.1016/j.procir.2017.12.170
Felix Gaisbauer et al. / Procedia CIRP 67 (2018) 24 – 29
Fig. 1. A global collision free walk path computed in a dynamic scene using the IPA approach (black line) against a collision-afflicted path planned with static assumptions (red dotted line).
However, these approaches are not broadly available since their higher code complexity showed to be a major hurdle for commercial planning tools. This paper presents a novel approach enabling static path planners to calculate collision-free trajectories while considering the movement of dynamic obstacles. The proposed system consists of an arbitrary static planning algorithm being wrapped with a novel, so-called "Iterative Path Adaption" (IPA) component. The latter introduces time as an additional dimension by successively updating the position estimations of dynamic obstacles. Therewith, any static path planner can be used out-of-the-box to generate collision free paths in dynamic two-dimensional environments. The remainder of the paper is structured as follows: First, the state of the art in the context of two-dimensional path planning is reviewed. Second, a novel approach is described being able to determine a collision-free two-dimensional path in dynamic environments using static path planning algorithms. Consecutively, the applicability and technical performance of the proposed method is verified within a holistic evaluation. The paper concludes with an outlook on further optimization potentials. 2. State of the art Path planning has been the subject of intense research and is applied in a vast variety of domains ranging from robotics [8] to crowd simulation [9], computer games [10] and production planning [3]. Independent of the specific use cases the problem of finding a collision free shortest path is oftentimes interpreted as a graph search problem. By discretizing the configuration space into connected nodes, the shortest paths can be computed using algorithms like Dijkstra [11] and A* [4]. Utilizing these approaches, the results are oftentimes unnatural due to the discretization of the space [1]. Using any angle path planning algorithms like Lazy Theta* [5], the paths can be computed without the restrictions of the grid structure in order to obtain more realistic and shorter paths. Literature proposes several approaches which can be further classified (see Gasparetto et al. [12]) into roadmap-techniques (see [13,14]), cell decomposition (i.e. [4][5,15]) and potential field based approaches [12]. For usage in high dimensional state spaces there are also probabilistic approaches applied, which cover probabilistic roadmaps [16] and rapidly exploring random trees [17]. In general most of the static path planners are easy
25
to use, time efficient and the knowledge is widely spread. Nevertheless, those types of planners are not directly applicable to dynamic environments, since the environment is usually initialized once and never updated during the planning process. Consequently, these kind of planner algorithms are not suited for a dynamic car assembly shop floor. Apart from the time-static path planner, previous works present a wide range of time-dynamic path planners which can be modeled with different approaches. The simplest way to handle path planning in dynamic environments is to treat dynamic as static objects (see [18]). Hence the computation of a path can be achieved with the above mentioned approaches. Using this simplified assumption, the dynamic behavior of the obstacles and agents are not explicitly considered, thus leading to unnatural walk paths which might not be feasible for an agent [19]. On the other hand, natural paths can be achieved using approaches such as [20] [6] [7] by explicitly considering the time and velocity of the obstacles. Using these dynamic planning methods, the dynamic shop floor environments can be modeled in principle. Nevertheless, the planners in this category are not broadly available and complex to setup. Additionally, aspects like line of sight checks which can improve the naturalness of paths (see [5]), are not covered within these algorithms. Utilizing the benefits of the static path planners, the proposed approach can cover these aspects in dynamic environments. 3. Approach The main concept of the proposed approach is to reuse existing and well established algorithms for static path planning and encapsulating them in an additional component driven by an algorithm called Iterative Path Adaption (IPA). Independent of the specific implementations of the path planners, the proposed method allows a high-level incorporation of dynamic environments using an iterative repair function based on obstacle collision time estimations. Figure 2 shows the idea of the proposed method which can be interpreted as an additional component between the scene graph representation and the specific implementations of the path planning algorithms.
Fig. 2. Illustration of the principle idea of the IPA-algorithm. The algorithm represents an additional component between the static path planner implementation and the scene graph, enabling the static implementation to plan in dynamic environments.
26
Felix Gaisbauer et al. / Procedia CIRP 67 (2018) 24 – 29
Within this component, the positions of the obstacles are predicted according to a time estimation model, sub-paths are computed utilizing path planners and further merged together to a single global and collision free trajectory. Since the IPA component predominantly encapsulates the scene graph states, any path planners which are based on a scene graph representation can be used without the need of further implementation adaptions.
The hereby obtained trajectory is further incorporated into the global path Pref, allowing to consider the improved path for the computation of ܲ for the succeeding obstacles. To avoid the re-planning of the complete trajectory in each step, the computation of the path always starts at the endpoint of the last step (if available). Figure 4 shows the schematic program code of this algorithm.
3.1. Algorithm Running the IPA algorithm, initially, the dynamic object positions are estimated based on the line of sight distance from the starting position of the agent. The required time to reach the corresponding obstacle is estimated by utilizing an a priori known agent velocity profile. Following Brogan and Johnson [21], the desired speed can be defined with 1.36 m/s, whereas acceleration and deceleration can be modeled as a linear function of distance to the goal. Knowing the rough distance, an expected mean velocity can be computed. Given the position and the mean velocity of the agent va, the expected time is computed with ݐ ൌ หȁ െ ȁหȀݒ , whereas หȁ െ ȁห defines the line of sight distance between the obstacle and the agent. Once the roughly estimated time is approximated, the corresponding obstacles are translated according to the determined travel time ta (see Figure 3). In this paper, it is assumed that the obstacles move with a constant velocity due to the fixed speed of cars in the assembly line, however arbitrary velocity profile assumptions can be used. After updating the obstacle positions, a global path Pref is computed using a static path planning algorithm considering the updated scene representation. Since the exact trajectory and thus the passing points are not known a priori, this first guess is error prone and the computed path might be collision afflicted. To further improve the path, it is adjusted in an iterative manner. Based on the reference path Pref, the time estimations for reaching the individual objects are updated. Therefore, all dynamic obstacles are traversed in ascending order of their distance to the agent. For each obstacle an updated passing time is computed using a so called critical point ܲ which is determined based on the trajectory Pref .Using this critical point, the time estimation can be updated and the path is subsequently recomputed.
Fig. 3. Illustration of the initial position prediction procedure. The future position of the obstacles is estimated based on the expected travel time and the velocity of the corresponding obstacles.
Fig. 4. Schematic program code of the IPA-algorithm.
3.2. Critical Point Estimation An important aspect of the proposed method is the determination of the so called critical point (see Figure 5). Depending on the motion of the obstacle and agent, the critical point is the closest/furthest point of an object geometry which causes a collision with the planned trajectory under given time constraints. In order to determine the critical point, the intersection point of the velocity vector of the dynamic obstacle and the planned path is computed. Using the velocity vector of the corresponding obstacle and a discretized contour, each contour point can be tested for an intersection by extending the contour positions with a vector representing the maximum prediction time. The quality of the obtained results strongly corresponds to the resolution of the contour points.
Fig. 5. Estimation of the critical point Pc which leads to a collision under given time constraints at time Tc. The point is defined as the first/last point that forces a collision with the computed path Pref.
27
Felix Gaisbauer et al. / Procedia CIRP 67 (2018) 24 – 29
While a high density of contour points is leading to a more accurate computation of the critical point, it also implies additional computational effort. The actual determination of the critical points is done iteratively. If no intersection point is determined or within a specified threshold - the point is skipped. If the time the obstacle requires to reach this intersection point is below the time the agent needs to reach the intersection point - a potential collision has been detected. If the dynamic object is moving away from the trajectory -the critical point is defined to be the closest point which causes a collision - otherwise it is specified as furthest point. 4. Evaluation To validate the proposed approach, it was compared using two different evaluation methods, represented by a procedural and a use case specific evaluation. 4.1. Procedural Evaluation Based on a procedural evaluation, the general performance and validity of the IPA approach has been examined. This procedural method enables a holistic evaluation, whereas properties concerning collision, path length and path shape can be determined. The performance of the novel algorithm was compared to a time-dynamic state of the art path planner based on 5000 procedurally generated scenarios. To further evaluate the influence of specific path planners incorporated into the IPA approach, combinations with different static path planning algorithms have been examined. 4.1.1. Experimental Setup To allow a meaningful assessment of the proposed methodology, a generic evaluation framework has been set up. Since testing of specific predefined scenarios might overlook individual aspects, a procedural world generation has been chosen. The implemented framework allows a randomized generation of environments with dynamic and static obstacles with different start- and endpoints, varying the velocities, directions, sizes and scene dimensions. The framework has been used to evaluate the proposed algorithm against a timedynamic algorithm, which models the time as an explicit dimension in state space using collision-free time intervals [20]. The so called SIPP algorithm incorporates the obstacle trajectories directly in the grid space, thus allowing a proactive consideration of dynamic obstacles. Due to the guarantee of completeness and optimality, the algorithm is a suitable approach for comparing the validity of the novel method. Since the SIPP algorithm uses an A* graph search algorithm to determine the shortest paths, the IPA-approach has been evaluated with a static A* implementation to allow a direct comparison. In addition to this, the IPA-method has been evaluated with Lazy Theta* and Visibility Graph implementations used from a *
a
https://github.com/Ohohcakester/Any-Angle-Pathfinding.
4.1.2. Design of experiments The evaluation was performed with 5000 test scenarios using scene dimensions ranging from 5.00 m to 25.00 m in which random rectangular shaped obstacles with diameters between 0.40 m and 5.00 m occur. The ratio between static and dynamic obstacles was evenly distributed, whereas the amount was scaled according to the scene dimensions. Since a usual car assembly shop floor mainly consists of obstacles with velocities around 0.05 m/s, the velocities of the dynamic obstacles were chosen between 0.05m -0.50 m/s. The cell size of the global path planners was set to 0.05 m, whereas the contour resolution of the obstacles was set to 0.01 m. The maximum prediction time of the IPA approach was set to 30 seconds. The velocity of the agent was defined at 1.36 m/s as proposed in [21], while the velocity profile was fixed at this value. For validating whether a collision occurs, the computed trajectories were traversed with the fixed mean velocity. The subsequent analysis only considers environments, where the SIPP implementation was able to compute collision free paths and in which no waiting actions occurs. Moreover, only environments in which a static A*-implementation caused collisions were further regarded. 4.1.3. Results Since the scope of the procedural evaluation is to verify whether the IPA approach can generate similar results compared to the state of the art path planner SIPP, the gathered results have to be further examined concerning the collision properties, path shape and path length. The procedurally generated test scenes all caused collision afflicted paths using a static A* implementation. In contrast to this static algorithm, within these 5000 scenarios, all IPA implementations, as well as the SIPP algorithm could generate collision free paths. Given these considered environments, the IPA approach can be stated as a collision free path planner. To estimate the path similarity, a Dynamic Time Warping (DTW) algorithm (proposed in [22]) has been used to align the data-sets, subsequently computing the mean Euclidean distances. The used path similarity value is defined as the mean Euclidean distance (DTW) set relative to the path length, subsequently subtracted from 1.00. The higher this value, the higher the compared paths fit geometrically together. Table 1 gives an overview of the gathered values. Table 1. Results of the comparison between the computed paths via Safe Interval Path Planner (SIPP) and the specific implementations using the novel IPA-approach estimated from 5000 procedurally generated scenarios. Algorithm
Length delta
Path similarity (DTW)
IPA - A* IPA - Lazy Theta* IPA – Visibility Graph
+0.10% -4.56% -3.95%
98.93% 96.31% 96.21%
28
Felix Gaisbauer et al. / Procedia CIRP 67 (2018) 24 – 29
The path similarities for all algorithms were computed relatively to the paths generated by the SIPP algorithm. The mean path similarity percentage of 98.93% indicates that the path shape of the IPA A* algorithm strongly corresponds with the baseline (mean Euclidian distance = 1.03% of path length). Since the other path planning algorithms are not limited to the grid restrictions the paths might differ more, which results in a lower path similarity value (96.31 %, 96.21%). On consideration of the mean lengths of the computed paths, the IPA A* approach results in slightly increased trajectory lengths of 0.10%. Transferring this to an estimated path length of 10 m implies a negligible increase of 0.01m. Combining the IPA-methodology with optimized algorithms like Lazy Theta*, or a Visibility Graph search, the estimated path lengths can be additionally decreased (i.e. Lazy Theta* 4.56%, Visibility Graph 3.95%), leading to more natural paths. Since the specific implementation of the SIPP algorithm strongly influences the memory usage, the performance concerning the memory usage has not been explicitly evaluated. Nevertheless, from a theoretical standpoint the memory usage of the IPA approach with a grid based A* algorithm is always lower than the equivalent SIPP approach. This is the case, since by using the IPA-A* only one byte per cell must be allocated, whereas the SIPP approach requires at least one interval data structure for each cell, which is always represented by multiple bytes. Given a scene with several dynamic obstacles, one cell can additionally contain multiple of those safe/collision intervals. Moreover, the IPA approach is not limited to cell decomposition/grid based approaches, therefore it can be furthermore combined with more memory efficient approaches (like RRT) in contrast to SIPP. Even though the proposed algorithm does not guarantee optimality it can achieve similar results with similar computation times (-26.29%). The absence of collision afflicted paths sustains the validity of the IPA-approach using arbitrary (collision-free) path planning algorithms. This reveals the benefit of the proposed method which provides a generic incorporation of various path planners. 4.2. Exemplary Use Case Evaluation In addition to the procedural evaluation, the performance of the proposed IPA algorithm has been evaluated based on an exemplary, realistic shop floor scenario. 4.2.1. Experimental Setup To determine the influence of the novel approach concerning the production planning and assembly simulation, an exemplary car assembly scene has been set up. Using the previously explained framework and the proposed scene, a rich repertoire of different path planning problems is generated. These individual problems were solved by different implementations of path planning algorithms, enabling to validate the performance of the path planners regarding typical walk scenarios in common automotive assembly environments. Since crossing the conveyer belt between two cars is one of the most challenging tasks for a path planner, this scenario has been chosen.
Fig. 6. Experimental setup of the car assembly use case evaluation. A collision-free path has to be computed, ranging from a randomly sampled point at A, to a randomly sampled point in the target area B.
4.2.2. Design of experiments The scene has been set up utilizing the same framework as in the previous evaluation. The modeled assembly environment represents a common assembly station within automotive industry. Figure 6 describes the experimental setup. The overall station size has been set to 6.0 m x 9.0 m, while effectively only 6.0 m x 5.0 m can be utilized (the other regions are specified as material zones). Within the scene, three car-shaped obstacles with dimensions of 4.0 m x 1.8m have been modeled. The distance between the cars among the horizontal axis is set to 1.8 m. The cars move horizontally on the belt with a constant velocity of 0.06 m/s according to the cycle time of the common automotive assembly processes. The start position of the agent is uniformly sampled within the rectangular shaped area A (see Figure 6, A) with dimensions of 6.0 x 1.25 m, while the endpoint is uniformly sampled within the endpoint area B. Additionality, the positions of the three cars are adjusted in a uniform way, ranging from -3.0 m to 3.0 m in the horizontal axis. Since the assembly workers in a real shop floor environment may vary in their velocities and the utilized dynamic path planner strongly rely on the velocity assumptions of the agents, the desired agent velocities have been further adjusted (uniformly sampled within the range 1.36 m/s ± 0.5 m/s). Given these specifications, within 1000 simulation runs, a randomly generated path planning problem has been generated. For each configuration, the selected path planners computed a path from a determined starting point from zone A to a target position in zone B. The trajectories have been computed with an implementation of the SIPP algorithm [20], the IPA approach with a Lazy Theta* planner, as well as IPA A*. The cell size and the obstacle contour resolution were set identically to the procedural evaluation (0.05 m, 0.01 m). The maximum prediction time of the IPA approach has been set to 30 seconds. 4.2.3. Results Within the 1000 simulations runs, different paths have been computed due to the uniform sampling of the configurations. As Figure 7 indicates, the length of the estimated paths range from below three meters to above eight meters.
Felix Gaisbauer et al. / Procedia CIRP 67 (2018) 24 – 29
29
References
Fig. 7. Boxplot of the computed path lengths for the different algorithms in the assembly use case scenarios after 1000 simulation runs.
The IPA A* and SIPP algorithms result in nearly identical trajectories according to their mean lengths and standard deviation (5.60 m, σ= 1.16 m vs. 5.59 m, σ= 1.16 m). Since these approaches both use the cell decomposition based A* algorithm, the trajectories lack of smoothness and result oftentimes in longer paths due to the discretization error. By using the dynamic IPA approach with an implementation of the Lazy Theta* algorithm, the novel approach can utilize the benefits of this any angle path planning algorithm. As the mean path length of 5.40 m (σ= 1.09 m) indicates, the mean length of the computed paths can be decreased by 0.19 m compared to the results of the SIPP. In particular, the maximum reduction between an estimated path of SIPP and IPA Lazy Theta* was 0.72 m. In general, the computed paths are shorter than the A* pendants. Transferring the results to the production planning and assembly simulation, it can be stated that the computed paths of the IPA Lazy Theta* approach can further improve the quality of the computed walk paths in automotive environments. Thus leading to a more accurate and realistic assembly planning and simulation in terms of non-value adding walk tasks. 5. Conclusion This paper presents a heuristic approach for time-dynamic path planning by incorporating static pathfinding algorithms into an additional component. The procedural evaluation shows that the approach can achieve similar result than a state of the art time-dynamic path planner, while being able to utilize different path finding implementations. The subsequent evaluation in a car assembly inspired environment shows the impact for the simulation and production planning. Since the proposed approach is still a work in progress it has to be further discussed and evaluated based on a larger database as well as compared to various path planners. Moreover instead of assuming a constant agent velocity, the expected velocities of the agent and obstacles could be further extended by means of probabilistic modeling (e.g. [23]).
[1] Manns M, Martin NAA. Improving A* walk trajectories with B-splines and motion capture for manual assembly verification. Procedia CIRP 2015;33:365–370. [2] Agethen P, Otto M, Mengel S, Rukzio E. Using Marker-less Motion Capture Systems for Walk Path Analysis in Paced Assembly Flow Lines. Procedia CIRP 2016;54:152–157. [3] IPO.Plan GmbH :IPO.Log 2017. https://www.ipoplan.de. [4] Hart P, Nilsson N, Raphael B. A Formal Basis for the Heuristic Determination of Minimum Cost Paths. IEEE Trans Syst Sci Cybern 1968;4:100–107. [5] Nash A, Koenig S, Tovey C. Lazy Theta*: Any-angle path planning and path length analysis in 3D. Third Annu. Symp. Comb. Search, 2010. [6] Belghith K, Kabanza F, Hartman L, Nkambou R. Anytime dynamic path-planning with flexible probabilistic roadmaps. Proc. 2006 IEEE Int. Conf. Robot. Autom. 2006 ICRA 2006, IEEE; 2006, p. 2372–2377. [7] Likhachev M, Gordon GJ, Thrun S. ARA*: Anytime A* with provable bounds on sub-optimality. Adv. Neural Inf. Process. Syst., 2003. [8] Kavraki LE, Svestka P, Latombe J-C, Overmars MH. Probabilistic roadmaps for path planning in high-dimensional configuration spaces. IEEE Trans Robot Autom 1996;12:566–580. [9] Karamouzas I, Geraerts R, Overmars M. Indicative routes for path planning and crowd simulation. Proc. 4th Int. Conf. Found. Digit. Games, ACM; 2009, p. 113–120. [10] Nieuwenhuisen D, Kamphuis A, Overmars MH. High quality navigation in computer games. Sci Comput Program 2007;67:91–104. [11] Dijkstra EW. A note on two problems in connexion with graphs. Numer Math 1959;1:269–271. [12] Gasparetto A, Boscariol P, Lanzutti A, Vidoni R. Path Planning and Trajectory Planning Algorithms: A General Overview. In: Carbone G, Gomez-Bravo F, editors. Motion Oper. Plan. Robot. Syst., vol. 29, Cham: Springer International Publishing; 2015, p. 3–27. [13] Lozano-Perez T, Wesley MA. An algorithm for planning collision-free paths among polyhedral obstacles. Commun ACM 1979;22:560–570. [14] o’Dunlaing C, Sharir M, Yap CK. Retraction: A new approach to motion-planning, ACM Press; 1983, p. 207–220. [15] Nash A. Any-angle path planning. University of Southern California, 2012. [16] Boor V, Overmars MH, van der Stappen AF. The Gaussian sampling strategy for probabilistic roadmap planners. Robot. Autom. 1999 Proc. 1999 IEEE Int. Conf. On, vol. 2, IEEE; 1999, p. 1018–1023. [17] Lavalle SM. Rapidly-Exploring Random Trees: A New Tool for Path Planning. 1998. [18] Rufli M, Ferguson D, Siegwart R. Smooth path planning in constrained environments. Robot. Autom. 2009 ICRA09 IEEE Int. Conf. On, IEEE; 2009, p. 3780–3785. [19] Van Den Berg J, Ferguson D, Kuffner J. Anytime path planning and replanning in dynamic environments. Proc. 2006 IEEE Int. Conf. Robot. Autom. 2006 ICRA 2006, IEEE; 2006, p. 2366–2371. [20] Phillips M, Likhachev M. Sipp: Safe interval path planning for dynamic environments. Robot. Autom. ICRA 2011 IEEE Int. Conf. On, IEEE; 2011, p. 5628–5635. [21] Brogan DC, Johnson NL. Realistic human walking paths. Comput. Animat. Soc. Agents 2003 16th Int. Conf. On, IEEE; 2003, p. 94–101. [22] Giorgino T, others. Computing and visualizing dynamic time warping alignments in R: the dtw package. J Stat Softw 2009;31:1–24. [23] Van Den Berg J, Abbeel P, Goldberg K. LQG-MP: Optimized path planning for robots with motion uncertainty and imperfect state information. Int J Robot Res 2011;30:895–913.
