Struct ClockModel 

pub struct ClockModel {
    pub gain: f64,
    pub offset: f64,
    pub residuals: f64,
    pub n_measurements: u64,
}

Linear clock synchronization model for multi-camera systems.

This structure implements a linear transformation to synchronize timestamps between different clock sources (e.g., camera hardware clocks vs. host system clock). The transformation follows the equation: host_time = gain * device_time + offset.

The clock model is essential for multi-camera synchronization in the Strand Camera system, allowing timestamps from different sources to be aligned to a common time reference.

Mathematical Model

The linear relationship is: t_host = gain × t_device + offset

• gain: Clock rate ratio (typically close to 1.0)
• offset: Time offset between clock sources
• residuals: Sum of squared residuals from the linear fit
• n_measurements: Number of data points used to compute the model

Examples

use strand_cam_bui_types::ClockModel;

// Create a clock model with typical values
let clock_model = ClockModel {
    gain: 1.000001,           // Slightly faster device clock
    offset: -1234567.89,      // Device clock started earlier
    residuals: 0.001,         // Good fit quality
    n_measurements: 100,      // Based on 100 sync points
};

// Convert device timestamp to host timestamp
let device_time = 1000.0;
let host_time = clock_model.gain * device_time + clock_model.offset;

Fields

gain: f64

Clock rate ratio between device and host clocks.

This represents how fast the device clock runs relative to the host clock. A value of 1.0 means identical rates, > 1.0 means the device clock runs faster, and < 1.0 means it runs slower.

offset: f64

Time offset between device and host clocks.

This is the constant offset needed to align the two time sources. The offset accounts for differences in when the clocks were started and any systematic time differences.

residuals: f64

Sum of squared residuals from the linear regression fit.

This value indicates the quality of the linear fit - smaller values indicate better synchronization. It’s computed during the least-squares fitting process used to determine the gain and offset parameters.

n_measurements: u64

Number of timestamp measurements used to compute this model.

More measurements typically lead to better model accuracy. The synchronization system collects timestamp pairs over time to build a robust clock model.

Trait Implementations

impl Clone for ClockModel

fn clone(&self) -> ClockModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClockModel

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClockModel

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ClockModel

fn eq(&self, other: &ClockModel) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ClockModel

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ClockModel