City-Scale Micro-Mobility & Safety

A.4 City-Scale Micro-Mobility & Safety (Radar / Acoustic / IMU)

As cities densify and micro-mobility (bikes, e-scooters, small EVs) proliferates, safety and flow management become critical. Today, safety analysis often relies on:

• sparse and lagged crash statistics,
• occasional manual counts or video studies,
• anecdotal reports from residents and operators.

However, the most informative signals are often the near misses and repeated risky patterns: sudden braking, evasive maneuvers, conflicts between modes, and unsafe speeds at known bottlenecks. These rarely make it into structured datasets.

Spaxiom can act as a street-level safety cortex, fusing radar, acoustic, and IMU signals from vehicles and infrastructure into INTENT events like NearMissCluster, SpeedingCorridor, and UnsafeCrossing.

Sensors and deployment

At the city scale, relevant sensors include:

• Roadside radar / lidar R_j(t) at fixed locations j, measuring:
  • object positions x_k(t) and velocities v_k(t),
  • object classes (car, truck, bike, scooter, pedestrian) from edge classifiers.
• Acoustic sensors A_j(t):
  • sharp impact-like sounds,
  • braking squeals,
  • honking patterns.
• On-vehicle IMUs and GNSS for fleets of:
  • public buses and service vehicles,
  • shared bikes and scooters,
  • possibly taxis or ridehail fleets.
• Signal phase and timing (SPaT):
  • phase state of traffic lights at intersections,
  • timing and coordination information.

Spaxiom ingests processed features from these sources (not raw full-resolution waveforms or video) and maps them into a common spatial model of the street network (segments, intersections, crosswalks, lanes).

INTENT events and risk metrics

We define several safety-relevant INTENT events:

• NearMiss: a spatiotemporal configuration where two or more agents come within a critical distance at relative speed above a threshold without collision;
• HarshEvent: harsh braking, swerving, or strong lateral acceleration from IMU traces;
• SpeedingCorridor: persistent high share of vehicles exceeding speed limits on a segment;
• UnsafeCrossing: repeated near misses or HarshEvents at or near a crosswalk or intersection.

Near-miss detection. Consider two agents a and b (e.g., a car and a cyclist) with positions x_a(t), x_b(t) and velocities v_a(t), v_b(t). For a short horizon τ ∈ [0, τ_max], approximate future positions with constant velocity:

Define the predicted minimum separation distance over that horizon:

Let Δv(t) = v_a(t) - v_b(t), and define relative speed v_rel(t) = ‖Δv(t)‖.

A near-miss candidate is a triple (a,b,t) such that:

where d^nm_thresh (e.g., 1–2 m) and v^nm_thresh (e.g., 5 m/s) are thresholds.

Each such event can be encapsulated as a NearMiss INTENT event with attributes:

• location (segment/crossing),
• agent types (car, bike, scooter, pedestrian),
• relative speed,
• minimum predicted distance.

Segment-level risk score. For a road segment ℓ over a period [t₀, t₁], define:

• N^nm_ℓ: number of near-miss events,
• N^veh_ℓ: total vehicle passages (volume),
• N^harsh_ℓ: number of HarshEvents from IMUs on that segment.

A simple risk index for segment ℓ is:

with weights α, β > 0. Segments with high R_ℓ are candidates for SpeedingCorridor or UnsafeCrossing labels, depending on their geometry.

Spaxiom-style implementation sketch

We can represent a segment or intersection in the DSL as an object that aggregates INTENT events and IMU-derived HarshEvents.

from spaxiom import Condition
from spaxiom.temporal import within
from spaxiom.logic import on

class RoadSegment:
    def __init__(self, seg_id, near_miss_stream, harsh_stream, volume_stream):
        self.seg_id = seg_id
        self.near_miss_stream = near_miss_stream  # yields NearMiss events
        self.harsh_stream = harsh_stream          # yields HarshEvent events
        self.volume_stream = volume_stream        # yields vehicle passage counts

    def counts(self, window_s: float):
        nm_events = self.near_miss_stream.history(window_s=window_s)
        harsh_events = self.harsh_stream.history(window_s=window_s)
        volume_events = self.volume_stream.history(window_s=window_s)

        N_nm = len(nm_events)
        N_harsh = len(harsh_events)
        N_veh = sum(e["count"] for _, e in volume_events) or 1
        return N_nm, N_harsh, N_veh

    def risk_index(self, window_s: float) -> float:
        N_nm, N_harsh, N_veh = self.counts(window_s)
        alpha, beta = 1.0, 0.5
        return alpha * (N_nm / N_veh) + beta * (N_harsh / N_veh)

# Example network segments
seg_main_1 = RoadSegment(
    seg_id="main_st_block_1",
    near_miss_stream=nm_main_1,
    harsh_stream=harsh_main_1,
    volume_stream=volume_main_1,
)
seg_main_2 = RoadSegment(
    seg_id="main_st_block_2",
    near_miss_stream=nm_main_2,
    harsh_stream=harsh_main_2,
    volume_stream=volume_main_2,
)

segments = [seg_main_1, seg_main_2]

# Condition to periodically assess risk
tick_15m = within(900, Condition(lambda: True))

@on(tick_15m)
def micromobility_safety_agent():
    window_s = 7 * 24 * 3600  # last 7 days
    for seg in segments:
        R = seg.risk_index(window_s)
        if R > 0.01:  # example threshold
            emit_intent_event({
                "type": "UnsafeCrossing" if is_crossing(seg.seg_id) else "SpeedingCorridor",
                "segment": seg.seg_id,
                "risk_index": R,
                "window_s": window_s,
            })
    # The resulting stream of UnsafeCrossing / SpeedingCorridor events can drive:
    # - infrastructure recommendations,
    # - signal timing changes,
    # - or targeted enforcement and education campaigns.

In a fuller implementation, separate Spaxiom patterns would compute NearMiss and HarshEvent INTENT events directly from radar and IMU streams, providing reusable building blocks across cities.