P017 — Threshold-Based Driving Event Detection

import sys
from pathlib import Path
import yaml
import duckdb
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

NB_DIR = Path.cwd()
TELEFORGE_ROOT = NB_DIR.parent.parent.parent.parent
NOSTOS_ROOT = TELEFORGE_ROOT.parent / "nostos"
sys.path.insert(0, str(NOSTOS_ROOT / "src"))

from nostos.context import TelematicsContext
from nostos.stages.d0_trip_detector import TripDetectorStage
from nostos.stages.d1_gps_cleaner import GPSCleanerStage
from nostos.stages.d1_imu_calibrator import IMUCalibratorStage
from nostos.stages.d2_event_detector import EventDetectorStage
print("Stages loaded")

def run_events(df, country='FR'):
    ctx = TelematicsContext(cfg={}, df=df.copy(),
                            meta={'device_id': '?', 'country': country, 'hz': 10})
    for stage in (TripDetectorStage(), GPSCleanerStage(), IMUCalibratorStage(), EventDetectorStage()):
        stage.run(ctx)
    events = ctx.artifacts.get('events', [])
    if not isinstance(events, list):
        events = []
    return events, ctx.df

print("Helper ready")

clermont_dir = TELEFORGE_ROOT / "datasets" / "fr_clermont_proto_2025-09"
with open(clermont_dir / "manifest.yaml") as f:
    mf_clermont = yaml.safe_load(f)
parquet = (clermont_dir / mf_clermont['data_files'][0]['path']).resolve()
df_clermont = pd.read_parquet(parquet)
print(f"Clermont : {len(df_clermont):,} samples, distance {mf_clermont['volume']['distance_km']} km")

events_clermont, _ = run_events(df_clermont, country='FR')
print(f"\nEvents détectés : {len(events_clermont)}")

# Count par type
clermont_types = {}
for e in events_clermont:
    t = e.get('type', 'unknown') if isinstance(e, dict) else str(e)
    clermont_types[t] = clermont_types.get(t, 0) + 1
print("\nPar type:")
for t, c in sorted(clermont_types.items(), key=lambda x: -x[1]):
    print(f"  {t:<20} {c}")

conn = duckdb.connect(str(NOSTOS_ROOT / "data" / "flespi" / "storage" / "telemetry.duckdb"), read_only=True)
us_meta = conn.execute("""
    SELECT trip_id, device_id, distance_km, parquet_path
    FROM trips
    WHERE carrier_state = 'mounted_driving'
      AND distance_km > 1.0
      AND ts_start >= '2026-04-10 11:06:00'
    ORDER BY distance_km DESC
""").fetchdf()
conn.close()

us_dfs = []
us_total_dist = 0
for _, row in us_meta.iterrows():
    pq = Path(row['parquet_path'])
    if not pq.exists():
        alt = NOSTOS_ROOT / "data" / "flespi" / "trips" / str(row['device_id']) / f"{row['trip_id']}.parquet"
        if alt.exists(): pq = alt
    if pq.exists():
        us_dfs.append(pd.read_parquet(pq))
        us_total_dist += row['distance_km']

if us_dfs:
    df_us = pd.concat(us_dfs, ignore_index=True)
    print(f"us_greensboro : {len(df_us):,} samples, distance ~{us_total_dist:.2f} km")
    events_us, _ = run_events(df_us, country='US')
    us_types = {}
    for e in events_us:
        t = e.get('type', 'unknown') if isinstance(e, dict) else str(e)
        us_types[t] = us_types.get(t, 0) + 1
    print(f"\n{len(events_us)} events détectés, par type :")
    for t, c in sorted(us_types.items(), key=lambda x: -x[1]):
        print(f"  {t:<20} {c}")
else:
    events_us = []
    us_types = {}
    us_total_dist = 0

all_types = sorted(set(clermont_types.keys()) | set(us_types.keys()))
clermont_dist = mf_clermont['volume']['distance_km']

comparison = pd.DataFrame([
    {
        'type': t,
        'clermont_count': clermont_types.get(t, 0),
        'us_count': us_types.get(t, 0),
        'clermont_per_100km': (clermont_types.get(t, 0) / clermont_dist) * 100,
        'us_per_100km': (us_types.get(t, 0) / us_total_dist) * 100 if us_total_dist > 0 else 0,
    }
    for t in all_types
])
comparison

fig, axes = plt.subplots(1, 2, figsize=(13, 5))

# Left: events count par type × dataset
ax = axes[0]
x = np.arange(len(all_types))
width = 0.35
if all_types:
    ax.bar(x - width/2, comparison['clermont_count'], width,
           label=f'Clermont ({clermont_dist} km)', color='#0066CC', alpha=0.85)
    ax.bar(x + width/2, comparison['us_count'], width,
           label=f'us_greensboro (~{us_total_dist:.1f} km)', color='#E87700', alpha=0.85)
    ax.set_xticks(x)
    ax.set_xticklabels(all_types, rotation=30, ha='right')
    ax.legend()
ax.set_ylabel('Event count')
ax.set_title('Events détectés par type')
ax.grid(True, alpha=0.3, axis='y')

# Right: events per 100 km (normalized)
ax = axes[1]
if all_types:
    ax.bar(x - width/2, comparison['clermont_per_100km'], width,
           label='Clermont', color='#0066CC', alpha=0.85)
    ax.bar(x + width/2, comparison['us_per_100km'], width,
           label='us_greensboro', color='#E87700', alpha=0.85)
    ax.set_xticks(x)
    ax.set_xticklabels(all_types, rotation=30, ha='right')
    ax.legend()
ax.set_ylabel('Events / 100 km')
ax.set_title('Taux d\'événements normalisé (/100 km)')
ax.grid(True, alpha=0.3, axis='y')

plt.tight_layout()
plt.savefig('p017_cross_dataset_events.png', dpi=120, bbox_inches='tight')
plt.show()