use rayon::prelude::*;
use crate::utils::haversine::haversine_km;
use crate::utils::helpers::median_slice_in_place;
pub type CompressRepresentatives = (Vec<usize>, Vec<f64>, Vec<f64>);
type CompressRepresentativeRow = (usize, f64, f64);
pub fn compress_user_slice(
lats: &[f64],
lngs: &[f64],
spatial_radius_km: f64,
offset: usize,
) -> Vec<(usize, usize)> {
let n = lats.len();
if n == 0 {
return Vec::new();
}
if n == 1 {
return vec![(offset, offset + 1)];
}
let mut groups: Vec<(usize, usize)> = Vec::new();
let mut lat_0 = lats[0];
let mut lon_0 = lngs[0];
let mut group_start = 0usize;
for i in 0..(n - 1) {
let lat = lats[i + 1];
let lon = lngs[i + 1];
let dist = haversine_km(lat_0, lon_0, lat, lon);
if dist > spatial_radius_km {
groups.push((offset + group_start, offset + i + 1));
lat_0 = lat;
lon_0 = lon;
group_start = i + 1;
}
}
groups.push((offset + group_start, offset + n));
groups
}
fn compress_user_representatives(
lats: &[f64],
lngs: &[f64],
spatial_radius_km: f64,
offset: usize,
) -> Vec<CompressRepresentativeRow> {
let groups = compress_user_slice(lats, lngs, spatial_radius_km, offset);
let mut rows = Vec::with_capacity(groups.len());
let mut lat_buf = Vec::new();
let mut lng_buf = Vec::new();
for (group_start, group_end) in groups {
lat_buf.clear();
lng_buf.clear();
lat_buf.extend_from_slice(&lats[group_start - offset..group_end - offset]);
lng_buf.extend_from_slice(&lngs[group_start - offset..group_end - offset]);
rows.push((
group_start,
median_slice_in_place(&mut lat_buf),
median_slice_in_place(&mut lng_buf),
));
}
rows
}
fn is_valid_indexed_compress_row(
lats: &[f64],
lngs: &[f64],
valid_rows: Option<&[bool]>,
idx: usize,
) -> bool {
valid_rows.is_none_or(|valid| valid[idx]) && lats[idx].is_finite() && lngs[idx].is_finite()
}
fn compress_user_representatives_indexed(
lats: &[f64],
lngs: &[f64],
user_indices: &[usize],
valid_rows: Option<&[bool]>,
spatial_radius_km: f64,
) -> Vec<CompressRepresentativeRow> {
let valid_indices: Vec<usize> = user_indices
.iter()
.copied()
.filter(|&idx| is_valid_indexed_compress_row(lats, lngs, valid_rows, idx))
.collect();
let n = valid_indices.len();
if n == 0 {
return Vec::new();
}
if n == 1 {
let orig = valid_indices[0];
return vec![(orig, lats[orig], lngs[orig])];
}
let mut groups: Vec<(usize, usize)> = Vec::new();
let mut lat_0 = lats[valid_indices[0]];
let mut lon_0 = lngs[valid_indices[0]];
let mut group_start = 0usize;
for i in 0..(n - 1) {
let lat = lats[valid_indices[i + 1]];
let lon = lngs[valid_indices[i + 1]];
let dist = haversine_km(lat_0, lon_0, lat, lon);
if dist > spatial_radius_km {
groups.push((group_start, i + 1));
lat_0 = lat;
lon_0 = lon;
group_start = i + 1;
}
}
groups.push((group_start, n));
let mut rows = Vec::with_capacity(groups.len());
let mut lat_buf = Vec::new();
let mut lng_buf = Vec::new();
for (group_start_local, group_end_local) in groups {
lat_buf.clear();
lng_buf.clear();
for &orig in &valid_indices[group_start_local..group_end_local] {
lat_buf.push(lats[orig]);
lng_buf.push(lngs[orig]);
}
rows.push((
valid_indices[group_start_local],
median_slice_in_place(&mut lat_buf),
median_slice_in_place(&mut lng_buf),
));
}
rows
}
pub fn compress_trajectory_representatives_impl(
lats: &[f64],
lngs: &[f64],
ranges: &[(usize, usize)],
spatial_radius_km: f64,
) -> CompressRepresentatives {
let per_user_rows: Vec<Vec<CompressRepresentativeRow>> = ranges
.par_iter()
.map(|&(start, end)| {
compress_user_representatives(
&lats[start..end],
&lngs[start..end],
spatial_radius_km,
start,
)
})
.collect();
let total_groups: usize = per_user_rows.iter().map(|g| g.len()).sum();
let mut representative_indices = Vec::with_capacity(total_groups);
let mut median_latitudes = Vec::with_capacity(total_groups);
let mut median_longitudes = Vec::with_capacity(total_groups);
for user_rows in per_user_rows {
for (representative_idx, median_lat, median_lng) in user_rows {
representative_indices.push(representative_idx);
median_latitudes.push(median_lat);
median_longitudes.push(median_lng);
}
}
(representative_indices, median_latitudes, median_longitudes)
}
pub fn compress_trajectory_representatives_indexed_impl(
lats: &[f64],
lngs: &[f64],
sorted_indices: &[usize],
ends: &[usize],
valid_rows: Option<&[bool]>,
spatial_radius_km: f64,
) -> CompressRepresentatives {
let per_user_rows: Vec<Vec<CompressRepresentativeRow>> = (0..ends.len())
.into_par_iter()
.map(|i| {
let start = if i == 0 { 0 } else { ends[i - 1] };
let end = ends[i];
compress_user_representatives_indexed(
lats,
lngs,
&sorted_indices[start..end],
valid_rows,
spatial_radius_km,
)
})
.collect();
let total_groups: usize = per_user_rows.iter().map(|g| g.len()).sum();
let mut representative_indices = Vec::with_capacity(total_groups);
let mut median_latitudes = Vec::with_capacity(total_groups);
let mut median_longitudes = Vec::with_capacity(total_groups);
for user_rows in per_user_rows {
for (representative_idx, median_lat, median_lng) in user_rows {
representative_indices.push(representative_idx);
median_latitudes.push(median_lat);
median_longitudes.push(median_lng);
}
}
(representative_indices, median_latitudes, median_longitudes)
}