@blueharford/scrypted-spatial-awareness 0.6.4 → 0.6.6

package/out/main.nodejs.js

@@ -36602,7 +36602,9 @@ class TopologyDiscoveryEngine {
                         type: landmark.type,
                         description: landmark.description,
                         visibleFromCameras: [analysis.cameraId],
-                    },
+                        // Include bounding box for positioning (will be used by applyDiscoverySuggestion)
+                        boundingBox: landmark.boundingBox,
+                    }, // boundingBox is extra metadata not in Landmark interface
                 };
                 this.suggestions.set(suggestion.id, suggestion);
             }
@@ -40305,24 +40307,65 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
                     const direction = fov.direction || 0;
                     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.boundingBox;
+                    let angleOffset;
+                    let distanceMultiplier;
+                    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;
                     position = {
                         x: camera.floorPlanPosition.x + Math.cos(finalAngle) * distance,
                         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
@@ -40383,29 +40426,54 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
                 // Convert direction to radians (0 = up/north, 90 = right/east)
                 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) => z.linkedCameras?.includes(sourceCameras[0])).length;
-                // 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 a portion of the FOV for each zone
-                const zoneSpread = halfFov * 0.7; // 70% of half FOV
                 const camX = camera.floorPlanPosition.x;
                 const camY = camera.floorPlanPosition.y;
-                // Create arc polygon (wedge shape)
+                // Use bounding box if available to position zone accurately within FOV
+                const bbox = zone.boundingBox; // [x, y, width, height] normalized 0-1
+                let innerRadius;
+                let outerRadius;
+                let angleStart;
+                let angleEnd;
+                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) => 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
                 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,