inverse_aerial

This is a continuation of a previous post, to demonstrate how to solve the inverse problem of determining user input from trajectories.

Problem Statement

Say we know that, at a particular instant in time, a user was controlling a vehicle in the air (without being hit by another car, or air dodging). Is it possible to use information about the car's dynamic state to determine what inputs the users issued?

Let's take a look: from the previous post, we have the following update procedure for the angular velocity:

ω (t + Δ t) := ω (t) + τ Δ t

$\boldsymbol{\omega}$ $\boldsymbol{\tau}$ must have been:

τ = \frac{ω (t + Δ t) - ω (t)}{Δ t}

$\boldsymbol{\tau}$ in the other post, we can say that

τ = Θ (t) (T u + D (u) Θ (t)^{⊤} ω (t))

$\boldsymbol{u}$ $\boldsymbol{D}(\boldsymbol{u})$ $\boldsymbol{u}$ , making the equations nonlinear:

\begin{aligned} T_{r} & u_{r} & = τ_{r} - D_{r} ω_{r} \\ T_{p} & u_{p} - D_{p} | u_{p} | & = τ_{p} - D_{p} ω_{p} \\ T_{y} & u_{y} - D_{y} | u_{y} | & = τ_{y} - D_{y} ω_{y} \end{aligned} where \tilde{τ} = [\begin{matrix} τ_{r} \\ τ_{p} \\ τ_{y} \end{matrix}] = Θ^{⊤} τ, \tilde{ω} = [\begin{matrix} ω_{r} \\ ω_{p} \\ ω_{y} \end{matrix}] = Θ^{⊤} ω

Thankfully, they are decoupled, so they can be solved individually:

Roll:

u_{r} = \frac{τ_{r} - D_{r} ω_{r}}{T_{r}}

Pitch:

u_{p} = \frac{τ_{p} - D_{p} ω_{p}}{T_{p} + sgn (τ_{p} - D_{p} ω_{p}) ω_{p} D_{p}}

Yaw:

u_{y} = \frac{τ_{y} - D_{y} ω_{y}}{T_{y} - sgn (τ_{y} - D_{y} ω_{y}) ω_{y} D_{y}}

$\text{sgn}$ () is the signum function. Ideally, these values will always be in the range (-1, 1), but to get the best admissible input in weird cases, do the following as well:

\begin{aligned} u_{r} & : = u_{r} min (1.0, \frac{1}{| u_{r} |}) \\ u_{p} & : = u_{p} min (1.0, \frac{1}{| u_{p} |}) \\ u_{y} & : = u_{y} min (1.0, \frac{1}{| u_{y} |}) \end{aligned}

Dealing with Maximum Angular Speed

If the norm of angular velocity exceeds 5.5, Rocket League scales it back down, until it is 5.5. How does this affect our ability to guess the inputs of a trajectory?

$\boldsymbol\tau$ that produces identical end-step angular velocities. As a result, there can be cases where there are infinitely many possible inputs that produce the same aerial trajectory. The procedure described above will still work, and will find the inputs that produce the torque of minimum magnitude that yields the appropriate end-step angular velocity!

Example Problem

These examples show how well the recovered user input (dashed lines) compares to the exact values (solid lines). The trace in red is the norm of the angular velocity-- note that when it hits 5.5, the inputs do not coincide. However, it is the case that the exact inputs and the recovered would still have the same effect on the car.

An example where angular velocities do not clip shows almost exact agreement:

Possible Implementation


xxxxxxxxxx
const float T_r = -36.07956616966136; // torque coefficient for roll
const float T_p = -12.14599781908070; // torque coefficient for pitch
const float T_y =   8.91962804287785; // torque coefficient for yaw
const float D_r =  -4.47166302201591; // drag coefficient for roll
const float D_p = -2.798194258050845; // drag coefficient for pitch
const float D_y = -1.886491900437232; // drag coefficient for yaw

float sgn(float x) {
  return return (0.0f < x) - (x < 0.0f);
}

vec3 aerial_inputs(
    vec3 omega_start, 
    vec3 omega_end,
    mat3x3 theta_start,
    float dt) {

  // net torque in world coordinates
  vec3 tau = (omega_end - omega_start) / dt; 

  // net torque in local coordinates
  tau = dot(transpose(theta_start), tau);

  // beginning-step angular velocity, in local coordinates
  vec3 omega_local = dot(transpose(theta_start), omega_start);

  vec3 rhs{
    tau[0] - D_r * omega_local[0],
    tau[1] - D_p * omega_local[1],
    tau[2] - D_y * omega_local[2]
  };

  // user inputs: roll, pitch, yaw
  vec3 u{
    rhs[0] / T_r,
    rhs[1] / (T_p + sgn(rhs[1]) * omega_local[1] * D_p),
    rhs[2] / (T_y - sgn(rhs[2]) * omega_local[2] * D_y)
  };

  // ensure that values are between -1 and +1 
  u[0] *= fmin(1.0, 1.0 / fabs(u[0]));
  u[1] *= fmin(1.0, 1.0 / fabs(u[1]));
  u[2] *= fmin(1.0, 1.0 / fabs(u[2]));

  return u; 

}