Skip to main content

sightloom_analysis/
scoped_baseline.rs

1//! Subject- and camera-scoped statistical baselines.
2//!
3//! Global baseline remains the fallback when a scope has too few samples.
4
5#![allow(
6    clippy::cast_possible_truncation,
7    clippy::cast_precision_loss,
8    clippy::cast_sign_loss
9)]
10
11extern crate alloc;
12
13use crate::input::AnalysisSeries;
14use crate::stat_anomaly::{BaselineStats, StatAnomalyConfig, build_baseline, detect_statistical};
15use alloc::collections::BTreeMap;
16use alloc::vec::Vec;
17use sightloom_core::{SourceId, SubjectId};
18
19/// Which scope a baseline row belongs to.
20#[derive(Clone, Copy, Debug, Eq, PartialEq)]
21pub enum BaselineScope {
22    /// Pooled over all samples.
23    Global,
24    /// One subject.
25    Subject(SubjectId),
26    /// One source / camera.
27    Source(SourceId),
28}
29
30/// Store of global + per-subject + per-source baselines.
31#[derive(Clone, Debug, Default, PartialEq)]
32pub struct ScopedBaselineStore {
33    /// Global fallback.
34    pub global: BaselineStats,
35    /// Subject id → baseline.
36    pub by_subject: BTreeMap<u64, BaselineStats>,
37    /// Source id → baseline.
38    pub by_source: BTreeMap<u32, BaselineStats>,
39}
40
41impl ScopedBaselineStore {
42    /// Builds scoped baselines from a history series.
43    #[must_use]
44    pub fn from_series(series: &AnalysisSeries, config: StatAnomalyConfig) -> Self {
45        let global = build_baseline(series, config);
46        let mut by_subject: BTreeMap<u64, BaselineStats> = BTreeMap::new();
47        let mut by_source: BTreeMap<u32, BaselineStats> = BTreeMap::new();
48
49        // Collect subject ids and source ids present.
50        let mut subjects: Vec<SubjectId> = Vec::new();
51        let mut sources: Vec<SourceId> = Vec::new();
52        for e in &series.timed {
53            if let Some(s) = e.subject_id
54                && !subjects.contains(&s)
55            {
56                subjects.push(s);
57            }
58            if let Some(src) = e.source_id
59                && !sources.contains(&src)
60            {
61                sources.push(src);
62            }
63        }
64        for d in &series.durations {
65            if let Some(s) = d.subject_id
66                && !subjects.contains(&s)
67            {
68                subjects.push(s);
69            }
70            if let Some(src) = d.source_id
71                && !sources.contains(&src)
72            {
73                sources.push(src);
74            }
75        }
76
77        for s in subjects {
78            let sub = filter_series_subject(series, s);
79            let b = build_baseline(&sub, config);
80            if b.dwell_n >= config.min_samples
81                || b.gap_n >= config.min_samples
82                || b.timed_n >= config.min_samples
83            {
84                by_subject.insert(s.0, b);
85            }
86        }
87        for src in sources {
88            let sub = filter_series_source(series, src);
89            let b = build_baseline(&sub, config);
90            if b.dwell_n >= config.min_samples
91                || b.gap_n >= config.min_samples
92                || b.timed_n >= config.min_samples
93            {
94                by_source.insert(src.0, b);
95            }
96        }
97
98        Self {
99            global,
100            by_subject,
101            by_source,
102        }
103    }
104
105    /// Resolves the best baseline for a sample (subject > source > global).
106    #[must_use]
107    pub fn resolve(
108        &self,
109        subject_id: Option<SubjectId>,
110        source_id: Option<SourceId>,
111    ) -> &BaselineStats {
112        if let Some(s) = subject_id
113            && let Some(b) = self.by_subject.get(&s.0)
114        {
115            return b;
116        }
117        if let Some(src) = source_id
118            && let Some(b) = self.by_source.get(&src.0)
119        {
120            return b;
121        }
122        &self.global
123    }
124
125    /// Number of subject-scoped baselines.
126    #[must_use]
127    pub fn subject_count(&self) -> usize {
128        self.by_subject.len()
129    }
130
131    /// Number of source-scoped baselines.
132    #[must_use]
133    pub fn source_count(&self) -> usize {
134        self.by_source.len()
135    }
136}
137
138/// Detects anomalies using the most specific baseline available per sample.
139///
140/// Implementation: run global detect, then re-run detect on each subject- and
141/// source-filtered live slice and merge (dedupe by reason+time+subject is host-side).
142#[must_use]
143pub fn detect_statistical_scoped(
144    live: &AnalysisSeries,
145    store: &ScopedBaselineStore,
146    config: StatAnomalyConfig,
147    next_id: &mut u64,
148) -> Vec<crate::anomaly::AnomalyEvent> {
149    let mut out = detect_statistical(live, &store.global, config, next_id);
150
151    // Subject slices
152    let mut subjects: Vec<SubjectId> = Vec::new();
153    for e in &live.timed {
154        if let Some(s) = e.subject_id
155            && !subjects.contains(&s)
156        {
157            subjects.push(s);
158        }
159    }
160    for d in &live.durations {
161        if let Some(s) = d.subject_id
162            && !subjects.contains(&s)
163        {
164            subjects.push(s);
165        }
166    }
167    for s in subjects {
168        if let Some(b) = store.by_subject.get(&s.0) {
169            let slice = filter_series_subject(live, s);
170            out.extend(detect_statistical(&slice, b, config, next_id));
171        }
172    }
173
174    // Source slices
175    let mut sources: Vec<SourceId> = Vec::new();
176    for e in &live.timed {
177        if let Some(src) = e.source_id
178            && !sources.contains(&src)
179        {
180            sources.push(src);
181        }
182    }
183    for d in &live.durations {
184        if let Some(src) = d.source_id
185            && !sources.contains(&src)
186        {
187            sources.push(src);
188        }
189    }
190    for src in sources {
191        if let Some(b) = store.by_source.get(&src.0) {
192            let slice = filter_series_source(live, src);
193            out.extend(detect_statistical(&slice, b, config, next_id));
194        }
195    }
196    out
197}
198
199fn filter_series_subject(series: &AnalysisSeries, subject: SubjectId) -> AnalysisSeries {
200    AnalysisSeries {
201        timed: series
202            .timed
203            .iter()
204            .copied()
205            .filter(|e| e.subject_id == Some(subject))
206            .collect(),
207        durations: series
208            .durations
209            .iter()
210            .copied()
211            .filter(|d| d.subject_id == Some(subject))
212            .collect(),
213        routes: series
214            .routes
215            .iter()
216            .filter(|r| r.subject_id == subject)
217            .cloned()
218            .collect(),
219        pairs: series
220            .pairs
221            .iter()
222            .copied()
223            .filter(|p| p.subject_a == subject || p.subject_b == subject)
224            .collect(),
225    }
226}
227
228fn filter_series_source(series: &AnalysisSeries, source: SourceId) -> AnalysisSeries {
229    AnalysisSeries {
230        timed: series
231            .timed
232            .iter()
233            .copied()
234            .filter(|e| e.source_id == Some(source))
235            .collect(),
236        durations: series
237            .durations
238            .iter()
239            .copied()
240            .filter(|d| d.source_id == Some(source))
241            .collect(),
242        routes: series.routes.clone(),
243        pairs: series
244            .pairs
245            .iter()
246            .copied()
247            .filter(|p| p.source_id == Some(source))
248            .collect(),
249    }
250}
251
252#[cfg(test)]
253mod tests {
254    use super::*;
255    use crate::input::{DurationSample, TimedSubjectEvent};
256
257    #[test]
258    fn builds_subject_and_source_scopes() {
259        let mut series = AnalysisSeries::default();
260        for i in 0..10 {
261            series.timed.push(TimedSubjectEvent {
262                subject_id: Some(SubjectId(1)),
263                source_id: Some(SourceId(7)),
264                at_ns: i * 3_600_000_000_000,
265                event_id: None,
266                kind_tag: 0,
267            });
268            series.durations.push(DurationSample {
269                subject_id: Some(SubjectId(1)),
270                source_id: Some(SourceId(7)),
271                zone_id: None,
272                duration_ns: 1_000_000_000 + i * 1_000,
273                at_ns: i * 3_600_000_000_000,
274                event_id: None,
275            });
276        }
277        for i in 0..10 {
278            series.timed.push(TimedSubjectEvent {
279                subject_id: Some(SubjectId(2)),
280                source_id: Some(SourceId(8)),
281                at_ns: i * 3_600_000_000_000,
282                event_id: None,
283                kind_tag: 0,
284            });
285        }
286        let store = ScopedBaselineStore::from_series(&series, StatAnomalyConfig::default());
287        assert!(store.subject_count() >= 1);
288        assert!(store.source_count() >= 1);
289        let b = store.resolve(Some(SubjectId(1)), Some(SourceId(7)));
290        assert!(b.dwell_n >= 5 || b.timed_n >= 5);
291    }
292}