@blueharford/scrypted-spatial-awareness 0.6.5 → 0.6.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueharford/scrypted-spatial-awareness",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Cross-camera object tracking for Scrypted NVR with spatial awareness",
   "author": "Joshua Seidel <blueharford>",
   "license": "Apache-2.0",

package/src/main.ts

@@ -1584,7 +1584,7 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
     }
   }
 
-  private handleTrainingEndRequest(response: HttpResponse): void {
+  private async handleTrainingEndRequest(response: HttpResponse): Promise<void> {
     if (!this.trackingEngine) {
       response.send(JSON.stringify({ error: 'Tracking engine not running' }), {
         code: 500,
@@ -1595,6 +1595,44 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
 
     const session = this.trackingEngine.endTrainingSession();
     if (session) {
+      // Get unique visited cameras
+      const visitedCameraIds = [...new Set(session.visits.map(v => v.cameraId))];
+
+      // Auto-run discovery on visited cameras to detect landmarks and zones
+      if (this.discoveryEngine && visitedCameraIds.length > 0) {
+        this.console.log(`[Training] Running discovery analysis on ${visitedCameraIds.length} visited cameras...`);
+
+        let landmarksFound = 0;
+        let zonesFound = 0;
+
+        for (const cameraId of visitedCameraIds) {
+          try {
+            const analysis = await this.discoveryEngine.analyzeScene(cameraId);
+            if (analysis.isValid) {
+              landmarksFound += analysis.landmarks.length;
+              zonesFound += analysis.zones.length;
+              this.console.log(`[Training] ${cameraId}: Found ${analysis.landmarks.length} landmarks, ${analysis.zones.length} zones`);
+            }
+          } catch (e) {
+            this.console.warn(`[Training] Failed to analyze ${cameraId}:`, e);
+          }
+        }
+
+        // Get all pending suggestions and auto-accept them
+        const suggestions = this.discoveryEngine.getPendingSuggestions();
+        for (const suggestion of suggestions) {
+          this.applyDiscoverySuggestion(suggestion);
+          this.discoveryEngine.acceptSuggestion(suggestion.id);
+        }
+
+        // Persist topology after applying suggestions
+        if (suggestions.length > 0 && this.trackingEngine) {
+          const updatedTopology = this.trackingEngine.getTopology();
+          await this.storageSettings.putSetting('topology', JSON.stringify(updatedTopology));
+          this.console.log(`[Training] Auto-applied ${suggestions.length} discoveries (${landmarksFound} landmarks, ${zonesFound} zones)`);
+        }
+      }
+
       response.send(JSON.stringify(session), {
         headers: { 'Content-Type': 'application/json' },
       });
@@ -1866,7 +1904,13 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
           const dirRad = (direction - 90) * Math.PI / 180;
           const halfFov = (fovAngle / 2) * Math.PI / 180;
 
-          // Use bounding box if available to position landmark accurately within FOV
+          // Use landmark TYPE to determine distance - some things are inherently far away
+          // regardless of where they appear in the camera frame
+          const landmarkType = suggestion.landmark.type;
+          const farTypes = ['neighbor', 'boundary', 'street']; // Always place at edge of FOV
+          const isFarType = farTypes.includes(landmarkType || '');
+
+          // Use bounding box if available for horizontal positioning
           // boundingBox format: [x, y, width, height] normalized 0-1
           const bbox = (suggestion.landmark as any).boundingBox as [number, number, number, number] | undefined;
 
@@ -1874,33 +1918,46 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
           let distanceMultiplier: number;
 
           if (bbox && bbox.length >= 2) {
-            // Use bounding box center to determine position in FOV
+            // Use bounding box X for horizontal position in FOV
             const bboxCenterX = bbox[0] + (bbox[2] || 0) / 2; // 0 = left edge, 1 = right edge
-            const bboxCenterY = bbox[1] + (bbox[3] || 0) / 2; // 0 = top (far), 1 = bottom (close)
 
             // Map X position to angle within FOV
-            // bboxCenterX 0 → left side of FOV (-halfFov)
-            // bboxCenterX 0.5 → center of FOV (0)
-            // bboxCenterX 1 → right side of FOV (+halfFov)
             angleOffset = (bboxCenterX - 0.5) * 2 * halfFov;
 
-            // Map Y position to distance from camera
-            // bboxCenterY 0 (top of frame) → far from camera (90% of range)
-            // bboxCenterY 1 (bottom of frame) → close to camera (30% of range)
-            distanceMultiplier = 0.9 - (bboxCenterY * 0.6);
-
-            this.console.log(`[Discovery] Using bounding box [${bbox.join(',')}] → center (${bboxCenterX.toFixed(2)}, ${bboxCenterY.toFixed(2)})`);
+            // For distance: use TYPE first, then bbox Y as hint
+            if (isFarType) {
+              // Neighbors, boundaries, streets are BEYOND the camera's normal range
+              // Place at 150-200% of range to indicate they're distant background features
+              distanceMultiplier = 1.5 + Math.random() * 0.5; // 150-200% of range
+              this.console.log(`[Discovery] Far-type landmark "${landmarkType}" placed BEYOND FOV (${(distanceMultiplier * 100).toFixed(0)}% of range)`);
+            } else {
+              // For other types, use bbox Y as a hint (but cap minimum distance)
+              const bboxCenterY = bbox[1] + (bbox[3] || 0) / 2;
+              // Map Y to distance: 0 (top) = far, 1 (bottom) = closer (but not too close)
+              distanceMultiplier = Math.max(0.4, 0.9 - (bboxCenterY * 0.5));
+            }
+
+            this.console.log(`[Discovery] Using bounding box [${bbox.join(',')}] for horizontal position`);
           } else {
-            // Fallback: spread landmarks across FOV if no bounding box
+            // No bounding box - use type and spread pattern
             const cameraDeviceId = camera.deviceId;
             const existingFromCamera = (topology.landmarks || []).filter(l =>
               l.visibleFromCameras?.includes(cameraDeviceId) ||
               l.visibleFromCameras?.includes(camera.name)
             ).length;
 
+            // Spread horizontally across FOV
             angleOffset = (existingFromCamera % 3 - 1) * halfFov * 0.6;
-            distanceMultiplier = 0.5 + (existingFromCamera % 2) * 0.3;
-            this.console.log(`[Discovery] No bounding box, using fallback spread (existing: ${existingFromCamera})`);
+
+            // Distance based on type
+            if (isFarType) {
+              // Neighbors, boundaries, streets are BEYOND the camera's normal range
+              distanceMultiplier = 1.5 + Math.random() * 0.5; // 150-200% of range
+              this.console.log(`[Discovery] Far-type landmark "${landmarkType}" (no bbox) placed BEYOND FOV`);
+            } else {
+              distanceMultiplier = 0.5 + (existingFromCamera % 2) * 0.3;
+              this.console.log(`[Discovery] No bounding box, using fallback spread (existing: ${existingFromCamera})`);
+            }
           }
 
           const finalAngle = dirRad + angleOffset;