Planner-Free Trajectory Pipeline

• The pipeline’s main contribution is embedding spatial and temporal constraints into a unified mixed-integer convex programming framework, eliminating the need for an initial trajectory guess.
• It leverages convex decomposition, IRIS-based sampling, and Bézier spline parameterization to represent and optimize time-parameterized trajectories in complex dynamic settings.
• Empirical results demonstrate optimal path lengths and rapid convergence in both static and dynamic scenarios, balancing solution quality with computational cost.

A planner-free trajectory construction pipeline is a method for systematically generating optimal, time-parameterized, collision-free trajectories—especially in cluttered and dynamic environments—without requiring a user-provided initial guess for the trajectory. The key innovation is the embedding of both spatial and temporal constraints into a unified mixed-integer convex programming (MICP) framework via the Space-Time Graphs of Convex Sets (ST-GCS) formalism. This approach leverages convex decomposition, IRIS-based sampling, and the Bézier spline parameterization to circumvent the initialization difficulties inherent in traditional nonconvex trajectory optimization (Osburn et al., 13 Aug 2025).

1. Problem Setting and Space–Time Embedding

The ST-GCS pipeline addresses motion planning for dynamic environments specified by a start state $p_s=(x_s,y_s,t_s)$, a goal state $p_f=(x_f,y_f,t_f)$, a set of obstacles (static or moving with known constant-velocity over $[t_s, t_f]$), and a robot kinematic upper bound $v_\mathrm{max}$ on speed.

Spatial configurations $(x, y)$ at each time $t$ are mapped into $\mathbb{R}^3$ by appending the temporal coordinate. Static obstacles are represented as prisms extruded along the temporal axis, while moving obstacles are encoded as 3D polyhedra bounded by their respective vertex trajectories—specifically, the vertex at time $t_s$ and at $t_f$, joined by lateral faces.

2. Convex Set Generation and Space–Time Graph Construction

Convex decomposition of the collision-free space-time region is achieved by repeatedly sampling free seed points $q \in \mathbb{R}^3$ and, if the point is not inside any obstacle polytope, executing the IRIS algorithm to compute the maximal collision-free convex polytope $\mathcal{A}_v$ containing $q$. Each such polytope becomes a node $v$ in the graph. Whenever two polytopes are adjacent (share a boundary face), bidirectional edges are established between the corresponding graph nodes. This process yields a sparse but connected graph structure spanning the space-time collision-free manifold.

3. Trajectory Representation and Optimization Variables

Trajectories are encoded as sequences of Bézier spline segments. Each active graph node $v$ is associated with an $n$th-order Bézier segment $\mathcal{B}_v(s)$ parameterized by control points $\{x_{v,i}\}_{i=0}^n \subset \mathbb{R}^3$. The global trajectory $\mathcal{P}(r)$ is the concatenation of these spline segments along the selected path through the graph. The decision variables comprise activation indicators for vertices and edges ($y_v, y_e \in \{0,1\}$), continuous control point positions, and “lifted” variables $z_{v,i}, z_{e,i}$ defined as $z = yx$ to facilitate handling of activation-dependent constraints.

4. MICP Formulation: Objective and Constraints

Trajectory optimization proceeds via the following MICP design:

• Objective Function: Minimize the total 2D path length

$$\min_{z, y} \quad J(z) = \sum_{v \in \mathcal{V}} \sum_{i=0}^{n-1} \lVert z_{v,i+1} - z_{v,i} \rVert_{xy,2},$$

where $\lVert \cdot \rVert_{xy,2}$ ignores the temporal component.

• Constraints:
  • Flow Conservation (Path Selection):

  $$\sum_{(a,v) \in \mathcal{E}} y_{(a,v)} + \delta_{v,s} = \sum_{(v,b) \in \mathcal{E}} y_{(v,b)} + \delta_{v,f} = y_v, \quad \delta_{v,s} = \mathbf{1}[v = s], \ \delta_{v,f} = \mathbf{1}[v = f]$$ - Set Containment (Collision Avoidance):

  $A_v z_{v,i} \leq b_v y_v$

  for each active vertex and each of its control points. - Edge Continuity:

  $$z_{v,n} = \sum_{(v,b)\in\mathcal{E}} z_{(v,b),0} \quad \forall v\neq f$$ - Differentiability at Junctions:

  $$z_{v,n} - z_{v,n-1} = \sum_{(v,b) \in \mathcal{E}} z_{(v,b),\mathrm{diff}} \quad \forall v\neq f$$

  where $$z_{(v,b),\mathrm{diff}} = z_{(v,b),1} - z_{(v,b),0}$$. - Causality and Velocity Bound:

  $$\lVert z_{v,i+1} - z_{v,i} \rVert_{xy,2} \leq v_{\max} (z_{v,i+1} - z_{v,i})_t, \quad (z_{v,i+1} - z_{v,i})_t \geq \epsilon y_v$$

  for all consecutive control points and a small $\epsilon$ to preclude zero-time jumps. - Integrality and Relaxation: The binary indicators $y_v, y_e$ are relaxed to $[0,1]$ and solved to optimality via branch-and-bound.

5. Systematic Constraint Formulation via GCS-Compatible Approach

The framework employs a generalized recipe for constructing constraints compatible with the GCS methodology. Any edge-spanning constraint, such as continuity or differentiability, is introduced initially as if the edge were active, multiplied by its activation indicator, summed over all successors, and then the indicator sum is replaced via the flow conservation condition. The “lifted” variable formulation absorbs the resulting bilinearities, permitting consistent inclusion of disparate constraints within the convex optimization landscape.

6. Graph Structure, Cost Functions, and Solver Implementation

Each node in the constructed graph corresponds to a convex polytope in augmented space-time, with edges linking adjacent polytopes (no edge cost, $f_e \equiv 0$). The cost at a vertex, $f_v(x_v)$, upper-bounds the associated Bézier segment’s length. The complete optimization problem is solved as an MICP, with global optimality enforced via branch-and-bound—made tractable by convex relaxations and cones that tightly constrain the feasible set. Implementations use Python/CVXPY and solvers such as CLARABELL, Gurobi, or Mosek. Performance is tunable by adjusting branch-and-bound tolerances (e.g., MIPGap) and graph density (sampling more IRIS seeds increases solution quality at the cost of additional variables and computation time).

7. Empirical Performance and Practical Notes

Experiments demonstrate that ST-GCS and standard GCS yield identical performance when the environment is static (path length of $1.0318\,\mathrm{m}$), while ST-GCS extends naturally to solve instances with moving obstacles, e.g., generating a minimal-length ($1.00\,\mathrm{m}$) trajectory in dynamic single-obstacle scenarios with rapid convergence ($0.52\,\mathrm{s}$ solve time). In dense dynamic fields (20 moving obstacles), increasing graph density from 80 to 1000 seed points enables a trade-off between trajectory optimality (from $1.24\,\mathrm{m}$ to $1.03\,\mathrm{m}$) and solve time (from $4.75\,\mathrm{s}$ to $82.3\,\mathrm{s}$). The MICP is NP-hard; practical tractability is achieved by pruning unreachable vertices and tuning solver parameters. Higher-order splines ($n>3$) increase trajectory smoothness at the expense of additional optimization variables.

A salient feature of this pipeline is the elimination of the need for an initial trajectory guess: the convex decomposition and resultant graph structure serve as a “warm start,” enabling direct optimization of the global path and timing (Osburn et al., 13 Aug 2025).