Struct PathConfig 

pub struct PathConfig {
    pub distance_scale: f64,
    pub heading_scale: f64,
    pub cutoff_distance: f64,
    pub heading_cutoff: f64,
    pub probability_threshold: f64,
    pub resampling_distance: Option<f64>,
    pub max_candidates: usize,
    pub path_only: bool,
    pub debug_mode: bool,
    pub beta: f64,
    pub edge_zone_distance: f64,
    pub turn_scale: f64,
}

Configuration for train path calculation algorithm

Controls probability thresholds, distance cutoffs, and other parameters that affect path selection and candidate filtering.

Examples

use tp_lib_core::PathConfig;

// Use default configuration
let config = PathConfig::default();
assert_eq!(config.distance_scale, 10.0);

// Create custom configuration
let config = PathConfig::builder()
    .distance_scale(15.0)
    .heading_scale(3.0)
    .cutoff_distance(75.0)
    .build()
    .unwrap();

Fields

distance_scale: f64

Distance scale parameter for exponential decay (meters) Controls how quickly probability decreases with distance

heading_scale: f64

Heading scale parameter for exponential decay (degrees) Controls how quickly probability decreases with heading difference

cutoff_distance: f64

Maximum distance from GNSS position to consider netelement as candidate (meters)

heading_cutoff: f64

Maximum heading difference to consider netelement as candidate (degrees) Positions with larger heading differences are filtered out

probability_threshold: f64

Minimum probability threshold for including segment in path (0.0 to 1.0)

resampling_distance: Option<f64>

Distance between resampled positions (meters), None to disable resampling

max_candidates: usize

Maximum number of candidate netelements per GNSS position

path_only: bool

If true, only calculate path without projecting positions (US2: T098) When true, PathResult.projected_positions will be empty

debug_mode: bool

If true, collect and return debug information about path calculation (US7: T152) Includes candidate paths, position candidates, and decision tree

beta: f64

Transition probability scale parameter (meters, Newson & Krumm β) Controls tolerance for mismatch between route distance and great-circle distance. Higher values are more forgiving of detours.

edge_zone_distance: f64

Edge-zone distance threshold (meters) Candidates whose projected point is farther than this from the nearest netelement endpoint are considered interior and cannot transition to a different netelement (transition probability = 0).

turn_scale: f64

Turn-angle scale parameter (degrees) Penalises transitions that require a direction change at a netelement connection. The penalty factor is exp(-turn_angle / turn_scale). Lower values penalise turns more aggressively.

Implementations

impl PathConfig

pub fn new( distance_scale: f64, heading_scale: f64, cutoff_distance: f64, heading_cutoff: f64, probability_threshold: f64, resampling_distance: Option<f64>, max_candidates: usize, path_only: bool, debug_mode: bool, beta: f64, edge_zone_distance: f64, turn_scale: f64, ) -> Result<Self, ProjectionError>

Create a new PathConfig with validation

pub fn builder() -> PathConfigBuilder

Create a builder for PathConfig

Trait Implementations

impl Clone for PathConfig

fn clone(&self) -> PathConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PathConfig

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

Formats the value using the given formatter.

impl Default for PathConfig

fn default() -> Self

Create default configuration with documented parameter values

Default values:

• distance_scale: 10.0 meters (exponential decay)
• heading_scale: 2.0 degrees (exponential decay)
• cutoff_distance: 500.0 meters
• heading_cutoff: 10.0 degrees
• probability_threshold: 0.02 (2%)
• resampling_distance: None (disabled)
• max_candidates: 3 netelements per position
• path_only: false (calculate path and project positions)
• debug_mode: false (no debug output)
• beta: 50.0 meters (transition probability scale)
• edge_zone_distance: 50.0 meters (edge-zone optimization threshold)
• turn_scale: 30.0 degrees (turn-angle penalty scale)

impl<'de> Deserialize<'de> for PathConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PathConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.