python123-ops/moonground/motion does not have a README file

    FrameResult

    pub(all) struct FrameResult {
    session_id : String
    timestamp_us : Int64
    tracks : Array[TrackEstimate]
    closed_segment_ids : Array[String]
    } derive(
    Debug
    )

    Segment identifiers are exact Int64 decimal strings within session_id.

    MotionCheckpoint

    pub(all) struct MotionCheckpoint {
    version : Int
    session_id : String
    config : MotionConfig
    last_timestamp_us : Int64?
    next_segment_id : Int64
    tracks : Array[TrackCheckpoint]
    } derive(
    Debug
    )

    Versioned motion state after the last committed frame. Int64 fields must use exact decimal strings in wire formats. Arrays are detached from the engine.

    MotionConfig

    pub struct MotionConfig {
    max_gap_us : Int64
    min_observations : Int
    min_span_us : Int64
    acceleration_spectral_density : Double
    initial_velocity_std : Double
    innovation_gate : Double
    max_tracks : Int
    max_position_std_m : Double?
    max_velocity_std_mps : Double?
    } derive(
    Debug
    )

    Runtime limits and continuous white-acceleration model parameters.

    MotionConfig::max_position_std_m

    fn MotionConfig::max_position_std_m(self : MotionConfig) -> Double?

    Optional worst-direction one-sigma position limit in metres.

    MotionConfig::max_tracks

    fn MotionConfig::max_tracks(self : MotionConfig) -> Int

    MotionConfig::max_velocity_std_mps

    fn MotionConfig::max_velocity_std_mps(self : MotionConfig) -> Double?

    Optional worst-direction one-sigma velocity limit in metres per second.

    MotionConfig::new

    fn MotionConfig::new(max_gap_us? : Int64, min_observations? : Int, min_span_us? : Int64, q? : Double, initial_velocity_std? : Double, gate? : Double, max_tracks? : Int, max_position_std_m? : Double, max_velocity_std_mps? : Double) -> MotionConfig raise
    GroundError

    Configure SI-unit filtering. q has units m²/s³; timestamps use microseconds. Optional one-sigma limits affect speed availability, not observation updates.

    MotionEstimator

    pub struct MotionEstimator {
    session_id : String
    config : MotionConfig
    tracks : Map[Int, TrackState]
    last_timestamp : Int64?
    next_segment : Int64
    }

    Bounded per-session state. Frame validation precedes all mutable work; candidates are committed only after the complete frame succeeds.

    MotionEstimator::active_track_count

    fn MotionEstimator::active_track_count(self : MotionEstimator) -> Int

    MotionEstimator::checkpoint

    Copy bounded accepted state without changing frame time or segment allocation.

    MotionEstimator::fork

    Create an independent branch at the same committed frame. Accepted track buffers are shared internally until replacement; neither branch mutates them.

    MotionEstimator::from_checkpoint

    Restore a new engine only after the complete checkpoint validates. Original covariance entries are preserved, including roundoff asymmetry; no filter prediction, covariance repair or wall-clock expiration happens here.

    MotionEstimator::last_timestamp_us

    fn MotionEstimator::last_timestamp_us(self : MotionEstimator) -> Int64?

    MotionEstimator::new

    MotionEstimator::update

    Apply one globally increasing frame atomically. Missing tracks produce no prediction output. Lost/removed identities and accepted-observation gaps at least max_gap_us close and release the segment without retaining tombstones.

    MotionStatus

    pub(all) enum MotionStatus {
    Initializing
    Ready
    Uncertain
    RejectedInnovation
    NumericalFailure
    } derive(Eq,
    Debug
    )

    Readiness refers to motion measurement, not availability of a filtered point. Uncertain has completed warmup but exceeds an enabled uncertainty limit.

    MotionStatus::equal

    MotionStatus::not_equal

    fn MotionStatus::not_equal(x : MotionStatus, y : MotionStatus) -> Bool

    TrackCheckpoint

    pub(all) struct TrackCheckpoint {
    track_id : Int
    segment_id : Int64
    first_timestamp_us : Int64
    last_timestamp_us : Int64
    accepted_count : Int
    state : Array[Double]
    covariance : Array[Double]
    first_filtered :
    Point2

    last_filtered :
    Point2

    observed_path_length_m : Double
    } derive(
    Debug
    )

    Accepted state of one active segment. Covariance uses row-major state order [x, y, vx, vy]. Times refer to accepted observations, not missing frames.

    TrackEstimate

    pub(all) struct TrackEstimate {
    track_id : Int
    segment_id : String
    status : MotionStatus
    position :
    Point2
    ?
    position_covariance :
    Covariance2
    ?
    velocity :
    Point2
    ?
    velocity_covariance :
    Covariance2
    ?
    position_std_m : Double?
    velocity_std_mps : Double?
    speed_mps : Double?
    observed_path_length_m : Double
    net_displacement_m : Double
    accepted_count : Int
    last_accepted_timestamp_us : Int64
    filtered_state : Array[Double]?
    filtered_covariance : Array[Double]?
    } derive(
    Debug
    )

    A result for an observation submitted in this frame. Rejections carry no stale position or velocity. Path length is the accepted filtered polyline, and does not claim the object's unobserved travelled distance. Each standard deviation is sqrt(lambda_max) of its 2 by 2 covariance. Initializing has no velocity deviation; Uncertain retains accepted vectors and deviations but withholds speed_mps.

    TrackState

    type TrackState