Struct TrackingParams 

pub struct TrackingParams {
    pub motion_noise_scale: f64,
    pub initial_position_std_meters: f64,
    pub initial_vel_std_meters_per_sec: f64,
    pub ekf_observation_covariance_pixels: f64,
    pub accept_observation_min_likelihood: f64,
    pub max_position_std_meters: f32,
    pub hypothesis_test_params: Option<HypothesisTestParams>,
    pub num_observations_to_visibility: u8,
    pub mini_arena_config: MiniArenaConfig,
}

Tracking parameters

The terminology used is as defined at the Wikipedia page on the Kalman filter.

The state estimated is a six component vector with position and velocity x = <x, y, z, x’, y’, z’>. The motion model is a constant velocity model with noise term, (see description).

The state covariance matrix P is initialized with the value (α is defined in the field TrackingParams::initial_position_std_meters and β is defined in the field TrackingParams::initial_vel_std_meters_per_sec:
P_initial = [[α², 0, 0, 0, 0, 0],
[0, α², 0, 0, 0, 0],
[0, 0, α², 0, 0, 0],
[0, 0, 0, β², 0, 0],
[0, 0, 0, 0, β², 0],
[0, 0, 0, 0, 0, β²]]

The covariance of the state process update Q(τ) is defined as a function of τ, the time interval from the previous update):
Q(τ) = TrackingParams::motion_noise_scale [[τ³/3, 0, 0, τ²/2, 0, 0],
[0, τ³/3, 0, 0, τ²/2, 0],
[0, 0, τ³/3, 0, 0, τ²/2],
[τ²/2, 0, 0, τ, 0, 0],
[0, τ²/2, 0, 0, τ, 0],
[0, 0, τ²/2, 0, 0, τ]]

Note that this form of the state process update covariance has the property that 2Q(τ) = Q(2τ). In other words, two successive additions of this covariance will have an identical effect to a single addtion for twice the time interval.

Fields

motion_noise_scale: f64

This is used to scale the state noise covariance matrix Q as described at the struct-level (Kalman filter parameter).

initial_position_std_meters: f64

This is α in the above formula used to build the position terms in the initial estimate covariance matrix P as described at the struct-level (Kalman filter parameter).

initial_vel_std_meters_per_sec: f64

This is β in the above formula used to build the velocity terms in the initial estimate covariance matrix P as described at the struct-level (Kalman filter parameter).

ekf_observation_covariance_pixels: f64

The observation noise covariance matrix R (Kalman filter parameter).

accept_observation_min_likelihood: f64

This sets a minimum threshold for using an obervation to update an object being tracked (data association parameter).

max_position_std_meters: f32

This is used to compute the maximum allowable covariance before an object is “killed” and no longer tracked.

hypothesis_test_params: Option<HypothesisTestParams>

These are the hypothesis testing parameters used to “birth” a new new object and start tracking it.

This is None if 2D (flat-3d) tracking.

num_observations_to_visibility: u8

This is the minimum number of observations before object becomes visible.

mini_arena_config: MiniArenaConfig

Parameters defining mini arena configuration.

This is MiniArenaConfig::NoMiniArena if no mini arena is in use.

Trait Implementations

impl Clone for TrackingParams

fn clone(&self) -> TrackingParams

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TrackingParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TrackingParams

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TrackingParams

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.