Struct GnssPosition 

pub struct GnssPosition {
    pub latitude: f64,
    pub longitude: f64,
    pub timestamp: DateTime<FixedOffset>,
    pub crs: String,
    pub metadata: HashMap<String, String>,
    pub heading: Option<f64>,
    pub distance: Option<f64>,
}

Represents a single GNSS measurement from a train journey

Each GnssPosition captures a timestamped geographic location with explicit coordinate reference system (CRS) information. Additional metadata can be preserved for audit trails and debugging.

Validation

• Latitude must be in range [-90.0, 90.0]
• Longitude must be in range [-180.0, 180.0]
• Timestamp must include timezone information (RFC3339 format)

Examples

use tp_lib_core::GnssPosition;
use chrono::{DateTime, FixedOffset};

let timestamp = DateTime::parse_from_rfc3339("2025-12-09T14:30:00+01:00")?;

let position = GnssPosition::new(
    50.8503,  // latitude
    4.3517,   // longitude
    timestamp,
    "EPSG:4326".to_string(),
)?;

assert_eq!(position.latitude, 50.8503);
assert_eq!(position.crs, "EPSG:4326");

Fields

latitude: f64

Latitude in decimal degrees (-90.0 to 90.0)

longitude: f64

Longitude in decimal degrees (-180.0 to 180.0)

timestamp: DateTime<FixedOffset>

Timestamp with timezone offset (e.g., 2025-12-09T14:30:00+01:00)

crs: String

Coordinate Reference System (e.g., “EPSG:4326” for WGS84)

metadata: HashMap<String, String>

Additional metadata from CSV (preserved for output)

heading: Option<f64>

Train heading in degrees (0-360), None if not available 0° = North, 90° = East, 180° = South, 270° = West

distance: Option<f64>

Distance from previous GNSS position in meters, None if not available or first position

Implementations

impl GnssPosition

pub fn new( latitude: f64, longitude: f64, timestamp: DateTime<FixedOffset>, crs: String, ) -> Result<Self, ProjectionError>

Create a new GNSS position with validation

pub fn with_heading_distance( latitude: f64, longitude: f64, timestamp: DateTime<FixedOffset>, crs: String, heading: Option<f64>, distance: Option<f64>, ) -> Result<Self, ProjectionError>

Create a new GNSS position with optional heading and distance

pub fn validate_heading(&self) -> Result<(), ProjectionError>

Validate heading if present (must be 0-360°)

pub fn is_opposite_heading(h1: f64, h2: f64) -> bool

Check if two headings are opposite Returns true if headings are closer to 180° apart than to 0° apart

Logic: Compare distance to 180° shift vs normal distance If shifting by 180° gives smaller circular distance, they’re opposite

pub fn heading_difference(h1: f64, h2: f64) -> f64

Calculate angular difference between two headings Accounts for circular nature of compass bearings Accounts for possible opposite headings (180° apart)

pub fn validate_latitude(&self) -> Result<(), ProjectionError>

Validate latitude range

pub fn validate_longitude(&self) -> Result<(), ProjectionError>

Validate longitude range

pub fn validate_timezone(&self) -> Result<(), ProjectionError>

Validate timezone is present (type-level guarantee with DateTime<FixedOffset>)

Trait Implementations

impl Clone for GnssPosition

fn clone(&self) -> GnssPosition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GnssPosition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GnssPosition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GnssPosition

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

where __S: Serializer,

Serialize this value into the given Serde serializer.