Paper deep dive
MeshSIPP: Efficient Lattice Planning in Dynamic Environment
Marat Agranovskiy, Konstantin Yakovlev
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 10/11/2026, 2:56:51 AM
Summary
The paper introduces MeshSIPP, an efficient kinodynamic spatiotemporal planning algorithm for autonomous navigation in dynamic environments. It addresses the computational bottleneck of combining state lattices with Safe Interval Path Planning (SIPP) by transforming the state lattice into a mesh graph. This allows motion primitives to be propagated as spatial bundles, validated together via lightweight bounding checks, and deferring expensive exact departure-time searches until terminal states. The method includes a time-aware pruning rule to discard redundant branches, ensuring completeness and optimality while achieving up to a 3x speedup over state-of-the-art planners.
Entities (9)
Relation Signals (7)
MeshSIPP → buildsupon → Safe Interval Path Planning
confidence 95% · MeshSIPP combines the interval-based reasoning of SIPP with a structural transformation
MeshSIPP → uses → Mesh Graph
confidence 95% · MeshSIPP propagates primitives as spatial bundles... in a specialized mesh graph
MeshSIPP → achievesspeedupover → state-of-the-art spatiotemporal planners
confidence 90% · MeshSIPP achieves up to a 3× speedup over state-of-the-art spatiotemporal planners
Agranovskiy → authored → MeshSIPP
confidence 90% · Marat Agranovskiy Konstantin Yakovlev Abstract... MeshSIPP
Yakovlev → authored → MeshSIPP
confidence 90% · Marat Agranovskiy Konstantin Yakovlev Abstract... MeshSIPP
MeshSIPP → transforms → State Lattice
confidence 90% · transforms the conventional state lattice into a specialized mesh graph
MeshSIPP → validatedon → TurtleBot3
confidence 85% · real-time ROS/Gazebo validation on a TurtleBot3
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Autonomous navigation in dynamic environments requires computing spatiotemporal trajectories that satisfy non-holonomic motion constraints. When the trajectories of the moving obstacles are predictable or known, a promising approach is to rely on the combination of state lattices constructed from precomputed feasible motion primitives and Safe Interval Path Planning -- a search-based algorithm with strong theoretical guarantees. While this approach yields feasible paths, the rich primitive sets needed for smooth navigation induce a large branching factor, which becomes costly when coupled with time-dependent obstacle intervals. To this end, we present MeshSIPP, an efficient planner that removes the computational bottleneck by exploiting the fact that many primitives sweep the same regions and can therefore be validated together. MeshSIPP propagates primitives as spatial bundles, screens them with lightweight bounding-interval checks, and defers the expensive exact departure-time search until a primitive reaches its terminal state. A time-aware pruning rule additionally discards redundant space-time branches early in the search. We prove that the resulting search is complete and optimal. Extensive experiments over more than 6,000 benchmark instances and real-time ROS~2 simulations show that MeshSIPP achieves up to a 3$\times$ speedup over state-of-the-art spatiotemporal planners.
Tags
Links
- Source: https://arxiv.org/abs/2610.09652v1
- Canonical: https://arxiv.org/abs/2610.09652v1
Trouble viewing inline? Open PDF directly →
Full Text
51,590 characters extracted from source content.
Expand or collapse full text
MeshSIPP: Efficient Lattice Planning in Dynamic Environment Marat Agranovskiy Konstantin Yakovlev Abstract Autonomous navigation in dynamic environments requires computing spatiotemporal trajectories that satisfy non-holonomic motion constraints. When the trajectories of the moving obstacles are predictable or known, a promising approach is to rely on the combination of state lattices constructed from precomputed feasible motion primitives and Safe Interval Path Planning – a search-based algorithm with strong theoretical guarantees. While this approach yields feasible paths, the rich primitive sets needed for smooth navigation induce a large branching factor, which becomes costly when coupled with time-dependent obstacle intervals. To this end, we present MeshSIPP, an efficient planner that removes the computational bottleneck by exploiting the fact that many primitives sweep the same regions and can therefore be validated together. MeshSIPP propagates primitives as spatial bundles, screens them with lightweight bounding-interval checks, and defers the expensive exact departure-time search until a primitive reaches its terminal state. A time-aware pruning rule additionally discards redundant space-time branches early in the search. We prove that the resulting search is complete and optimal. Extensive experiments over more than 6,000 benchmark instances and real-time ROS 2 simulations show that MeshSIPP achieves up to a 3× speedup over state-of-the-art spatiotemporal planners. I Introduction Autonomous navigation in environments with dynamic obstacles is a fundamental challenge in mobile robotics. In many practical applications, such as warehouse logistics, the future movements of dynamic obstacles are either explicitly known or can be accurately predicted. Utilizing this predictive information enables a global spatiotemporal planning paradigm, allowing the robot to compute high-quality collision-free paths ahead of time. Beyond avoiding dynamic obstacles, practical deployment requires strict adherence to vehicle kinematics, as non-holonomic platforms (such as car-like or differential-drive vehicles) cannot turn in place and require smoothly curved, kinematically feasible trajectories. A widespread approach to handle kinodynamic constraints in robotics is sampling-based path planning [1, 2, 3]. Planners of this family naturally operate in continuous spaces and rely on the randomized decomposition of the problem into smaller ones. They support complex vehicle constraints via customized steering functions and are particularly advantageous in high-dimensional configuration spaces, e.g., for robotic manipulators. Moreover, extensions like ST-RRT* [4] incorporate a temporal dimension to avoid dynamic obstacles. Still, these methods provide only probabilistic guarantees of completeness and optimality and may struggle to find paths in confined configuration workspaces. Conversely, lattice-based planners rely on the discretization of the workspace/configuration space and provide strong theoretical guarantees with respect to this discretization. They are often preferable for systems with fewer degrees of freedom, such as mobile robots, where planning primarily involves (x,y,θ)(x,y,θ). These methods reason over motion primitives – precomputed, kinodynamically feasible motions used to construct the final path (see Fig. 1). Stacked motion primitives form a state lattice, i.e., a graph where vertices correspond to the robot’s states and edges to the feasible transitions between them. A shortest path on this graph can be obtained by the search algorithms like A* [5]. Fig. 1: Example of the path planning problem we are interested in. Within a 2D workspace (green: static obstacles, white: free space), the robot with state (x,y,θ)(x,y,θ) must compute a collision-free path composed of smoothly connected motion primitives (alternating colors) to reach the goal while avoiding dynamic obstacles. To effectively extend this approach to dynamic environments, one can utilize Safe Interval Path Planning (SIPP) [6] that reduces the temporal search space by grouping obstacle-free time periods into contiguous safe intervals. This abstraction has been successfully extended to any-angle pathfinding [7], strict acceleration profiles [8], quadrotors [9], high-dimensional manipulators [10], anytime planning [11], etc. However, directly integrating state lattices with SIPP, as in [12], introduces a severe computational bottleneck. To produce smooth and expressive trajectories, rich motion-primitive libraries are required and this leads to a large branching factor. In dynamic environments, this is further amplified by the fragmentation of safe intervals at each state, resulting in a multiplicative increase in search complexity. As a consequence, straightforward combinations of lattice-based and safe interval planning become computationally burdensome in complex, obstacle-rich scenarios. To this end, we introduce MeshSIPP, a novel kinodynamic spatiotemporal planning algorithm that transforms the conventional state lattice into a specialized mesh graph [13]. Because many primitives sweep the same areas, MeshSIPP groups them into coherent bundles and propagates each bundle incrementally along their shared footprint, establishing spatial validity once for the whole group. Extending this idea to dynamic environments is not straightforward: primitives within a bundle have different execution durations, so evaluating exact temporal constraints during propagation would fragment the bundle and destroy the structure that makes it efficient. We resolve this with a lazy evaluation scheme that defers the expensive continuous departure search until a primitive reaches its terminal state, combined with a time-aware pruning rule that discards redundant space-time branches early in the search. Our contributions are: (i) MeshSIPP, a bundle-based safe-interval search with lazy temporal evaluation; (i) a bounded, time-aware terminal pruning rule, together with a proof that it preserves completeness and optimality with respect to the given workspace discretization and control set; (i) an evaluation over 6,000+ instances against four baselines, in which MeshSIPP returns solutions of identical cost to SIPP at a 100% success rate while running 2−3×2-3× faster; and (iv) a real-time ROS/Gazebo validation on a TurtleBot3, replanning in 50 ms per cycle amidst 20 non-cooperative moving obstacles. I Problem Statement Consider a mobile robot, approximated by a bounding circle of radius R, operating in a planar 2D workspace ⊂ℝ2W ^2. Its continuous state is defined by its coordinates and heading angle: =(x,y,θ)∈×S1s=(x,y,θ) × S^1. The underlying motion is subject to non-holonomic kinematic constraints expressed through the dynamic model ˙=f(,) s=f(s,u), where u denotes the bounded control inputs. As is typical for mobile platforms, these dynamics are translationally invariant, being independent of the absolute spatial coordinates (x,y)(x,y). State Lattice and Motion Primitives. To formulate continuous planning as a graph search, we define a discrete set of headings Θ=θ1,…,θk⊂S1 =\ _1,…, _k\⊂ S^1 and a finite control set of template motion primitives. Each template specifies an initial heading θ∈Θθ∈ , a control sequence (t)u(t), and an execution duration Δt>0 t>0. Due to the translational invariance of the dynamics, integrating ˙=f(,) s=f(s,u) from an initial state (x,y,θ)(x,y,θ) over Δt t produces a kinematically feasible trajectory segment whose continuous geometric shape is independent of the starting coordinates (x,y)(x,y). Consequently, rather than reasoning about time-varying control inputs, these templates can be treated directly as precomputed, invariant trajectory segments that the robot can execute from any spatial location. Instantiating these templates at a common origin, such as (0,0)(0,0), yields a finite set of relative endpoint displacements that can be embedded into a regular spatial grid (see Fig. 2). This grid is not unique, as any of its refinements preserve the alignment of all primitive endpoints. We choose a resolution that reflects the robot’s sensing and localization capabilities, using the resulting grid as the environmental occupancy map. Fig. 2: Control set with regular grid: totaling 384384 primitives across 1616 discrete orientations. Two colors are used for visual clarity. To close this construction under transitions, we additionally design each template so that its terminal heading also belongs to Θ . We can therefore define the discrete state space as =(i,j,θ)∣(i,j)∈ℤ2,θ∈ΘS=\(i,j,θ) (i,j) ^2,\ θ∈ \, where (i,j)(i,j) corresponds to the cell centers of the chosen grid. A template with initial heading θ can be instantiated at any state (i,j,θ)(i,j,θ). Because its relative displacement is grid-aligned and its terminal heading belongs to Θ , the resulting trajectory terminates at another state in S. Thus, template instantiations define directed edges between discrete states and form a regular state lattice. A path in this graph represents a sequence of smoothly connected primitives, yielding a continuous, kinematically feasible global trajectory whose expressiveness scales with the richness of the control set. Environment Representation. We represent the environment on the same occupancy grid introduced above, and distinguish between static and dynamic obstacles: • Static Environment: A binary occupancy map M, where Mi,j=1M_i,j=1 if cell (i,j)(i,j) is blocked, and 00 otherwise. • Dynamic Environment: A spatio-temporal occupancy map D, where each cell (i,j)(i,j) is associated with a set Di,j=[tin(1),tout(1)),[tin(2),tout(2)),…D_i,j=\[t_in^(1),t_out^(1)),[t_in^(2),t_out^(2)),…\ of disjoint intervals, indicating when the cell is occupied by a moving obstacles. These intervals are precomputed by dilating dynamic obstacles by the robot radius R, sweeping them along their trajectories, and rasterizing the resulting spatio-temporal volumes onto the grid. Spatial-Temporal Trace. As the robot executes a template primitive, its center sequentially traverses a set of grid cells. For each visited cell c, we record its coordinate offset Δc=(Δic,Δjc) c=( i_c, j_c) from the primitive’s origin and the relative time interval [τinc,τoutc)⊆[0,Δt)[ _in^c, _out^c) [0, t) during which the center resides within c. When the primitive is instantiated at (i,j,θ)(i,j,θ) with absolute start time t, this local trace shifts accordingly. The execution is collision-free if all cells in the trace are statically free in M and its absolute intervals do not overlap with any obstacle intervals: [t+τinc,t+τoutc)∩Di+Δic,j+Δjc=∅[t+ _in^c,t+ _out^c)∩ D_i+ i_c,\,j+ j_c= . Objective. A valid path is a sequence of collision-free motion primitives, optionally interleaved with waits in safe intervals. Each action must start from the discrete state reached by the previous one, ensuring kinematic continuity. Starting from s0=(i0,j0,θ0)s_0=(i_0,j_0, _0) at time t0t_0, we seek a path to sf=(if,jf,θf)s_f=(i_f,j_f, _f) that minimizes the arrival time tft_f. I Background: Safe Interval Path Planning To effectively navigate dynamic environments where in-place waiting is permitted to avoid obstacles, several methods exist. Standard space-time search algorithms operate over an augmented state space (x,y,θ,t)(x,y,θ,t). By modeling waiting actions through discrete time increments (t→t+Δt→ t+ t), these methods often suffer from severe state-space explosion, especially over long planning horizons or in continuous time. Safe Interval Path Planning (SIPP) [6] mitigates this inefficiency by abstracting the continuum of free time at each spatial configuration into a finite set of maximal, contiguous, collision-free windows called safe intervals. Over this interval-augmented space, a search state is defined as p=⟨i,j,θ,I⟩p= i,j,θ,I , and SIPP functions similarly to A* (or Dijkstra’s algorithm) to find a path to each state p that minimizes the arrival time g(p)=tarr∈Ig(p)=t_arr∈ I. This formulation enables a dominance property: if multiple paths reach the same spatial configuration within the same safe interval I, only the earliest arrival time tarrt_arr needs to be maintained. Any later one is inherently dominated, as the robot could instead arrive earlier and safely wait in place within I until any later moment. This allows SIPP to prune redundant trajectories and bound the search space by the number of safe intervals, regardless of the amount or duration of wait actions. Consequently, a single spatial configuration gives rise to multiple search states, each corresponding to different time windows (before, between, or after the passage of dynamic obstacles). Maintaining all of them is essential for completeness and optimality, as arriving at an intermediate configuration in a later interval may be the only way to access a downstream safe interval that yields a faster overall path to the goal. Given this representation, the SIPP search proceeds by iteratively expanding states p=⟨i,j,θ,I⟩p= i,j,θ,I to generate successors. To do so, all applicable motion primitives m from the current configuration are evaluated. For each target configuration (i′,j′,θ′)(i ,j ,θ ) resulting from m, the algorithm retrieves the list of available safe intervals. For every target interval I′I , we compute the earliest possible departure time tdept_dep from the current state — which directly minimizes the arrival time in I′I — such that the robot successfully departs from the current interval, arrives within the target interval, and avoids all dynamic obstacles along the path (see Fig. 3, left). Formally, a valid departure time tdept_dep must satisfy: 1. tdep≥tarrt_dep≥ t_arr, enforcing temporal causality; 2. tdep+m.τout(0,0)≤I.tendt_dep+m. _out^(0,0)≤ I.t_end, ensuring the agent vacates the origin cell before the current interval I closes, where m.τout(0,0)m. _out^(0,0) is the time required to leave the cell; 3. tdep+Δtm∈I′t_dep+ t_m∈ I , ensuring arrival at the target cell within the destination interval I′I , where Δtm t_m is the execution duration of primitive m. This step generates a successor state p′=⟨i′,j′,θ′,I′⟩p = i ,j ,θ ,I with an updated arrival time g(p′)=tdep+Δtmg(p )=t_dep+ t_m We encapsulate the calculation of the time tdep∗t_dep^* within a function GetEarliestDeparture((i,j),m,tmin,tmax) GetEarliestDeparture((i,j),m,t_min,t_max). While its specific implementation is environment-dependent, for a grid-based state space, it can be achieved by projecting all temporal constraints back to the moment of departure. Specifically, the function iterates over all cells traversed by the primitive m, retrieves the occupied intervals of dynamic obstacles in those cells, and projects them backward in time according to the primitive’s spatial-temporal trace. This projection yields a set of forbidden departure time blocks at the origin cell. By merging and sorting these invalid blocks, the algorithm identifies the earliest free gap that falls within the allowable departure window [tmin,tmax][t_min,t_max]. Fig. 3: Left: Finding the optimal departure time tdep∗t_dep^* for a single motion primitive. Colored curves represent the same primitive shifted across continuous times: gray trajectories collide with dynamic obstacle intervals (black blocks), red options are safe, and the purple trajectory denotes the earliest safe departure we are interested in. Right: Extended cells in the mesh graph, representing a grid cell (magenta) combined with a bundle of motion primitives (teal) passing through it at a specific 00-based spatial trace index k. The bottom panel depicts (i,j,Ψ)(i,j, ) at index k=3k=3. The top panel shows its second-order successor (i′,j′,Ψ′)(i ,j , ) at k=5k=5, retaining only the primitives whose spatial traces match the bundle’s exact sequence of cells (orange ones) up to this point. The remainder are pruned (gray dashed lines) as their traces diverged at an earlier step. Red arrows indicate the endpoints of the surviving primitives in the bundle. IV Method: MeshSIPP The proposed method combines the interval-based reasoning of SIPP with a structural transformation of the search space (state lattice) into a specialized mesh graph. Conducting a search directly over this representation enables early pruning and mitigates redundant state expansions. IV-A Mesh Graph To reason about motion primitives at the individual grid-cell level, we adopt the mesh graph formulation introduced in [13]. In conventional state-lattice planning, search nodes represent discrete states (i,j,θ)(i,j,θ) and edges represent full motion primitives. In contrast, the mesh graph decomposes the primitive execution cell-by-cell along its spatial trace, allowing primitives with overlapping footprints to be evaluated simultaneously in bundles within the same search node. Formally, nodes in the mesh graph are extended cells, defined as tuples u=(i,j,Ψ)u=(i,j, ), where (i,j)(i,j) specifies the 2D grid cell and Ψ represents a primitive configuration: Ψ=(m1,k),(m2,k),…,(mn,k). = \(m_1,k),(m_2,k),…,(m_n,k) \. Here, each pair (m,k)∈Ψ(m,k)∈ indicates that an instance of the template primitive m (from a precomputed control set) traverses cell (i,j)(i,j) as the k-th cell (00-based index) in its spatial trace. Thus, Ψ captures the information about a specific bundle of primitives simultaneously passing through cell (i,j)(i,j) at identical spatial offsets k (see Fig. 3). To establish equivalence with the conventional state lattice, extended cells are categorized into two types: • Initial Extended Cells: Characterized by a configuration Ψθ=(m1,0),…,(mr,0) _θ= \(m_1,0),…,(m_r,0) \ containing all control-set primitives originating at orientation θ with step index k=0k=0. An initial cell (i,j,Ψθ)(i,j, _θ) serves as the direct functional counterpart to a standard lattice state (i,j,θ)(i,j,θ). • Regular Extended Cells: Others: intermediate cells (k>0k>0) along the spatial traces of active primitives from a bundle, as depicted in Fig. 3 (right). Transitions in the mesh graph propagate active bundles cell-by-cell along the spatial traces of their constituent primitives. To generate a successor configuration for an immediate neighbor, the algorithm filters the current bundle Ψ : it retains only the primitives whose next swept cell matches that neighbor, while primitives routing elsewhere are excluded. For instance, in Fig. 3 (right, bottom panel), the bundle at trace index k=3k=3 physically diverges. If the search follows the rightward branch and advances two steps, it reaches a second-order successor (i′,j′,Ψ′)(i ,j , ) at k=5k=5 (top panel). The primitives that routed along the alternate branch are inherently pruned from Ψ′ (illustrated by gray dashed lines). This local filtering mechanism ensures that primitive bundles remain grouped as long as they share a spatial path, splitting only when their traces physically diverge. When a primitive m∈Ψm∈ completes its spatial trace, it reaches a specific discrete endpoint state (im,jm,θm)(i_m,j_m, _m) (indicated by red arrows in Fig. 3, right). Reaching this terminal state initiates a new bundle, meaning the succeeding node is represented as an initial extended cell (im,jm,Ψθm)(i_m,j_m, _ _m). Edge costs in the mesh graph are assigned as follows: • Transitions into regular extended cells carry a cost 00. • Transitions into initial extended cells are assigned the full cost of the completed primitive, Cost(m)Cost(m). Exactly one primitive completes upon entering any given initial cell, ensuring this edge cost is uniquely defined. Formally, we encapsulate the entire neighbor-generation process in a function MeshSuccessors(i,j,Ψ) MeshSuccessors(i,j, ), which yields the set of all valid successor extended cells (i′,j′,Ψ′)(i ,j , ). Crucially, paths between initial extended cells are in bijection with motion-primitive sequences on the state lattice, preserving both total cost and exact spatial trace. IV-B MeshSIPP: Lazy Temporal Evaluation Integrating continuous temporal constraints directly into the spatial mesh graph requires careful handling of primitive execution times. Because primitives within a single bundle possess distinct durations Δt t, evaluating exact dynamic collisions cell-by-cell would prematurely fragment the bundles, diminishing the core efficiency of the mesh graph structure. To preserve the structural advantage of simultaneous primitive evaluation, we introduce a lazy temporal evaluation scheme. This approach decouples spatial traversal from strict dynamic interval validation: spatial propagation along regular cells utilizes lightweight bounding checks, while the exact continuous departure search is deferred until primitives reach their endpoints at initial cells. Search Space Elements. To support this delayed evaluation, we augment the spatial extended cells of the mesh graph with the temporal structure of SIPP. Definition 1 (MeshSIPP State) A state in the MeshSIPP search space is defined as a tuple u=⟨i,j,Ψ,sroot⟩u= i,j, ,s_root , where (i,j,Ψ)(i,j, ) is the spatial extended cell, and sroot=⟨i0,j0,θ0,I0⟩s_root= i_0,j_0, _0,I_0 is the base SIPP state from which the current bundle Ψ originated. Thus, (i0,j0,Ψθ0)(i_0,j_0, _ _0) corresponds to the last initial extended cell traversed on the path up to u. The g-value (current time) of the state u is defined entirely by the arrival time of its root state, i.e., g(u)=g(sroot)=tarrg(u)=g(s_root)=t_arr. In this augmented space, the root state sroots_root acts as a temporal anchor. As the bundle propagates through intermediate cells, time remains logically anchored at tarrt_arr, and transition costs are inherently zero. Time advances and costs accumulate exclusively when a primitive terminates and a new temporal anchor is instantiated. Successor Generation and Conservative Pruning. Algorithm 1 details the successor generation process. For a state u, the algorithm first retrieves the spatial successors from the underlying mesh graph via MeshSuccessors (Line 3). If a transition yields a REGULAR cell (Line 4), we apply conservative temporal pruning (Lines 5–8). We estimate a bounding window [tmin,tmax)[t_min,t_max) representing the earliest possible arrival and latest possible departure of any primitive within the bundle Ψ′ traversing the current cell. If dynamic obstacles (Di′j′D_i j ) completely subsume this window, the transition is pruned. Otherwise, it forms a new regular state with zero transition cost (Lines 9–10). Conversely, reaching an INITIAL successor (past Line 11) means a primitive m has completed, triggering the deferred exact evaluation. For each destination safe interval I′I , we compute a bounded departure window [t1,t2][t_1,t_2] relative to sroots_root (Lines 18–19) and execute the continuous departure search (Line 20). If a valid departure time tdept_dep is found, we establish a new temporal anchor snews_new and assign the true transition cost as the required wait time at the root cell plus the primitive’s execution duration: (tdep−tarr)+m.Δt(t_dep-t_arr)+m. t. Algorithm 1 Generating Successors of a MeshSIPP State Input: MeshSIPP state u=⟨i,j,Ψ,sroot⟩u= i,j, ,s_root with time tarrt_arr Output: Set of successors and transition costs (v,)(v,cost) 1: Successors←∅ Successors← 2: for all ⟨i′,j′,Ψ′⟩∈MeshSuccessors(i,j,Ψ) i ,j , ∈ MeshSuccessors(i,j, ) do 3: if Ψ′ is REGULAR then 4: tmin=tarr+min(m,k)∈Ψ′(τink)t_min=t_arr+ _(m,k)∈ ( _in^k) 5: tmax=tarr+max(m,k)∈Ψ′(τoutk)t_max=t_arr+ _(m,k)∈ ( _out^k) 6: if [tmin,tmax)⊂Ib[t_min,t_max)⊂ I_b for some Ib∈Di′j′I_b∈ D_i j then 7: continue ⊳ Fully covered by obstacles 8: vint←⟨i′,j′,Ψ′,sroot⟩v_int← i ,j , ,s_root 9: Successors.add((vint,0)) Successors. add ((v_int,0) ) 10: continue 11: θ′←θ ← heading from which Ψ′ originates ⊳ Ψ′=Ψθ′ = _θ 12: m←m← the primitive that just terminated to form Ψ′ 13: p←(sroot.i,sroot.j)p←(s_root.i,~s_root.j) ⊳ Origin cell 14: τ∗←m.τout(0,0)τ^*← m. _out^(0,0) ⊳ Time to clear origin 15: SafeIntervals←ℝ≥0∖Di′,j′ SafeIntervals← R_≥ 0 D_i ,j 16: for all I′=[tstart,tend)∈SafeIntervalsI =[t_start,t_end)∈ SafeIntervals do 17: t1←max(tarr,tstart−m.Δt)t_1← (t_arr,~t_start-m. t) 18: t2←min(sroot.I.tend−τ∗,tend−m.Δt)t_2← (s_root.I.t_end-τ^*,~t_end-m. t) 19: tdep←GetEarliestDeparture(p,m,t1,t2)t_dep← GetEarliestDeparture(p,m,t_1,t_2) 20: if t1<t2t_1<t_2 and tdep≠∞t_dep≠∞ then 21: snew←⟨i′,j′,θ′,I′⟩s_new← i ,j ,θ ,I 22: vterm←⟨i′,j′,Ψ′,snew⟩v_term← i ,j , ,s_new 23: tarrnew←tdep+m.Δt_arr^new← t_dep+m. t ⊳ =g(snew)=g(s_new) 24: ←(tdep−tarr)+m.Δtcost←(t_dep-t_arr)+m. t 25: Successors.add((vterm,)) Successors. add ((v_term,cost) ) 26: return Successors Heuristic. As in other informed search algorithms, we use a heuristic to estimate the remaining cost to the goal and focus the search on promising states. Let h^SIPP h_SIPP denote an admissible SIPP heuristic; as is common, it may ignore the temporal component and estimate only the remaining motion cost. For an initial MeshSIPP state, we use the heuristic value of its corresponding SIPP state. For a regular state u=⟨i,j,Ψ,sroot⟩u= i,j, ,s_root , each (m,k)∈Ψ(m,k)∈ defines a discrete endpoint state sms_m obtained by completing m. Since the cost of a primitive is incurred only at its endpoint, we set h(u)=min(m,k)∈ΨΔtm+h^SIPP(sm).h(u)= _(m,k)∈ \ t_m+ h_SIPP(s_m) \. If h^SIPP h_SIPP also accounts for safe intervals, the minimum is additionally taken over all reachable safe intervals of the primitive endpoints. IV-C Early Terminal Pruning in MeshSIPP A profound advantage of transitioning to a cell-by-cell search space (mesh graph) is the structural capability to prune unpromising branches prematurely. In a static environment, a regular search node can be safely discarded if all its spatial endpoints are already expanded. Since any valid path from this node must pass through one of these endpoints, its further exploration is redundant. Extending this principle to SIPP, however, introduces a temporal challenge: a single spatial endpoint (i,j,θ)(i,j,θ) encompasses multiple safe intervals. Algorithm 2 MeshSIPP Early Terminal Pruning Input: Regular u=⟨i,j,Ψ,sroot⟩u= i,j, ,s_root with arrival time tarrt_arr Output: true if u is pruned, false otherwise 1: Δtmax←maxm∈ControlSet(m.Δt) t_max← _m∈ ControlSet(m. t) ⊳ Slowest primitive 2: for all endpoint (i′,j′,θ′)(i ,j ,θ ) for each primitive m∈Ψm∈ do 3: tmin←tarr+m.Δt_min← t_arr+m. t ⊳ Wm=[tmin,tmax]W_m=[t_min,t_max] 4: tmax←sroot.I.tend−m.τout(0,0)+m.Δt_max← s_root.I.t_end-m. _out^(0,0)+m. t 5: ℐ←(ℝ≥0∖Di′,j′)∩[tmin,tmax]I← ( R_≥ 0 D_i ,j )∩[t_min,t_max] ⊳ Reachable 6: if ℐI is empty then 7: continue ⊳ Arrival within WmW_m is blocked 8: Ilast←last interval in ℐI_last interval in I ⊳ Nearest to tmaxt_max 9: if not IsExplored(⟨i′,j′,θ′,Ilast⟩) ( i ,j ,θ ,I_last ) then 10: return false ⊳ Found unexplored interval 11: tcutoff←min(tmax,tarr+Δtmax)t_cutoff← (t_max,~t_arr+ t_max) 12: ℐ0←I_0← intervals in ℐI before tcutofft_cutoff 13: for all I∈ℐ0I _0 (checked backward) do 14: if not IsExplored(⟨i′,j′,θ′,I⟩) ( i ,j ,θ ,I ) then 15: return false 16: for all I∈ℐ∖ℐ0∖IlastI _0 \I_last\ (checked backward) do 17: if not IsExplored(⟨i′,j′,θ′,I⟩) ( i ,j ,θ ,I ) then 18: return false 19: return true ⊳ All reachable intervals are explored To maintain theoretical optimality without exhaustive global interval checks, we introduce a bounded, time-aware pruning mechanism. For a regular state u=⟨i,j,Ψ,sroot⟩u= i,j, ,s_root with arrival time tarrt_arr, the physically possible arrival times at any spatial endpoint via a primitive m are strictly confined to a continuous window Wm=[tmin,tmax]W_m=[t_min,t_max]. It reflects the constraint that motion cannot initiate before the agent’s arrival – tmin=tarr+m.Δt_min=t_arr+m. t – or later than the interval’s closure, accounting for the time required to fully vacate the root grid cell: tmax=sroot.I.tend−m.τout(0,0)+m.Δt_max=s_root.I.t_end-m. _out^(0,0)+m. t. To safely prune u, every safe interval I intersecting WmW_m must be explored – meaning its corresponding SIPP state has already been expanded by the search (which, under A* properties, guarantees its optimal cost is securely fixed), or its current arrival time matches the theoretical absolute minimum of the interval, I.tstartI.t_start. If even one intersecting interval remains unexplored, the endpoint might yield a better path, and pruning is immediately aborted. Theorem 1 MeshSIPP is complete and optimal, yielding identical solutions (in terms of path cost and spatial traces) to the standard SIPP algorithm over the same control set. Proof Sketch: The proof establishes that augmenting the mesh graph with temporal anchors (sroots_root) and deferred continuous evaluation yields a dynamic search space isomorphic to the standard SIPP state lattice with respect to optimal paths. We first prove the correspondence for a single motion primitive. Specifically, MeshSIPP constructs a chain of states whose grid projections form exactly the primitive’s spatial trace, ensuring identical interactions with static obstacles in both representations. Once the trace reaches the primitive’s endpoint, MeshSIPP performs the exact continuous temporal evaluation, as in SIPP, yielding the same departure window, successor safe interval, and transition cost. This correspondence extends to arbitrary sequences of primitives by concatenating the corresponding MeshSIPP chains. Finally, the pruning rules do not break this correspondence: conservative pruning removes only branches whose entire reachable temporal window is occupied (Algorithm 1, Line 7), while early terminal pruning removes only branches whose reachable intervals have already been explored. IV-D Heuristic Interval Ordering While verifying all intervals within WmW_m guarantees optimality, a sequential scan introduces a computational bottleneck. To accelerate the discovery of unexplored intervals – and thereby abort the pruning check faster – we evaluate the intervals in a heuristically permuted order. Our strategy is designed to fail-fast by exploiting the chronological expansion properties of A*. Since later time intervals are typically explored deeper in the search tree, scanning reachable intervals in reverse chronological order maximizes the probability of immediately encountering an unexplored state. Furthermore, a powerful bound can be established based on the expansion status of the latest reachable interval. If IlastI_last (nearest to tmaxt_max) has already been explored, it implies that the search previously reached this spatial cell via some primitive m from a predecessor state expanded at some earlier time t′≤tarrt ≤ t_arr. The same spatial trajectory with zero (or minimal) waiting would have reached earlier safe intervals at arrival times starting from t′+Δt + t. Since t′≤tarrt ≤ t_arr, we can strictly bound these early arrival times by defining a cutoff threshold: t′+Δt≤tarr+maxm∈ControlSet(Δt)=:tcutofft + t≤ t_arr+ _m∈ ControlSet( t)=:t_cutoff. Consequently, all intervals from tmaxt_max down to tcutofft_cutoff are highly likely to have already been expanded via these zero-wait continuations, unless a dynamic obstacle has blocked those earlier arrivals. This logic is implemented in Algorithm 2. First, it evaluates IlastI_last – if unexplored, the pruning check aborts immediately (Lines 8–10). Second, it jumps to tcutofft_cutoff and scans backward toward tmint_min (Lines 11–15). Finally, it verifies any remaining intervals between tcutofft_cutoff and IlastI_last, also in backward order (Lines 16–18). This permuted sequence dramatically minimizes average memory accesses. Because the entire window WmW_m is comprehensively verified before a state is conclusively pruned (Line 19), the fail-fast heuristic strictly preserves the optimality guarantees of the algorithm. V Experiments To evaluate the performance, scalability, and execution efficiency of MeshSIPP, we conducted both numerical benchmarks and ROS2/Gazebo simulations. V-A Numerical experiments In the experiments we use the grid maps from the Moving AI benchmark [14]: Denver_1_256 (city layout, 256×256256× 256), arena (open space with structured static obstacles, 49×4949× 49), and empty_64x64 (unobstructed grid, 64×6464× 64). Dynamic obstacles were simulated as independent agents moving along predefined trajectories. For each obstacle density, we generated sets of problem instances with randomly assigned valid start and goal configurations. In total, more than 6,000 evaluation runs were executed to ensure representativeness. The motion primitive control set was constructed following the methodology of [15] (Fig. 2). Robot orientations are discretized into 16 headings and for each one the control set provides 24 primitives with lengths ranging from 1 to 9 grid units, each terminating at a cell center and aligned with the valid discrete orientations. Motion along all primitives is executed at a constant speed of 0.1 cells per tick, where a tick represents the base simulation time step. Baselines. We compare MeshSIPP algorithm against four baselines that share the same underlying kinematic limits (maximum velocity and turning radius). • SIPP: The standard Safe Interval Path Planning algorithm with motion primitives using the same control set from Fig. 2. Both SIPP and MeshSIPP were implemented in C++ to provide a meaningful comparison. • ST-RRT*: A spatiotemporal variant of the probabilistically optimal RRT* algorithm [4], connecting sampled states (x,y,t)(x,y,t) via constant-velocity linear segments. We utilized the standard implementation from the Open Motion Planning Library (OMPL v1.7.0 for C++) [16]. The time budget was set generously to max(1.0,2×TSIPP) (1.0,~2× T_SIPP) seconds, where TSIPPT_SIPP is the SIPP baseline runtime. • ST-RRT*-Dubins: An extension of the previous baseline where the spatial space is replaced with Dubins space. Consequently, the algorithm samples four-dimensional states (x,y,θ,t)(x,y,θ,t) and connects them via Dubins curves, natively respecting the agent’s kinematic constraints. Due to the increased computational complexity of the steering function, the time budget was doubled relative to standard ST-RRT*. • ORCA: A two-stage approach widely used in robotics. A path is first planned ignoring dynamic obstacles. Then Optimal Reciprocal Collision Avoidance (ORCA) local planner [17] tracks the path while reactively avoiding dynamic agents. We utilized the official implementation from the RVO2 library (also in C++) [18]. Notably, while standard ORCA assumes cooperative collision avoidance where all agents share the responsibility equally, the dynamic obstacles in our setup are strictly non-cooperative. To account for this, we adjusted the ORCA velocity update factor, increasing it from the standard 0.5 to 1.0, thereby assigning the entire avoidance maneuver exclusively to the ego-agent. Fig. 4: Performance and trajectory evaluation of the tested algorithms. (a) Median runtime relative to standard SIPP across three map topologies with varying dynamic obstacle counts. (b) Snapshots of trajectory execution at t=250.0t=250.0 ticks on the arena map populated with 20 dynamic obstacles. The ego-agent (red circle, radius 1.0) navigates from start (42,7)(42,7) to goal (14,37)(14,37). TABLE I: Median cost ratio and success rate (Cost / SR) relative to standard SIPP. arena empty_64_64 Denver_1_256 Algorithm N=0N=0 N=5N=5 N=35N=35 N=0N=0 N=20N=20 N=80N=80 N=0N=0 N=50N=50 N=200N=200 SIPP 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% MeshSIPP 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% 1.0 / 100% ORCA 1.0 / 100% 1.0 / 100% 1.3 / 90.2% 1.0 / 99.6% 1.1 / 100% 1.6 / 67.6% 1.0 / 98.5% 1.1 / 98.6% 1.3 / 70.1% ST-RRT* 1.8 / 87.8% 1.6 / 87.4% 1.9 / 88.0% 1.7 / 91.8% 1.7 / 91.2% 2.0 / 90.3% 2.6 / 89.9% 2.2 / 89.7% 2.0 / 85.9% ST-RRT*-Dubins 2.2 / 80.0% 2.3 / 79.3% 3.3 / 54.3% 1.8 / 89.3% 2.1 / 87.1% 3.9 / 68.8% 2.4 / 85.9% 2.4 / 84.2% 2.5 / 76.5% Results. The experimental results are summarized in Fig. 4(a) and Table I. As anticipated, the MeshSIPP algorithm consistently achieves identical optimal path costs (1.0 ratio) and a 100% success rate across all evaluated instances, matching the SIPP baseline. At the same time, it delivers a substantial reduction in computation time. The performance graphs demonstrate a stable speedup of approximately 2 to 3 times over the baseline SIPP. Crucially, this efficiency gain remains highly consistent across different map types and varying quantities of dynamic obstacles, demonstrating the scalability and reproducibility of MeshSIPP. In contrast, the performance of ORCA depends heavily on obstacle density. Being a purely reactive local planner that bypasses complex graph searches, ORCA exhibits exceptional speed in sparse scenarios. In these simpler cases, ORCA frequently achieves a 100% success rate and near-optimal trajectory costs. However, as the density of dynamic obstacles increases, its performance sharply degrades. In heavily populated environments, the high density of dynamic agents forces the reactive planner into continuous evasive maneuvers and oscillatory behavior, substantially increasing both the final path cost (execution time of the trajectory) and the total computation time required by ORCA to simulate and calculate the path itself. Because the obstacles are non-cooperative and strictly follow their predefined trajectories, they frequently corner the ego-robot into unavoidable collisions. This fundamental limitation is reflected in a drastically reduced success rate, dropping to 67.6% on the empty_64_64 map with 80 obstacles and 70.1% on the Denver_1_256 map with 200 obstacles. For the sampling-based baselines, ST-RRT* and ST-RRT*-Dubins, execution time is bounded by a predefined budget, making direct runtime comparisons uninformative. Despite receiving generous computational budgets, both variants frequently fail to reach a 100% success rate. Unlike ORCA, where a failure denotes a physical collision during execution, a failure in the sampling-based planners indicates an inability to discover a collision-free space-time trajectory before the time limit expires. When successful, the stochastic nature of RRT* inherently yields suboptimal paths, which is reflected in the elevated median cost ratios (up to 3.9×3.9×) in Table I. The runtime speedup profiles in Fig. 4(a) provide additional context regarding the scalability of the sampling-based methods. Because the RRT* variants were allotted a minimum base budget of 1.0 second, their relative speedup appears near zero in simpler scenarios where the deterministic SIPP resolves the problem in milliseconds. However, in the most computationally demanding scenarios, such as the Denver_1_256 map with extensive dynamic traffic, SIPP’s runtime increases significantly. Consequently, the relative speedups of the ST-RRT* variants rise to meet their theoretical budget caps (12 12 and 14 14 of SIPP’s runtime). This convergence highlights that while sampling-based methods carry an excessive overhead for standard planar spatiotemporal navigation, their fixed-budget scaling becomes competitive as the combinatorial complexity of the exact search space approaches extremes, reinforcing their standard application in highly complex, high-dimensional configuration spaces (such as multi-DOF manipulators). Sample trajectory executions and their total costs are illustrated in Fig. 4(b). Indeed, SIPP and MeshSIPP produce smooth lowest-cost paths. V-B Real-Time Validation in ROS 2 and Gazebo To validate MeshSIPP in a realistic physics engine, we deployed the planner within a Robot Operating System (ROS 2) [19, 20] and Gazebo [21] simulation. The physical environment and system architecture were strictly configured to test the planner’s real-time adaptability. • Workspace: A 10×1010× 10 meter room, discretized into a 100×100100× 100 occupancy grid. This yields a spatial resolution of 0.10.1 meters per cell, utilized for both internal planning and RViz visualization. • Kinematics: The planner utilizes the motion primitives from Fig. 2. Time resolution is fixed at 1 tick = 0.08 seconds. Consequently, the planned movement speed across grid cells is 0.1 meters per 0.08 seconds, equating to 1.25 m/s (approx. 4.5 km/h) – a velocity representative of a fast pedestrian or a standard service robot. • Agents: The ego-robot is modeled as a standard TurtleBot3 Waffle Pi (radius 0.220.22 meters) [22]. The environment is densely populated with 20 dynamic obstacles, modeled as moving cylinders with a radius of 10 cm and a height of 1.5 meters. • System Architecture: A custom ROS 2 node manages dynamic obstacles, invokes MeshSIPP, publishes the generated trajectory to RViz, and tracks the resulting path via a PID wheel velocity controller. Standard localization is handled by the Nav2 [23] stack. Fig. 5: Real-time navigation in the ROS 2 and Gazebo simulation. Left: The 3D physical environment in Gazebo, featuring the TurtleBot3 ego-agent, dynamic obstacles (red cylinders), and simulated 2D LiDAR scans (blue rays). Right: The corresponding RViz visualization showing the occupancy grid, inflated obstacle footprints, and the planned MeshSIPP trajectory (orange/blue primitives). To bridge the gap between deterministic planning and real-world perception limits, we imposed a strict planning horizon. The robot is only permitted to predict dynamic obstacle trajectories for the next 200 ticks (16 seconds). Any time state beyond this 16-second threshold is assumed to be free of dynamic obstacles. To compensate for this limited foresight, the robot triggers a mandatory replan every 3 seconds. Throughout the simulation, MeshSIPP demonstrated high efficiency, requiring an average of only 50 ms of computation time for each replanning cycle. By utilizing this receding-horizon strategy, the trajectory dynamically adapts and shifts over time as the ego-robot closes the distance to the moving obstacles. This allows the robot to seamlessly weave through dense, non-cooperative traffic and successfully reach the goal without any collisions. This adaptive behavior is visualized in Fig. 5. The top panels display the early stages of navigation, where distant obstacles fall beyond the temporal horizon and the robot plans a relatively direct route. The bottom panels illustrate the adapted trajectory later in the run, showcasing the planner heavily modifying the route to evade the approaching obstacle cluster. Full continuous execution of this scenario is available in the supplementary demonstration video. VI Conclusion In this paper, we presented MeshSIPP, an efficient spatiotemporal path planning algorithm that integrates state-lattice motion primitives with Safe Interval Path Planning (SIPP). By searching over a mesh graph with time-aware pruning, the method eliminates redundant branches while maintaining completeness and optimality. Evaluations demonstrate a consistent 3×3× runtime speedup over standard lattice SIPP with identical trajectory quality. Future work will extend MeshSIPP to multi-agent systems via decentralized or prioritized frameworks and validate the algorithm on physical robots in real-world scenarios. References [1] S. Karaman and E. Frazzoli (2010) Incremental sampling-based algorithms for optimal motion planning. ArXiv abs/1005.0416. Cited by: §I. [2] S. LaValle and J. Kuffner (2001) Randomized kinodynamic planning.. I. J. Robotic Res. 20, p. 378–400. Cited by: §I. [3] S. Karaman and E. Frazzoli (2011) Sampling-based algorithms for optimal motion planning. The International Journal of Robotics Research 30 (7), p. 846–894. External Links: Document Cited by: §I. [4] F. Grothe, V. N. Hartmann, A. Orthey, and M. Toussaint (2022) ST-rrt*: asymptotically-optimal bidirectional motion planning through space-time. In 2022 International Conference on Robotics and Automation (ICRA), Vol. , p. 3314–3320. External Links: Document Cited by: §I, 2nd item. [5] P. E. Hart, N. J. Nilsson, and B. Raphael (1968) A formal basis for the heuristic determination of minimum cost paths. IEEE Transactions on Systems Science and Cybernetics 4 (2), p. 100–107. External Links: Document Cited by: §I. [6] M. Phillips and M. Likhachev (2011) SIPP: safe interval path planning for dynamic environments. In 2011 IEEE International Conference on Robotics and Automation, Vol. , p. 5628–5635. External Links: Document Cited by: §I, §I. [7] K. Yakovlev and A. Andreychuk (2017) Any-angle pathfinding for multiple agents based on sipp algorithm. In International Conference on Automated Planning and Scheduling, Vol. 27, p. 586–594. External Links: Document Cited by: §I. [8] Z. A. Ali and K. Yakovlev (2023) Safe interval path planning with kinodynamic constraints. Proceedings of the AAAI Conference on Artificial Intelligence 37 (10), p. 12330–12337. External Links: Document Cited by: §I. [9] S. Huang, Y. Wu, Y. Tao, and V. Kumar (2025) Safe interval motion planning for quadrotors in dynamic environments. In 2025 IEEE International Conference on Robotics and Automation, Vol. , p. 2780–2786. External Links: Document Cited by: §I. [10] N. Kerimov, A. Onegin, and K. Yakovlev (2025) Safe interval randomized path planning for manipulators. In International Conference on Automated Planning and Scheduling, Vol. 35, p. 213–217. External Links: Document Cited by: §I. [11] V. Narayanan, M. Phillips, and M. Likhachev (2012) Anytime safe interval path planning for dynamic environments. In IEEE/RSJ International Conference on Intelligent Robots and Systems, Vol. , p. 4708–4715. External Links: Document Cited by: §I. [12] M. Agranovskiy (2027) Path planning with motion primitives in dynamic environments: sipp on lattices. In Interactive Collaborative Robotics, p. 406–420. External Links: Document Cited by: §I. [13] M. Agranovskiy and K. Yakovlev (2026) MeshA*: efficient path planning with motion primitives. Proceedings of the AAAI Conference on Artificial Intelligence 40 (43), p. 36785–36792. External Links: Document Cited by: §I, §IV-A. [14] N. Sturtevant (2012) Benchmarks for grid-based pathfinding. Transactions on Computational Intelligence and AI in Games 4 (2), p. 144 – 148. Cited by: §V-A. [15] B. Nagy and A. Kelly (2001) Trajectory generation for car-like robots using cubic curvature polynomials. In Field and Service Robotics (FSR 01), Helsinki, Finland. Cited by: §V-A. [16] I. Sucan, M. Moll, and L. Kavraki (2012) The open motion planning library. IEEE Robotics & Automation Magazine 19, p. 72–82. External Links: Document Cited by: 2nd item. [17] J. van den Berg, S. Guy, M. Lin, and D. Manocha (2011) Reciprocal n-body collision avoidance. Vol. 70, p. 3–19. External Links: ISBN 978-3-642-19456-6, Document Cited by: 4th item. [18] Snape/rvo2: v2.0.2 External Links: Document Cited by: 4th item. [19] M. Quigley, K. Conley, B. P. Gerkey, J. Faust, T. Foote, J. Leibs, R. Wheeler, and A. Y. Ng (2009) ROS: an open-source robot operating system. In ICRA Workshop on Open Source Software, Cited by: §V-B. [20] Y. Maruyama, S. Kato, and T. Azumi (2016) Exploring the performance of ros2. In Proceedings of the 13th International Conference on Embedded Software, EMSOFT ’16, New York, NY, USA. External Links: ISBN 9781450344852, Document Cited by: §V-B. [21] N. Koenig and A. Howard (2004) Design and use paradigms for gazebo, an open-source multi-robot simulator. In 2004 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) (IEEE Cat. No.04CH37566), Vol. 3, p. 2149–2154 vol.3. External Links: Document Cited by: §V-B. [22] E. Guizzo and E. Ackerman (2017) The turtlebot3 teacher [resources_hands on]. IEEE Spectrum 54 (8), p. 19–20. External Links: Document Cited by: 3rd item. [23] S. Macenski, F. Martin, R. White, and J. Ginés Clavero (2020) The marathon 2: a navigation system. In 2020 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), Cited by: 4th item.