Scope station bearing sectors to time window with sliding windows

Station directional coverage (bearing sectors) was accumulating forever
regardless of the selected time window. Now uses StationSlidingWindow
— the same circular buffer approach as H3 cells.

Each time slice stores per-station sector data (max distance, message
count, signal levels). When queried, slices are aggregated to produce
window-scoped coverage. Switching from 1h to 5m now shows only the
bearing sectors from the last 5 minutes.

Also: clicking a polygon or station now enlarges the associated station
marker (radius 20, bright emerald, thicker stroke). Both direct station
click and polygon click highlight the related station.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: kevinelliott

map/src/components/map/CoverageMap.tsx

@@ -171,6 +171,8 @@ export default function CoverageMap() {
   // ── Deck.gl layers ──
 
   const selectedPolygonStationId = selectedPolygon?.stationId ?? null;
+  // Highlight the station marker for either direct station click or polygon click
+  const highlightedStationId = selectedStationId ?? selectedPolygonStationId;
 
   const layers = useMemo(() => {
     const result = [];
@@ -179,9 +181,9 @@ export default function CoverageMap() {
     } else {
       result.push(createPolygonLayer(polygonData, selectedPolygonStationId));
     }
-    result.push(createStationMarkersLayer(stations, selectedStationId));
+    result.push(createStationMarkersLayer(stations, highlightedStationId));
     return result;
-  }, [mode, hexData, polygonData, stations, selectedStationId, selectedPolygonStationId]);
+  }, [mode, hexData, polygonData, stations, highlightedStationId, selectedPolygonStationId]);
 
   const getTooltip = useCallback(({ object }: any) => {
     if (!object) return null;

map/src/components/map/layers/station-markers-layer.ts

@@ -1,24 +1,25 @@
 import { ScatterplotLayer } from '@deck.gl/layers';
 import type { Station } from '@/lib/types/coverage';
 
-/** Source type to RGBA color for station dots */
 const SOURCE_COLORS: Record<string, [number, number, number]> = {
-  acars:     [52, 211, 153],    // emerald
-  vdl:       [96, 165, 250],    // blue
-  hfdl:      [129, 140, 248],   // indigo
-  satcom:    [167, 139, 250],   // purple
-  aiscatcher:[251, 146, 60],    // orange
-  ais:       [251, 146, 60],    // orange
+  acars:     [52, 211, 153],
+  vdl:       [96, 165, 250],
+  hfdl:      [129, 140, 248],
+  satcom:    [167, 139, 250],
+  aiscatcher:[251, 146, 60],
+  ais:       [251, 146, 60],
 };
 
 const DEFAULT_COLOR: [number, number, number] = [200, 200, 200];
 const SELECTED_COLOR: [number, number, number, number] = [99, 251, 215, 255];
 
+/**
+ * @param highlightedId - station to highlight (from direct click OR polygon selection)
+ */
 export function createStationMarkersLayer(
   data: Station[],
-  selectedId: number | null,
+  highlightedId: number | null,
 ) {
-  // Filter out stations without coordinates
   const visibleData = data.filter(
     (d) => d.latitude !== 0 || d.longitude !== 0
   );
@@ -29,25 +30,30 @@ export function createStationMarkersLayer(
     pickable: true,
     getPosition: (d) => [d.longitude, d.latitude],
     getFillColor: (d) => {
-      if (d.id === selectedId) return SELECTED_COLOR;
+      if (d.id === highlightedId) return SELECTED_COLOR;
       const rgb = SOURCE_COLORS[d.sourceType] ?? DEFAULT_COLOR;
       return [rgb[0], rgb[1], rgb[2], 200];
     },
-    getRadius: (d) => Math.max(4, Math.log2((d.messageCount || 1) + 1) * 1.8),
+    getRadius: (d) => {
+      if (d.id === highlightedId) return 20;
+      return Math.max(4, Math.log2((d.messageCount || 1) + 1) * 1.8);
+    },
     radiusMinPixels: 3,
-    radiusMaxPixels: 12,
+    radiusMaxPixels: 20,
     stroked: true,
     getLineColor: (d) =>
-      d.id === selectedId
-        ? [99, 251, 215, 100]
+      d.id === highlightedId
+        ? [99, 251, 215, 150]
         : [0, 0, 0, 100],
+    getLineWidth: (d) =>
+      d.id === highlightedId ? 3 : 1,
     lineWidthMinPixels: 1,
-    transitions: {
-      getRadius: { duration: 300 },
-      getFillColor: { duration: 200 },
-    },
+    lineWidthMaxPixels: 4,
     updateTriggers: {
-      getFillColor: [selectedId, data],
+      getFillColor: [highlightedId],
+      getRadius: [highlightedId],
+      getLineColor: [highlightedId],
+      getLineWidth: [highlightedId],
     },
   });
 }

service/src/aggregation/coverage-store.ts

@@ -1,4 +1,5 @@
 import { SlidingWindow, createEmptyCell, mergeIntoCell } from './sliding-window.js';
+import { StationSlidingWindow } from './station-window.js';
 import { indexPoint, shouldMaintainResolution } from '../compute/h3-indexer.js';
 import { haversineDistance, bearing, bearingToSector } from '../compute/distance.js';
 import { computeConfidence } from '../compute/signal-analysis.js';
@@ -18,8 +19,8 @@ import type { CoverageEvent, StationMeta, TransportType } from '../types/events.
 export class CoverageStore {
   /** windows[resolutionIdx][windowIdx] = SlidingWindow */
   private windows: SlidingWindow[][] = [];
-  /** Per-station directional coverage: stationId -> windowName -> StationCoverage */
-  private stationCoverage = new Map<number, Map<string, StationCoverage>>();
+  /** Per-station directional coverage with sliding windows: one per window config */
+  private stationWindows: StationSlidingWindow[] = [];
   /** Synced station metadata from main API */
   public stationMap = new Map<number, StationMeta>();
   /** Rate limiter */
@@ -45,6 +46,11 @@ export class CoverageStore {
       }
       this.windows.push(resWindows);
     }
+
+    // Initialize station sliding windows (one per time window config)
+    for (const wc of WINDOW_CONFIGS) {
+      this.stationWindows.push(new StationSlidingWindow(wc));
+    }
   }
 
   /**
@@ -175,66 +181,24 @@ export class CoverageStore {
 
   private updateStationCoverage(
     event: CoverageEvent,
-    stationLat: number,
-    stationLon: number,
+    _stationLat: number,
+    _stationLon: number,
     distance: number,
     brng: number,
     hasValidTarget: boolean,
   ): void {
-    let stationWindows = this.stationCoverage.get(event.stationId);
-    if (!stationWindows) {
-      stationWindows = new Map();
-      this.stationCoverage.set(event.stationId, stationWindows);
-    }
-
-    for (const wc of WINDOW_CONFIGS) {
-      let cov = stationWindows.get(wc.name);
-      if (!cov) {
-        cov = {
-          stationId: event.stationId,
-          bearingSectors: new Float64Array(36),
-          sectorMessageCounts: new Uint32Array(36),
-          sectorAvgLevels: new Float64Array(36),
-          totalMessages: 0,
-          messagesWithPosition: 0,
-          maxDistance: 0,
-          avgLevel: 0,
-          errorRate: 0,
-          confidence: 0,
-          lastUpdated: Date.now(),
-        };
-        stationWindows.set(wc.name, cov);
-      }
-
-      cov.totalMessages++;
-      cov.lastUpdated = Date.now();
-
-      if (hasValidTarget) {
-        cov.messagesWithPosition++;
-        if (distance > cov.maxDistance) cov.maxDistance = distance;
-
-        const sector = bearingToSector(brng);
-        if (distance > cov.bearingSectors[sector]) {
-          cov.bearingSectors[sector] = distance;
-        }
-        cov.sectorMessageCounts[sector]++;
-
-        if (event.signalLevel !== null) {
-          // Running average
-          const prevAvg = cov.sectorAvgLevels[sector];
-          const count = cov.sectorMessageCounts[sector];
-          cov.sectorAvgLevels[sector] = prevAvg + (event.signalLevel - prevAvg) / count;
-        }
-      }
-
-      if (event.signalLevel !== null) {
-        const prevAvg = cov.avgLevel;
-        cov.avgLevel = prevAvg + (event.signalLevel - prevAvg) / cov.totalMessages;
-      }
-
-      if (event.errorCount !== null && event.errorCount > 0) {
-        cov.errorRate = (cov.errorRate * (cov.totalMessages - 1) + 1) / cov.totalMessages;
-      }
+    const sector = hasValidTarget ? bearingToSector(brng) : -1;
+    const hasError = event.errorCount !== null && event.errorCount > 0;
+
+    for (const sw of this.stationWindows) {
+      sw.record(
+        event.stationId,
+        sector,
+        distance,
+        event.signalLevel,
+        hasValidTarget,
+        hasError,
+      );
     }
   }
 
@@ -288,19 +252,22 @@ export class CoverageStore {
     return results;
   }
 
-  /** Get station coverage data for a specific station and window */
+  /** Get station coverage data for a specific station and window (sliding window scoped) */
   getStationCoverage(stationId: number, windowName: string): StationCoverage | null {
-    return this.stationCoverage.get(stationId)?.get(windowName) ?? null;
+    const wi = WINDOW_CONFIGS.findIndex(c => c.name === windowName);
+    if (wi === -1) return null;
+    return this.stationWindows[wi].getStationCoverage(stationId);
   }
 
   /** Get all stations with coverage data for a given window */
   getAllStationCoverage(windowName: string): StationCoverage[] {
+    const wi = WINDOW_CONFIGS.findIndex(c => c.name === windowName);
+    if (wi === -1) return [];
+    const sw = this.stationWindows[wi];
     const results: StationCoverage[] = [];
-    for (const [, windows] of this.stationCoverage) {
-      const cov = windows.get(windowName);
-      if (cov && cov.totalMessages > 0) {
-        results.push(cov);
-      }
+    for (const id of sw.activeStationIds()) {
+      const cov = sw.getStationCoverage(id);
+      if (cov && cov.totalMessages > 0) results.push(cov);
     }
     return results;
   }
@@ -360,7 +327,7 @@ export class CoverageStore {
       eventsRejected: this.eventsRejected,
       eventsWithPosition: this.eventsWithPosition,
       eventsWithoutPosition: this.eventsWithoutPosition,
-      stationsTracked: this.stationCoverage.size,
+      stationsTracked: this.stationWindows.length > 0 ? this.stationWindows[2].activeStationIds().size : 0,
       activeCells,
     };
   }
@@ -371,6 +338,7 @@ export class CoverageStore {
         window.destroy();
       }
     }
+    for (const sw of this.stationWindows) sw.destroy();
     this.rateLimiter.destroy();
   }
 }