pub mod angle_change;
pub mod observation_gap;
pub mod speed;
pub mod stop;
pub mod value_change;
use std::str::FromStr;
use rayon::prelude::*;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SegmentMethod {
AngleChange,
ObservationGap,
Speed,
Stop,
ValueChange,
}
impl FromStr for SegmentMethod {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"angle_change" => Ok(SegmentMethod::AngleChange),
"observation_gap" => Ok(SegmentMethod::ObservationGap),
"speed" => Ok(SegmentMethod::Speed),
"stop" => Ok(SegmentMethod::Stop),
"value_change" => Ok(SegmentMethod::ValueChange),
other => Err(format!("unknown segment method: {other:?}")),
}
}
}
#[derive(Clone, Copy)]
pub struct SegmentConfig {
pub method: SegmentMethod,
pub min_angle_deg: f64,
pub angle_min_speed_kmh: f64,
pub gap_s: f64,
pub speed_min_kmh: f64,
pub speed_max_kmh: f64,
pub duration_s: f64,
pub stop_radius_km: f64,
pub stop_minutes_for_a_stop: f64,
pub stop_no_data_for_minutes: f64,
pub stop_min_speed_kmh: f64,
}
impl SegmentConfig {
#[allow(clippy::too_many_arguments)]
pub fn new(
method: SegmentMethod,
min_angle_deg: f64,
angle_min_speed_kmh: f64,
gap_s: f64,
speed_min_kmh: f64,
speed_max_kmh: f64,
duration_s: f64,
stop_radius_km: f64,
stop_minutes_for_a_stop: f64,
stop_no_data_for_minutes: f64,
stop_min_speed_kmh: f64,
) -> Self {
SegmentConfig {
method,
min_angle_deg,
angle_min_speed_kmh,
gap_s,
speed_min_kmh,
speed_max_kmh,
duration_s,
stop_radius_km,
stop_minutes_for_a_stop,
stop_no_data_for_minutes,
stop_min_speed_kmh,
}
}
}
fn segment_user_slice(
lats: &[f64],
lngs: &[f64],
times: &[f64],
bucket_ids: Option<&[i64]>,
config: &SegmentConfig,
) -> Vec<u32> {
match config.method {
SegmentMethod::AngleChange => angle_change::angle_change_segment_ids(
lats,
lngs,
times,
config.min_angle_deg,
config.angle_min_speed_kmh,
),
SegmentMethod::ObservationGap => {
observation_gap::observation_gap_segment_ids(times, config.gap_s)
}
SegmentMethod::Speed => speed::speed_segment_ids(
lats,
lngs,
times,
config.speed_min_kmh,
config.speed_max_kmh,
config.duration_s,
),
SegmentMethod::Stop => stop::stop_segment_ids(
lats,
lngs,
times,
config.stop_radius_km,
config.stop_minutes_for_a_stop,
config.stop_no_data_for_minutes,
config.stop_min_speed_kmh,
),
SegmentMethod::ValueChange => match bucket_ids {
Some(ids) => value_change::value_change_segment_ids(ids),
None => vec![0u32; lats.len()],
},
}
}
fn is_valid_segment_row(
lats: &[f64],
lngs: &[f64],
times: &[f64],
valid_rows: Option<&[bool]>,
idx: usize,
) -> bool {
valid_rows.is_none_or(|valid| valid[idx])
&& lats[idx].is_finite()
&& lngs[idx].is_finite()
&& times[idx].is_finite()
}
pub fn segment_trajectory_impl(
latitudes: &[f64],
longitudes: &[f64],
timestamps_s: &[f64],
ranges: &[(usize, usize)],
bucket_ids: Option<&[i64]>,
config: &SegmentConfig,
) -> Vec<u32> {
let n = latitudes.len();
let mut out = vec![0u32; n];
let out_addr = out.as_mut_ptr() as usize;
ranges.par_iter().for_each(|&(start, end)| {
let user_len = end - start;
let user_out =
unsafe { std::slice::from_raw_parts_mut((out_addr as *mut u32).add(start), user_len) };
let user_bucket_ids = bucket_ids.map(|ids| &ids[start..end]);
user_out.copy_from_slice(&segment_user_slice(
&latitudes[start..end],
&longitudes[start..end],
×tamps_s[start..end],
user_bucket_ids,
config,
));
});
out
}
#[allow(clippy::too_many_arguments)]
pub fn segment_trajectory_indexed_impl(
latitudes: &[f64],
longitudes: &[f64],
timestamps_s: &[f64],
sorted_indices: &[usize],
ends: &[usize],
valid_rows: Option<&[bool]>,
bucket_ids: Option<&[i64]>,
config: &SegmentConfig,
) -> Vec<u32> {
let n = latitudes.len();
debug_assert_eq!(longitudes.len(), n);
debug_assert_eq!(timestamps_s.len(), n);
debug_assert!(valid_rows.is_none_or(|valid| valid.len() == n));
debug_assert!(bucket_ids.is_none_or(|ids| ids.len() == n));
let mut global_out = vec![0u32; n];
let out_addr = global_out.as_mut_ptr() as usize;
(0..ends.len()).into_par_iter().for_each_init(
|| {
(
Vec::<bool>::new(),
Vec::<f64>::new(),
Vec::<f64>::new(),
Vec::<f64>::new(),
Vec::<i64>::new(),
)
},
|(valid_flags_buf, lat_buf, lng_buf, time_buf, bucket_buf), i| {
let start = if i == 0 { 0 } else { ends[i - 1] };
let end = ends[i];
if start >= end {
return;
}
let user_indices = &sorted_indices[start..end];
valid_flags_buf.clear();
lat_buf.clear();
lng_buf.clear();
time_buf.clear();
bucket_buf.clear();
let out_ptr = out_addr as *mut u32;
for &idx_u32 in user_indices {
let idx = idx_u32;
let is_valid =
is_valid_segment_row(latitudes, longitudes, timestamps_s, valid_rows, idx);
valid_flags_buf.push(is_valid);
if is_valid {
lat_buf.push(latitudes[idx]);
lng_buf.push(longitudes[idx]);
time_buf.push(timestamps_s[idx]);
if let Some(ids) = bucket_ids {
bucket_buf.push(ids[idx]);
}
}
}
let bucket_slice = bucket_ids.map(|_| bucket_buf.as_slice());
let valid_ids = segment_user_slice(lat_buf, lng_buf, time_buf, bucket_slice, config);
let mut valid_pos = 0usize;
let mut last_id = 0u32;
for (&idx_u32, &is_valid) in user_indices.iter().zip(valid_flags_buf.iter()) {
let idx = idx_u32;
if is_valid {
last_id = valid_ids[valid_pos];
valid_pos += 1;
}
unsafe {
*out_ptr.add(idx) = last_id;
}
}
},
);
global_out
}