@blueharford/scrypted-spatial-awareness 0.6.4 → 0.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueharford/scrypted-spatial-awareness",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "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

@@ -659,7 +659,9 @@ export class TopologyDiscoveryEngine {
             type: landmark.type,
             description: landmark.description,
             visibleFromCameras: [analysis.cameraId],
-          },
+            // Include bounding box for positioning (will be used by applyDiscoverySuggestion)
+            boundingBox: landmark.boundingBox,
+          } as any, // boundingBox is extra metadata not in Landmark interface
         };
         this.suggestions.set(suggestion.id, suggestion);
       }

package/src/main.ts

@@ -1861,21 +1861,66 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
           const range = fov.range || 80;
           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(cameraDeviceId) ||
-            l.visibleFromCameras?.includes(camera.name)
-          ).length;
-
           // Calculate position in front of camera within its FOV
           // Convert direction to radians (0 = up/north, 90 = right/east)
           const dirRad = (direction - 90) * Math.PI / 180;
           const halfFov = (fovAngle / 2) * Math.PI / 180;
 
-          // Spread landmarks across the FOV cone at varying distances
-          const angleOffset = (existingFromCamera % 3 - 1) * halfFov * 0.6; // -0.6, 0, +0.6 of half FOV
-          const distanceMultiplier = 0.5 + (existingFromCamera % 2) * 0.3; // 50% or 80% of range
+          // 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;
+
+          let angleOffset: number;
+          let distanceMultiplier: number;
+
+          if (bbox && bbox.length >= 2) {
+            // Use bounding box X for horizontal position in FOV
+            const bboxCenterX = bbox[0] + (bbox[2] || 0) / 2; // 0 = left edge, 1 = right edge
+
+            // Map X position to angle within FOV
+            angleOffset = (bboxCenterX - 0.5) * 2 * halfFov;
+
+            // 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 {
+            // 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;
+
+            // 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;
           const distance = range * distanceMultiplier;
@@ -1885,7 +1930,7 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
             y: camera.floorPlanPosition.y + Math.sin(finalAngle) * distance,
           };
 
-          this.console.log(`[Discovery] Placing landmark "${suggestion.landmark.name}" in ${camera.name}'s FOV: dir=${direction}°, dist=${distance.toFixed(0)}px`);
+          this.console.log(`[Discovery] Placing landmark "${suggestion.landmark.name}" in ${camera.name}'s FOV: dir=${direction}°, angle=${(angleOffset * 180 / Math.PI).toFixed(1)}°, dist=${distance.toFixed(0)}px`);
         } else {
           // Position in a grid pattern starting from center
           const landmarkCount = topology.landmarks?.length || 0;
@@ -1956,35 +2001,65 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
         const dirRad = (direction - 90) * Math.PI / 180;
         const halfFov = (fovAngle / 2) * Math.PI / 180;
 
-        // Count existing zones from this camera to offset new ones
-        const existingFromCamera = (topology.drawnZones || []).filter((z: any) =>
-          z.linkedCameras?.includes(sourceCameras[0])
-        ).length;
+        const camX = camera.floorPlanPosition.x;
+        const camY = camera.floorPlanPosition.y;
 
-        // Create a wedge-shaped zone within the camera's FOV
-        // Offset based on existing zones to avoid overlap
-        const innerRadius = range * 0.3 + existingFromCamera * 20;
-        const outerRadius = range * 0.8 + existingFromCamera * 20;
+        // Use bounding box if available to position zone accurately within FOV
+        const bbox = zone.boundingBox; // [x, y, width, height] normalized 0-1
 
-        // Use a portion of the FOV for each zone
-        const zoneSpread = halfFov * 0.7; // 70% of half FOV
+        let innerRadius: number;
+        let outerRadius: number;
+        let angleStart: number;
+        let angleEnd: number;
 
-        const camX = camera.floorPlanPosition.x;
-        const camY = camera.floorPlanPosition.y;
+        if (bbox && bbox.length >= 4) {
+          // Map bounding box to position within FOV
+          const bboxLeft = bbox[0];
+          const bboxRight = bbox[0] + bbox[2];
+          const bboxTop = bbox[1];
+          const bboxBottom = bbox[1] + bbox[3];
+
+          // Map X to angle within FOV (0 = left edge, 1 = right edge)
+          angleStart = dirRad + (bboxLeft - 0.5) * 2 * halfFov;
+          angleEnd = dirRad + (bboxRight - 0.5) * 2 * halfFov;
+
+          // Map Y to distance (0 = far, 1 = close)
+          innerRadius = range * (0.9 - bboxBottom * 0.6);
+          outerRadius = range * (0.9 - bboxTop * 0.6);
+
+          // Ensure min size
+          if (outerRadius - innerRadius < 20) {
+            outerRadius = innerRadius + 20;
+          }
+
+          this.console.log(`[Discovery] Zone "${zone.name}" using bbox [${bbox.join(',')}] → angles ${(angleStart * 180 / Math.PI).toFixed(1)}° to ${(angleEnd * 180 / Math.PI).toFixed(1)}°`);
+        } else {
+          // Fallback: wedge-shaped zone offset by existing count
+          const existingFromCamera = (topology.drawnZones || []).filter((z: any) =>
+            z.linkedCameras?.includes(sourceCameras[0])
+          ).length;
+
+          innerRadius = range * 0.3 + existingFromCamera * 20;
+          outerRadius = range * 0.8 + existingFromCamera * 20;
+          angleStart = dirRad - halfFov * 0.7;
+          angleEnd = dirRad + halfFov * 0.7;
+
+          this.console.log(`[Discovery] Zone "${zone.name}" using fallback spread (existing: ${existingFromCamera})`);
+        }
 
-        // Create arc polygon (wedge shape)
+        // Create arc polygon
         const steps = 8;
-        // Inner arc (from left to right)
+        // Inner arc (from start angle to end angle)
         for (let i = 0; i <= steps; i++) {
-          const angle = dirRad - zoneSpread + (zoneSpread * 2 * i / steps);
+          const angle = angleStart + (angleEnd - angleStart) * i / steps;
           polygon.push({
             x: camX + Math.cos(angle) * innerRadius,
             y: camY + Math.sin(angle) * innerRadius,
           });
         }
-        // Outer arc (from right to left)
+        // Outer arc (from end angle to start angle)
         for (let i = steps; i >= 0; i--) {
-          const angle = dirRad - zoneSpread + (zoneSpread * 2 * i / steps);
+          const angle = angleStart + (angleEnd - angleStart) * i / steps;
           polygon.push({
             x: camX + Math.cos(angle) * outerRadius,
             y: camY + Math.sin(angle) * outerRadius,