@blueharford/scrypted-spatial-awareness 0.2.1 → 0.4.0

package/src/models/training.ts

@@ -0,0 +1,300 @@
+/**
+ * Training Mode Types
+ *
+ * These types support the guided training system where a user physically
+ * walks around their property to train the system on camera positions,
+ * transit times, overlaps, landmarks, and structures.
+ */
+
+/** Unique identifier for a training session */
+export type TrainingSessionId = string;
+
+/** Current state of the training session */
+export type TrainingSessionState = 'idle' | 'active' | 'paused' | 'completed';
+
+/** Type of training action being performed */
+export type TrainingActionType =
+  | 'camera_visit'      // User arrived at a camera
+  | 'transit_start'     // User started walking to another camera
+  | 'transit_end'       // User arrived at destination camera
+  | 'mark_landmark'     // User marked a landmark location
+  | 'mark_overlap'      // User marked camera overlap zone
+  | 'mark_structure'    // User marked a structure (wall, fence, etc.)
+  | 'confirm_position'  // User confirmed camera position on floor plan
+  | 'adjust_fov';       // User adjusted camera field of view
+
+/** A single camera visit during training */
+export interface TrainingCameraVisit {
+  /** Camera device ID */
+  cameraId: string;
+  /** Camera name for display */
+  cameraName: string;
+  /** When the trainer was first detected on this camera */
+  arrivedAt: number;
+  /** When the trainer left this camera (null if still there) */
+  departedAt: number | null;
+  /** Visual embedding captured for the trainer */
+  trainerEmbedding?: string;
+  /** Confidence of trainer detection (0-1) */
+  detectionConfidence: number;
+  /** Bounding box of trainer in frame [x, y, width, height] */
+  boundingBox?: [number, number, number, number];
+  /** Position on floor plan if confirmed */
+  floorPlanPosition?: { x: number; y: number };
+  /** Entry zone detected (if any) */
+  entryZone?: string;
+  /** Exit zone detected (if any) */
+  exitZone?: string;
+}
+
+/** A recorded transit between two cameras */
+export interface TrainingTransit {
+  /** Unique ID for this transit */
+  id: string;
+  /** Source camera ID */
+  fromCameraId: string;
+  /** Destination camera ID */
+  toCameraId: string;
+  /** Transit start time */
+  startTime: number;
+  /** Transit end time */
+  endTime: number;
+  /** Calculated transit duration in seconds */
+  transitSeconds: number;
+  /** Whether there was direct overlap (both cameras saw trainer simultaneously) */
+  hasOverlap: boolean;
+  /** Duration of overlap in seconds (if any) */
+  overlapDuration?: number;
+  /** Exit zone from source camera */
+  exitZone?: string;
+  /** Entry zone to destination camera */
+  entryZone?: string;
+  /** Path description entered by user (optional) */
+  pathDescription?: string;
+}
+
+/** A landmark marked during training */
+export interface TrainingLandmark {
+  /** Unique ID for this landmark */
+  id: string;
+  /** Name given by user */
+  name: string;
+  /** Type of landmark */
+  type: 'mailbox' | 'garage' | 'shed' | 'tree' | 'gate' | 'door' | 'driveway' | 'pathway' | 'garden' | 'pool' | 'deck' | 'patio' | 'other';
+  /** Position on floor plan */
+  position: { x: number; y: number };
+  /** Which camera(s) can see this landmark */
+  visibleFromCameras: string[];
+  /** When this was marked */
+  markedAt: number;
+  /** Optional description */
+  description?: string;
+}
+
+/** A camera overlap zone marked during training */
+export interface TrainingOverlap {
+  /** Unique ID for this overlap */
+  id: string;
+  /** First camera in overlap */
+  camera1Id: string;
+  /** Second camera in overlap */
+  camera2Id: string;
+  /** Position on floor plan where overlap was confirmed */
+  position: { x: number; y: number };
+  /** Approximate radius of overlap zone */
+  radius: number;
+  /** When this was marked */
+  markedAt: number;
+}
+
+/** A structure marked during training (walls, fences, etc.) */
+export interface TrainingStructure {
+  /** Unique ID for this structure */
+  id: string;
+  /** Type of structure */
+  type: 'wall' | 'fence' | 'hedge' | 'building' | 'path' | 'road' | 'other';
+  /** Name/description */
+  name: string;
+  /** Points defining the structure (line or polygon) */
+  points: Array<{ x: number; y: number }>;
+  /** When this was marked */
+  markedAt: number;
+}
+
+/** Summary statistics for a training session */
+export interface TrainingSessionStats {
+  /** Total duration of training in seconds */
+  totalDuration: number;
+  /** Number of cameras visited */
+  camerasVisited: number;
+  /** Number of transits recorded */
+  transitsRecorded: number;
+  /** Number of landmarks marked */
+  landmarksMarked: number;
+  /** Number of overlaps detected */
+  overlapsDetected: number;
+  /** Number of structures marked */
+  structuresMarked: number;
+  /** Average transit time in seconds */
+  averageTransitTime: number;
+  /** Coverage percentage (cameras visited / total cameras) */
+  coveragePercentage: number;
+}
+
+/** A training session */
+export interface TrainingSession {
+  /** Unique session ID */
+  id: TrainingSessionId;
+  /** Current state */
+  state: TrainingSessionState;
+  /** When the session started */
+  startedAt: number;
+  /** When the session was last updated */
+  updatedAt: number;
+  /** When the session ended (if completed) */
+  completedAt?: number;
+  /** Visual embedding of the trainer (captured at start) */
+  trainerEmbedding?: string;
+  /** Name of the trainer (for display) */
+  trainerName?: string;
+  /** All camera visits during this session */
+  visits: TrainingCameraVisit[];
+  /** All transits recorded during this session */
+  transits: TrainingTransit[];
+  /** All landmarks marked during this session */
+  landmarks: TrainingLandmark[];
+  /** All overlaps detected during this session */
+  overlaps: TrainingOverlap[];
+  /** All structures marked during this session */
+  structures: TrainingStructure[];
+  /** Current camera where trainer is detected (if any) */
+  currentCameraId?: string;
+  /** Previous camera (for transit tracking) */
+  previousCameraId?: string;
+  /** Time when trainer left previous camera */
+  transitStartTime?: number;
+  /** Session statistics */
+  stats: TrainingSessionStats;
+}
+
+/** Configuration for training mode */
+export interface TrainingConfig {
+  /** Minimum confidence for trainer detection */
+  minDetectionConfidence: number;
+  /** Maximum time (seconds) to wait for trainer at next camera */
+  maxTransitWait: number;
+  /** Whether to auto-detect overlaps */
+  autoDetectOverlaps: boolean;
+  /** Whether to auto-suggest landmarks based on AI */
+  autoSuggestLandmarks: boolean;
+  /** Minimum overlap duration (seconds) to count as overlap */
+  minOverlapDuration: number;
+}
+
+/** Real-time training status update sent to UI */
+export interface TrainingStatusUpdate {
+  /** Session ID */
+  sessionId: TrainingSessionId;
+  /** Current state */
+  state: TrainingSessionState;
+  /** Current camera (if detected) */
+  currentCamera?: {
+    id: string;
+    name: string;
+    detectedAt: number;
+    confidence: number;
+  };
+  /** Active transit (if in transit) */
+  activeTransit?: {
+    fromCameraId: string;
+    fromCameraName: string;
+    startTime: number;
+    elapsedSeconds: number;
+  };
+  /** Recent action */
+  lastAction?: {
+    type: TrainingActionType;
+    description: string;
+    timestamp: number;
+  };
+  /** Session stats */
+  stats: TrainingSessionStats;
+  /** Suggestions for next actions */
+  suggestions: string[];
+}
+
+/** Result of applying training to topology */
+export interface TrainingApplicationResult {
+  /** Number of cameras added to topology */
+  camerasAdded: number;
+  /** Number of connections created */
+  connectionsCreated: number;
+  /** Number of connections updated */
+  connectionsUpdated: number;
+  /** Number of landmarks added */
+  landmarksAdded: number;
+  /** Number of zones created */
+  zonesCreated: number;
+  /** Any warnings or issues */
+  warnings: string[];
+  /** Whether the application was successful */
+  success: boolean;
+}
+
+/** Default training configuration */
+export const DEFAULT_TRAINING_CONFIG: TrainingConfig = {
+  minDetectionConfidence: 0.7,
+  maxTransitWait: 120, // 2 minutes
+  autoDetectOverlaps: true,
+  autoSuggestLandmarks: true,
+  minOverlapDuration: 2, // 2 seconds
+};
+
+/** Create a new empty training session */
+export function createTrainingSession(trainerName?: string): TrainingSession {
+  const now = Date.now();
+  return {
+    id: `training-${now}-${Math.random().toString(36).substr(2, 9)}`,
+    state: 'idle',
+    startedAt: now,
+    updatedAt: now,
+    trainerName,
+    visits: [],
+    transits: [],
+    landmarks: [],
+    overlaps: [],
+    structures: [],
+    stats: {
+      totalDuration: 0,
+      camerasVisited: 0,
+      transitsRecorded: 0,
+      landmarksMarked: 0,
+      overlapsDetected: 0,
+      structuresMarked: 0,
+      averageTransitTime: 0,
+      coveragePercentage: 0,
+    },
+  };
+}
+
+/** Calculate session statistics */
+export function calculateTrainingStats(session: TrainingSession, totalCameras: number): TrainingSessionStats {
+  const uniqueCameras = new Set(session.visits.map(v => v.cameraId));
+  const transitTimes = session.transits.map(t => t.transitSeconds);
+  const avgTransit = transitTimes.length > 0
+    ? transitTimes.reduce((a, b) => a + b, 0) / transitTimes.length
+    : 0;
+
+  return {
+    totalDuration: (session.completedAt || Date.now()) - session.startedAt,
+    camerasVisited: uniqueCameras.size,
+    transitsRecorded: session.transits.length,
+    landmarksMarked: session.landmarks.length,
+    overlapsDetected: session.overlaps.length,
+    structuresMarked: session.structures.length,
+    averageTransitTime: Math.round(avgTransit),
+    coveragePercentage: totalCameras > 0
+      ? Math.round((uniqueCameras.size / totalCameras) * 100)
+      : 0,
+  };
+}

package/src/ui/editor-html.ts

@@ -105,6 +105,23 @@ export const EDITOR_HTML = `<!DOCTYPE html>
           </div>
           <div id="suggestions-list"></div>
         </div>
+        <div class="section" id="connection-suggestions-section" style="display: none;">
+          <div class="section-title">
+            <span>Connection Suggestions</span>
+            <button class="btn btn-small" onclick="loadConnectionSuggestions()">Refresh</button>
+          </div>
+          <div id="connection-suggestions-list"></div>
+        </div>
+        <div class="section" id="live-tracking-section">
+          <div class="section-title">
+            <span>Live Tracking</span>
+            <label class="checkbox-group" style="font-size: 11px; font-weight: normal; text-transform: none;">
+              <input type="checkbox" id="live-tracking-toggle" onchange="toggleLiveTracking(this.checked)">
+              Enable
+            </label>
+          </div>
+          <div id="live-tracking-list" style="max-height: 150px; overflow-y: auto;"></div>
+        </div>
       </div>
     </div>
     <div class="editor">
@@ -295,6 +312,12 @@ export const EDITOR_HTML = `<!DOCTYPE html>
     let availableCameras = [];
     let landmarkTemplates = [];
     let pendingSuggestions = [];
+    let connectionSuggestions = [];
+    let liveTrackingData = { objects: [], timestamp: 0 };
+    let liveTrackingEnabled = false;
+    let liveTrackingInterval = null;
+    let selectedJourneyId = null;
+    let journeyPath = null;
     let isDrawing = false;
     let drawStart = null;
     let currentDrawing = null;
@@ -307,6 +330,7 @@ export const EDITOR_HTML = `<!DOCTYPE html>
       await loadAvailableCameras();
       await loadLandmarkTemplates();
       await loadSuggestions();
+      await loadConnectionSuggestions();
       resizeCanvas();
       render();
       updateUI();
@@ -406,6 +430,132 @@ export const EDITOR_HTML = `<!DOCTYPE html>
       } catch (e) { console.error('Failed to reject suggestion:', e); }
     }
 
+    // ==================== Connection Suggestions ====================
+    async function loadConnectionSuggestions() {
+      try {
+        const response = await fetch('../api/connection-suggestions');
+        if (response.ok) {
+          const data = await response.json();
+          connectionSuggestions = data.suggestions || [];
+          updateConnectionSuggestionsUI();
+        }
+      } catch (e) { console.error('Failed to load connection suggestions:', e); }
+    }
+
+    function updateConnectionSuggestionsUI() {
+      const section = document.getElementById('connection-suggestions-section');
+      const list = document.getElementById('connection-suggestions-list');
+      if (connectionSuggestions.length === 0) {
+        section.style.display = 'none';
+        return;
+      }
+      section.style.display = 'block';
+      list.innerHTML = connectionSuggestions.map(s =>
+        '<div class="camera-item" style="display: flex; justify-content: space-between; align-items: center;">' +
+        '<div><div class="camera-name">' + s.fromCameraName + ' → ' + s.toCameraName + '</div>' +
+        '<div class="camera-info">' + Math.round(s.suggestedTransitTime.typical / 1000) + 's typical, ' +
+        Math.round(s.confidence * 100) + '% confidence</div></div>' +
+        '<div style="display: flex; gap: 5px;">' +
+        '<button class="btn btn-small btn-primary" onclick="acceptConnectionSuggestion(\\'' + s.id + '\\')">Accept</button>' +
+        '<button class="btn btn-small" onclick="rejectConnectionSuggestion(\\'' + s.id + '\\')">Reject</button>' +
+        '</div></div>'
+      ).join('');
+    }
+
+    async function acceptConnectionSuggestion(id) {
+      try {
+        const response = await fetch('../api/connection-suggestions/' + encodeURIComponent(id) + '/accept', { method: 'POST' });
+        if (response.ok) {
+          const data = await response.json();
+          if (data.connection) {
+            topology.connections.push(data.connection);
+            updateUI();
+            render();
+          }
+          await loadConnectionSuggestions();
+          setStatus('Connection accepted', 'success');
+        }
+      } catch (e) { console.error('Failed to accept connection suggestion:', e); }
+    }
+
+    async function rejectConnectionSuggestion(id) {
+      try {
+        await fetch('../api/connection-suggestions/' + encodeURIComponent(id) + '/reject', { method: 'POST' });
+        await loadConnectionSuggestions();
+        setStatus('Connection suggestion rejected', 'success');
+      } catch (e) { console.error('Failed to reject connection suggestion:', e); }
+    }
+
+    // ==================== Live Tracking ====================
+    function toggleLiveTracking(enabled) {
+      liveTrackingEnabled = enabled;
+      if (enabled) {
+        loadLiveTracking();
+        liveTrackingInterval = setInterval(loadLiveTracking, 2000); // Poll every 2 seconds
+      } else {
+        if (liveTrackingInterval) {
+          clearInterval(liveTrackingInterval);
+          liveTrackingInterval = null;
+        }
+        liveTrackingData = { objects: [], timestamp: 0 };
+        selectedJourneyId = null;
+        journeyPath = null;
+        updateLiveTrackingUI();
+        render();
+      }
+    }
+
+    async function loadLiveTracking() {
+      try {
+        const response = await fetch('../api/live-tracking');
+        if (response.ok) {
+          liveTrackingData = await response.json();
+          updateLiveTrackingUI();
+          render();
+        }
+      } catch (e) { console.error('Failed to load live tracking:', e); }
+    }
+
+    function updateLiveTrackingUI() {
+      const list = document.getElementById('live-tracking-list');
+      if (liveTrackingData.objects.length === 0) {
+        list.innerHTML = '<div style="color: #666; font-size: 12px; text-align: center; padding: 10px;">No active objects</div>';
+        return;
+      }
+      list.innerHTML = liveTrackingData.objects.map(obj => {
+        const isSelected = selectedJourneyId === obj.globalId;
+        const ageSeconds = Math.round((Date.now() - obj.lastSeen) / 1000);
+        const ageStr = ageSeconds < 60 ? ageSeconds + 's ago' : Math.round(ageSeconds / 60) + 'm ago';
+        return '<div class="camera-item' + (isSelected ? ' selected' : '') + '" ' +
+          'onclick="selectTrackedObject(\\'' + obj.globalId + '\\')" ' +
+          'style="padding: 8px; cursor: pointer;">' +
+          '<div class="camera-name" style="font-size: 12px;">' +
+          (obj.className.charAt(0).toUpperCase() + obj.className.slice(1)) +
+          (obj.label ? ' (' + obj.label + ')' : '') + '</div>' +
+          '<div class="camera-info">' + obj.lastCameraName + ' • ' + ageStr + '</div>' +
+          '</div>';
+      }).join('');
+    }
+
+    async function selectTrackedObject(globalId) {
+      if (selectedJourneyId === globalId) {
+        // Deselect
+        selectedJourneyId = null;
+        journeyPath = null;
+      } else {
+        selectedJourneyId = globalId;
+        // Load journey path
+        try {
+          const response = await fetch('../api/journey-path/' + globalId);
+          if (response.ok) {
+            journeyPath = await response.json();
+          }
+        } catch (e) { console.error('Failed to load journey path:', e); }
+      }
+      updateLiveTrackingUI();
+      render();
+    }
+
     function openAddLandmarkModal() {
       updateLandmarkSuggestions();
       document.getElementById('add-landmark-modal').classList.add('active');
@@ -629,6 +779,112 @@ export const EDITOR_HTML = `<!DOCTYPE html>
       for (const camera of topology.cameras) {
         if (camera.floorPlanPosition) { drawCamera(camera); }
       }
+
+      // Draw journey path if selected
+      if (journeyPath && journeyPath.segments.length > 0) {
+        drawJourneyPath();
+      }
+
+      // Draw live tracking objects
+      if (liveTrackingEnabled && liveTrackingData.objects.length > 0) {
+        drawLiveTrackingObjects();
+      }
+    }
+
+    function drawJourneyPath() {
+      if (!journeyPath) return;
+
+      ctx.strokeStyle = '#ff6b6b';
+      ctx.lineWidth = 3;
+      ctx.setLineDash([8, 4]);
+
+      // Draw path segments
+      for (const segment of journeyPath.segments) {
+        if (segment.fromCamera.position && segment.toCamera.position) {
+          ctx.beginPath();
+          ctx.moveTo(segment.fromCamera.position.x, segment.fromCamera.position.y);
+          ctx.lineTo(segment.toCamera.position.x, segment.toCamera.position.y);
+          ctx.stroke();
+
+          // Draw timestamp indicator
+          const midX = (segment.fromCamera.position.x + segment.toCamera.position.x) / 2;
+          const midY = (segment.fromCamera.position.y + segment.toCamera.position.y) / 2;
+          ctx.fillStyle = 'rgba(255, 107, 107, 0.9)';
+          ctx.beginPath();
+          ctx.arc(midX, midY, 4, 0, Math.PI * 2);
+          ctx.fill();
+        }
+      }
+
+      ctx.setLineDash([]);
+
+      // Draw current location indicator
+      if (journeyPath.currentLocation?.position) {
+        const pos = journeyPath.currentLocation.position;
+        // Pulsing dot effect
+        const pulse = (Date.now() % 1000) / 1000;
+        const radius = 10 + pulse * 5;
+        const alpha = 1 - pulse * 0.5;
+
+        ctx.beginPath();
+        ctx.arc(pos.x, pos.y, radius, 0, Math.PI * 2);
+        ctx.fillStyle = 'rgba(255, 107, 107, ' + alpha + ')';
+        ctx.fill();
+
+        ctx.beginPath();
+        ctx.arc(pos.x, pos.y, 6, 0, Math.PI * 2);
+        ctx.fillStyle = '#ff6b6b';
+        ctx.fill();
+        ctx.strokeStyle = '#fff';
+        ctx.lineWidth = 2;
+        ctx.stroke();
+      }
+    }
+
+    function drawLiveTrackingObjects() {
+      const objectColors = {
+        person: '#4caf50',
+        car: '#2196f3',
+        animal: '#ff9800',
+        default: '#9c27b0'
+      };
+
+      for (const obj of liveTrackingData.objects) {
+        if (!obj.cameraPosition) continue;
+
+        // Skip if this is the selected journey object (drawn separately with path)
+        if (obj.globalId === selectedJourneyId) continue;
+
+        const pos = obj.cameraPosition;
+        const color = objectColors[obj.className] || objectColors.default;
+        const ageSeconds = (Date.now() - obj.lastSeen) / 1000;
+
+        // Fade old objects
+        const alpha = Math.max(0.3, 1 - ageSeconds / 60);
+
+        // Draw object indicator
+        ctx.beginPath();
+        ctx.arc(pos.x, pos.y, 12, 0, Math.PI * 2);
+        ctx.fillStyle = color.replace(')', ', ' + alpha + ')').replace('rgb', 'rgba');
+        ctx.fill();
+        ctx.strokeStyle = 'rgba(255, 255, 255, ' + alpha + ')';
+        ctx.lineWidth = 2;
+        ctx.stroke();
+
+        // Draw class icon
+        ctx.fillStyle = 'rgba(255, 255, 255, ' + alpha + ')';
+        ctx.font = 'bold 10px sans-serif';
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'middle';
+        const icon = obj.className === 'person' ? 'P' : obj.className === 'car' ? 'C' : obj.className === 'animal' ? 'A' : '?';
+        ctx.fillText(icon, pos.x, pos.y);
+
+        // Draw label below
+        if (obj.label) {
+          ctx.font = '9px sans-serif';
+          ctx.fillText(obj.label.slice(0, 10), pos.x, pos.y + 20);
+        }
+      }
     }
 
     function drawLandmark(landmark) {