use std::collections::{HashMap, HashSet};
use super::signals::Signals;
use super::{properties, BakedRoad, Orientation, Warning};
use crate::along::sorted;
use crate::road::{along, RoadSection};
use crate::{Along, Direction, Lane, LaneId, Semantic, SignalBoard, SpeedLimit};
#[derive(Clone, Copy, PartialEq)]
enum Rule {
Set(SpeedLimit),
End,
}
struct Sign {
road: usize,
s: f64,
lanes: Vec<LaneId>,
rule: Rule,
orientation: Orientation,
}
type Place<'a> = (usize, &'a RoadSection);
pub(super) fn signs_over(
speed_limits: Vec<Along<SpeedLimit>>,
roads: &[(roxmltree::Node, BakedRoad)],
lanes: &[Lane],
signals: &Signals,
) -> (Vec<Along<SpeedLimit>>, Vec<Warning>) {
let road_index: HashMap<&str, usize> = roads
.iter()
.enumerate()
.map(|(k, (_, r))| (r.road.od_id.as_str(), k))
.collect();
let mut place: HashMap<LaneId, Place> = HashMap::new();
for (k, (_, road)) in roads.iter().enumerate() {
for section in &road.road.sections {
for &(_, id) in §ion.lanes {
place.insert(id, (k, section));
}
}
}
let signs = speed_signs(signals, &road_index, &place);
if signs.is_empty() {
return (speed_limits, Vec::new());
}
let mut set = Vec::new();
let mut warnings = Vec::new();
for (k, sign) in signs.iter().enumerate() {
let road = &roads[sign.road].1.road;
for &lane in &sign.lanes {
let reach = reach(k, lane, &signs, lanes, &place);
let Rule::Set(limit) = sign.rule else {
continue;
};
let stretches: Vec<Along<SpeedLimit>> = reach
.into_iter()
.map(|(lane, from, to)| Along {
lane,
from,
to,
value: limit,
})
.collect();
let against = stretches.iter().find_map(|s| contradicts(s, &speed_limits));
if let Some(record) = against {
let od_lane = place[&lane].1.lanes.iter().find(|(_, id)| *id == lane);
warnings.push(Warning::SpeedLimitDisagrees {
road_id: road.od_id.clone(),
s: sign.s,
lane: od_lane.map_or(0, |l| l.0),
sign: limit,
record,
});
}
set.extend(stretches);
}
}
(overlay(speed_limits, set), warnings)
}
fn speed_signs(
signals: &Signals,
road_index: &HashMap<&str, usize>,
place: &HashMap<LaneId, Place>,
) -> Vec<Sign> {
let mut out = Vec::new();
for (signal, prov) in signals.baked.iter().zip(&signals.provenance) {
let mut rules = vec![(rule(&signal.semantics), &signal.lanes)];
for board in &signal.boards {
if let SignalBoard::Static(signs) = board {
rules.extend(signs.iter().map(|s| (rule(&s.semantics), &s.lanes)));
}
}
let at = std::iter::once((prov.road_id.as_str(), prov.s, prov.orientation))
.chain((prov.references.iter()).map(|r| (r.road_id.as_str(), r.s, r.orientation)));
for (road_id, s, orientation) in at {
let Some(&road) = road_index.get(road_id) else {
continue;
};
for (rule, lanes) in &rules {
let Some(rule) = *rule else {
continue;
};
let here: Vec<LaneId> = (lanes.iter())
.copied()
.filter(|l| {
place.get(l).is_some_and(|(r, section)| {
*r == road && section.start <= s + 1e-9 && s <= section.end + 1e-9
})
})
.collect();
if !here.is_empty() {
out.push(Sign {
road,
s,
lanes: here,
rule,
orientation,
});
}
}
}
}
out
}
fn rule(semantics: &[Semantic]) -> Option<Rule> {
semantics.iter().find_map(|s| match s {
Semantic::Speed { kind, .. } if kind == "maximumEnd" || kind == "zoneEnd" => {
Some(Rule::End)
}
Semantic::Speed { kind, value, unit } if kind == "maximum" || kind == "zone" => {
let as_maximum = Semantic::Speed {
kind: "maximum".into(),
value: *value,
unit: *unit,
};
properties::speed_limit(&[as_maximum]).map(Rule::Set)
}
_ => None,
})
}
fn reach(
k: usize,
lane: LaneId,
signs: &[Sign],
lanes: &[Lane],
place: &HashMap<LaneId, Place>,
) -> Vec<(LaneId, f32, f32)> {
let sign = &signs[k];
let forward = |lane: &Lane| match lane.direction {
Direction::Forward => true,
Direction::Backward => false,
Direction::Both => sign.orientation != Orientation::Negative,
};
let at = |lane: LaneId, s: f64| {
let (_, section) = place[&lane];
along(lanes[lane.0].center.points(), §ion.stations, s)
};
let mut out = Vec::new();
let mut seen = HashSet::new();
let mut todo = vec![(lane, Some(at(lane, sign.s)))];
while let Some((id, start)) = todo.pop() {
if !seen.insert(id) {
continue;
}
let current = &lanes[id.0];
let ahead = forward(current);
let length = current.center.length();
let from = start.unwrap_or(if ahead { 0.0 } else { length });
let next = (signs.iter().enumerate())
.filter(|&(j, other)| j != k && other.road == sign.road && other.lanes.contains(&id))
.map(|(_, other)| at(id, other.s))
.filter(|&p| match ahead {
true => p > from + 1e-4,
false => p < from - 1e-4,
})
.min_by(|a, b| match ahead {
true => a.total_cmp(b),
false => b.total_cmp(a),
});
let end = next.unwrap_or(if ahead { length } else { 0.0 });
let (low, high) = (from.min(end), from.max(end));
if high - low > 1e-4 {
out.push((id, low, high));
}
if next.is_none() {
let on_road = |n: &&LaneId| place.get(n).is_some_and(|(r, _)| *r == sign.road);
todo.extend(
current
.successors
.iter()
.filter(on_road)
.map(|&n| (n, None)),
);
}
}
out
}
fn contradicts(stretch: &Along<SpeedLimit>, records: &[Along<SpeedLimit>]) -> Option<SpeedLimit> {
records
.iter()
.find(|r| {
r.lane == stretch.lane
&& r.from < stretch.to
&& stretch.from < r.to
&& r.value != stretch.value
})
.map(|r| r.value)
}
fn overlay(records: Vec<Along<SpeedLimit>>, set: Vec<Along<SpeedLimit>>) -> Vec<Along<SpeedLimit>> {
let mut by_lane: HashMap<LaneId, Vec<Along<SpeedLimit>>> = HashMap::new();
for stretch in set {
let laid = by_lane.entry(stretch.lane).or_default();
*laid = cut(std::mem::take(laid), stretch.from, stretch.to);
laid.push(stretch);
}
let mut out = Vec::new();
for record in records {
match by_lane.get(&record.lane) {
Some(laid) => {
let mut pieces = vec![record];
for s in laid {
pieces = cut(pieces, s.from, s.to);
}
out.extend(pieces);
}
None => out.push(record),
}
}
out.extend(by_lane.into_values().flatten());
sorted(out)
}
fn cut<T: Clone>(stretches: Vec<Along<T>>, from: f32, to: f32) -> Vec<Along<T>> {
let mut out = Vec::new();
for s in stretches {
if s.to <= from || to <= s.from {
out.push(s);
continue;
}
if s.from < from {
out.push(Along {
to: from,
..s.clone()
});
}
if to < s.to {
out.push(Along { from: to, ..s });
}
}
out
}