@blueharford/scrypted-spatial-awareness 0.6.2 → 0.6.4

package/package.json

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

package/src/core/topology-discovery.ts

@@ -83,13 +83,15 @@ Identify:
 2. Camera connections - How someone could move between camera views and estimated walking time
 3. Overall layout - Describe the property layout based on what you see
 
+IMPORTANT: For camera references, use the EXACT device ID shown in parentheses (e.g., "device_123"), NOT the camera name.
+
 Respond with ONLY valid JSON:
 {
   "sharedLandmarks": [
-    {"name": "Driveway", "type": "access", "seenByCameras": ["camera1", "camera2"], "confidence": 0.8, "description": "Concrete driveway"}
+    {"name": "Driveway", "type": "access", "seenByCameras": ["device_123", "device_456"], "confidence": 0.8, "description": "Concrete driveway"}
   ],
   "connections": [
-    {"from": "camera1", "to": "camera2", "transitSeconds": 10, "via": "driveway", "confidence": 0.7, "bidirectional": true}
+    {"from": "device_123", "to": "device_456", "transitSeconds": 10, "via": "driveway", "confidence": 0.7, "bidirectional": true}
   ],
   "layoutDescription": "Single-story house with front yard facing street, driveway on the left side, backyard accessible through side gate"
 }`;
@@ -447,6 +449,40 @@ export class TopologyDiscoveryEngine {
     return 'unknown';
   }
 
+  /** Resolve a camera reference (name or deviceId) to its deviceId */
+  private resolveCameraRef(ref: string): string | null {
+    if (!this.topology?.cameras || !ref) return null;
+
+    // Try exact deviceId match first
+    const byId = this.topology.cameras.find(c => c.deviceId === ref);
+    if (byId) return byId.deviceId;
+
+    // Try exact name match
+    const byName = this.topology.cameras.find(c => c.name === ref);
+    if (byName) return byName.deviceId;
+
+    // Try case-insensitive name match
+    const refLower = ref.toLowerCase();
+    const byNameLower = this.topology.cameras.find(c => c.name.toLowerCase() === refLower);
+    if (byNameLower) return byNameLower.deviceId;
+
+    // Try partial name match (LLM might truncate or abbreviate)
+    const byPartial = this.topology.cameras.find(c =>
+      c.name.toLowerCase().includes(refLower) || refLower.includes(c.name.toLowerCase())
+    );
+    if (byPartial) return byPartial.deviceId;
+
+    this.console.warn(`[Discovery] Could not resolve camera reference: "${ref}"`);
+    return null;
+  }
+
+  /** Normalize camera references in an array to deviceIds */
+  private normalizeCameraRefs(refs: string[]): string[] {
+    return refs
+      .map(ref => this.resolveCameraRef(ref))
+      .filter((id): id is string => id !== null);
+  }
+
   /** Analyze all cameras and correlate findings */
   async runFullDiscovery(): Promise<TopologyCorrelation | null> {
     if (!this.topology?.cameras?.length) {
@@ -552,24 +588,42 @@ export class TopologyDiscoveryEngine {
           };
 
           if (Array.isArray(parsed.sharedLandmarks)) {
-            correlation.sharedLandmarks = parsed.sharedLandmarks.map((l: any) => ({
-              name: l.name || 'Unknown',
-              type: this.mapLandmarkType(l.type),
-              seenByCameras: Array.isArray(l.seenByCameras) ? l.seenByCameras : [],
-              confidence: typeof l.confidence === 'number' ? l.confidence : 0.7,
-              description: l.description,
-            }));
+            correlation.sharedLandmarks = parsed.sharedLandmarks.map((l: any) => {
+              // Normalize camera references to deviceIds
+              const rawRefs = Array.isArray(l.seenByCameras) ? l.seenByCameras : [];
+              const normalizedRefs = this.normalizeCameraRefs(rawRefs);
+              if (rawRefs.length > 0 && normalizedRefs.length === 0) {
+                this.console.warn(`[Discovery] Landmark "${l.name}" has no resolvable camera refs: ${JSON.stringify(rawRefs)}`);
+              }
+              return {
+                name: l.name || 'Unknown',
+                type: this.mapLandmarkType(l.type),
+                seenByCameras: normalizedRefs,
+                confidence: typeof l.confidence === 'number' ? l.confidence : 0.7,
+                description: l.description,
+              };
+            });
           }
 
           if (Array.isArray(parsed.connections)) {
-            correlation.suggestedConnections = parsed.connections.map((c: any) => ({
-              fromCameraId: c.from || c.fromCameraId || '',
-              toCameraId: c.to || c.toCameraId || '',
-              transitSeconds: typeof c.transitSeconds === 'number' ? c.transitSeconds : 15,
-              via: c.via || '',
-              confidence: typeof c.confidence === 'number' ? c.confidence : 0.6,
-              bidirectional: c.bidirectional !== false,
-            }));
+            correlation.suggestedConnections = parsed.connections.map((c: any) => {
+              // Normalize camera references to deviceIds
+              const fromRef = c.from || c.fromCameraId || '';
+              const toRef = c.to || c.toCameraId || '';
+              const fromId = this.resolveCameraRef(fromRef);
+              const toId = this.resolveCameraRef(toRef);
+              if (!fromId || !toId) {
+                this.console.warn(`[Discovery] Connection has unresolvable camera refs: from="${fromRef}" to="${toRef}"`);
+              }
+              return {
+                fromCameraId: fromId || fromRef,
+                toCameraId: toId || toRef,
+                transitSeconds: typeof c.transitSeconds === 'number' ? c.transitSeconds : 15,
+                via: c.via || '',
+                confidence: typeof c.confidence === 'number' ? c.confidence : 0.6,
+                bidirectional: c.bidirectional !== false,
+              };
+            });
           }
 
           this.console.log(`[Discovery] Correlation found ${correlation.sharedLandmarks.length} shared landmarks, ${correlation.suggestedConnections.length} connections`);

package/src/main.ts

@@ -1827,9 +1827,32 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       // Calculate position for the landmark WITHIN the camera's field of view
       let position = suggestion.landmark.position;
       if (!position || (position.x === 0 && position.y === 0)) {
+        // Debug logging
+        this.console.log(`[Discovery] Processing landmark "${suggestion.landmark.name}"`);
+        this.console.log(`[Discovery] sourceCameras: ${JSON.stringify(suggestion.sourceCameras)}`);
+        this.console.log(`[Discovery] visibleFromCameras: ${JSON.stringify(suggestion.landmark.visibleFromCameras)}`);
+        this.console.log(`[Discovery] Available cameras: ${topology.cameras.map(c => `${c.name}(${c.deviceId})`).join(', ')}`);
+
         // Find a camera that can see this landmark
-        const visibleCameraId = suggestion.landmark.visibleFromCameras?.[0];
-        const camera = visibleCameraId ? topology.cameras.find(c => c.deviceId === visibleCameraId) : null;
+        // PREFER sourceCameras (set from analysis.cameraId) over visibleFromCameras (from LLM parsing)
+        const sourceCameraRef = suggestion.sourceCameras?.[0];
+        const visibleCameraRef = suggestion.landmark.visibleFromCameras?.[0];
+        const cameraRef = sourceCameraRef || visibleCameraRef;
+
+        // Use flexible matching (deviceId, name, or case-insensitive)
+        const camera = cameraRef ? topology.cameras.find(c =>
+          c.deviceId === cameraRef ||
+          c.name === cameraRef ||
+          c.name.toLowerCase() === cameraRef.toLowerCase()
+        ) : null;
+
+        if (camera) {
+          this.console.log(`[Discovery] Matched camera: ${camera.name} (${camera.deviceId})`);
+          this.console.log(`[Discovery] Camera position: ${JSON.stringify(camera.floorPlanPosition)}`);
+          this.console.log(`[Discovery] Camera FOV: ${JSON.stringify(camera.fov)}`);
+        } else {
+          this.console.warn(`[Discovery] No camera matched for ref="${cameraRef}" (source="${sourceCameraRef}", visible="${visibleCameraRef}")`);
+        }
 
         if (camera?.floorPlanPosition) {
           // Get camera's FOV direction and range (cast to any for flexible access)
@@ -1839,8 +1862,10 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
           const fovAngle = fov.angle || 90;
 
           // Count existing landmarks from this camera to spread them out
+          const cameraDeviceId = camera.deviceId;
           const existingFromCamera = (topology.landmarks || []).filter(l =>
-            l.visibleFromCameras?.includes(visibleCameraId)
+            l.visibleFromCameras?.includes(cameraDeviceId) ||
+            l.visibleFromCameras?.includes(camera.name)
           ).length;
 
           // Calculate position in front of camera within its FOV
@@ -1900,10 +1925,22 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
 
       // Find cameras that see this zone
       const sourceCameras = suggestion.sourceCameras || [];
-      const camera = sourceCameras[0]
-        ? topology.cameras.find(c => c.deviceId === sourceCameras[0] || c.name === sourceCameras[0])
+      const cameraRef = sourceCameras[0];
+      const camera = cameraRef
+        ? topology.cameras.find(c =>
+            c.deviceId === cameraRef ||
+            c.name === cameraRef ||
+            c.name.toLowerCase() === cameraRef.toLowerCase()
+          )
         : null;
 
+      this.console.log(`[Discovery] Processing zone "${zone.name}" from camera ref="${cameraRef}"`);
+      if (camera) {
+        this.console.log(`[Discovery] Matched camera: ${camera.name} (${camera.deviceId})`);
+      } else if (cameraRef) {
+        this.console.warn(`[Discovery] No camera matched for zone source ref="${cameraRef}"`);
+      }
+
       // Create zone polygon WITHIN the camera's field of view
       let polygon: { x: number; y: number }[] = [];
       const timestamp = Date.now();
@@ -1987,8 +2024,15 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       const globalZoneType = this.mapZoneTypeToGlobalType(zone.type);
       const cameraZones: CameraZoneMapping[] = sourceCameras
         .map(camRef => {
-          const cam = topology.cameras.find(c => c.deviceId === camRef || c.name === camRef);
-          if (!cam) return null;
+          const cam = topology.cameras.find(c =>
+            c.deviceId === camRef ||
+            c.name === camRef ||
+            c.name.toLowerCase() === camRef.toLowerCase()
+          );
+          if (!cam) {
+            this.console.warn(`[Discovery] GlobalZone: No camera matched for ref="${camRef}"`);
+            return null;
+          }
           return {
             cameraId: cam.deviceId,
             zone: [[0, 0], [100, 0], [100, 100], [0, 100]] as ClipPath, // Full frame default