@blueharford/scrypted-spatial-awareness 0.6.17 → 0.6.19

package/out/main.nodejs.js

@@ -36236,7 +36236,10 @@ For EACH landmark, estimate its DISTANCE from the camera:
 - Street/road
 - Neighbor's yard
 
-For each zone, estimate what percentage of the image it covers (0.0 to 1.0).
+For each zone, provide:
+- coverage: percentage of the image it covers (0.0 to 1.0)
+- distance: how far the CENTER of the zone is from camera ("close", "near", "medium", "far", "distant")
+- boundingBox: [x, y, width, height] in normalized coordinates (0-1) where the zone appears in the image
 
 ## 3. EDGES - What's at each edge of the frame:
 This helps understand what's just out of view.
@@ -36254,8 +36257,9 @@ Respond with ONLY valid JSON:
     {"name": "Large Oak Tree", "type": "feature", "distance": "far", "confidence": 0.85, "description": "Mature oak tree near property line, roughly 80 feet from camera"}
   ],
   "zones": [
-    {"name": "Front Yard", "type": "yard", "coverage": 0.5, "description": "Grass lawn with some bare patches"},
-    {"name": "Driveway", "type": "driveway", "coverage": 0.25, "description": "Concrete driveway leading to garage"}
+    {"name": "Front Yard", "type": "yard", "coverage": 0.5, "distance": "medium", "boundingBox": [0.2, 0.4, 0.6, 0.4], "description": "Grass lawn with some bare patches"},
+    {"name": "Driveway", "type": "driveway", "coverage": 0.25, "distance": "near", "boundingBox": [0.6, 0.5, 0.3, 0.4], "description": "Concrete driveway leading to garage"},
+    {"name": "Street", "type": "street", "coverage": 0.1, "distance": "distant", "boundingBox": [0.0, 0.1, 1.0, 0.15], "description": "Public road beyond property line"}
   ],
   "edges": {
     "top": "sky, tree canopy",
@@ -36536,6 +36540,7 @@ Use the mount height to help estimate distances - objects at ground level will a
                                 coverage: typeof z.coverage === 'number' ? z.coverage : 0.5,
                                 description: z.description || '',
                                 boundingBox: z.boundingBox,
+                                distance: this.mapDistance(z.distance), // Parse distance for zones too
                             }));
                         }
                         if (parsed.edges && typeof parsed.edges === 'object') {
@@ -36657,6 +36662,26 @@ Use the mount height to help estimate distances - objects at ground level will a
             return 'distant';
         return 'medium'; // Default to medium if not specified
     }
+    /** Get default distance in feet based on zone type */
+    getDefaultZoneDistance(zoneType) {
+        switch (zoneType) {
+            case 'patio':
+            case 'walkway':
+                return 10; // Close zones
+            case 'driveway':
+            case 'parking':
+                return 25; // Near zones
+            case 'yard':
+            case 'garden':
+            case 'pool':
+                return 40; // Medium zones
+            case 'street':
+                return 100; // Far zones
+            case 'unknown':
+            default:
+                return 50; // Default to medium distance
+        }
+    }
     /** Try to parse JSON with recovery for truncated responses */
     parseJsonWithRecovery(jsonStr, context) {
         // First, try direct parse
@@ -36950,6 +36975,9 @@ Use the mount height to help estimate distances - objects at ground level will a
         // Generate zone suggestions (even for smaller coverage - 10% is enough)
         for (const zone of analysis.zones) {
             if (zone.coverage >= 0.1) {
+                // Calculate distance in feet from distance estimate (for zones with distance info)
+                const zoneWithDist = zone;
+                const distanceFeet = zoneWithDist.distance ? (0, discovery_1.distanceToFeet)(zoneWithDist.distance) : this.getDefaultZoneDistance(zone.type);
                 const suggestion = {
                     id: `zone_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
                     type: 'zone',
@@ -36957,10 +36985,14 @@ Use the mount height to help estimate distances - objects at ground level will a
                     sourceCameras: [analysis.cameraId],
                     confidence: Math.min(0.9, 0.5 + zone.coverage), // Higher coverage = higher confidence
                     status: 'pending',
-                    zone: zone,
+                    zone: {
+                        ...zone,
+                        // Include distance metadata for positioning
+                        distanceFeet: distanceFeet,
+                    },
                 };
                 this.suggestions.set(suggestion.id, suggestion);
-                this.console.log(`[Discovery] Zone suggestion: ${zone.name} (${zone.type}, ${Math.round(zone.coverage * 100)}% coverage)`);
+                this.console.log(`[Discovery] Zone suggestion: ${zone.name} (${zone.type}, ${Math.round(zone.coverage * 100)}% coverage, ~${distanceFeet}ft)`);
             }
         }
     }
@@ -40784,61 +40816,38 @@ 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;
-                    // 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;
+                    // Get floor plan scale (pixels per foot) - default 5
+                    const floorPlanScale = topology.floorPlanScale || 5;
+                    // Use the ACTUAL distance from LLM analysis (distanceFeet) - this is the key fix!
+                    // The LLM estimates distance based on object size, perspective, and camera context
+                    const landmarkData = suggestion.landmark;
+                    const distanceFeet = landmarkData.distanceFeet || 50; // Default 50ft if not set
+                    const distanceInPixels = distanceFeet * floorPlanScale;
+                    // Use bounding box for horizontal positioning within the FOV
+                    const bbox = landmarkData.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`);
+                        this.console.log(`[Discovery] Using bounding box [${bbox.join(',')}] for horizontal angle offset`);
                     }
                     else {
-                        // No bounding box - use type and spread pattern
+                        // No bounding box - spread horizontally based on existing landmarks
                         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})`);
-                        }
+                        this.console.log(`[Discovery] No bounding box, spreading horizontally (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,
+                        x: camera.floorPlanPosition.x + Math.cos(finalAngle) * distanceInPixels,
+                        y: camera.floorPlanPosition.y + Math.sin(finalAngle) * distanceInPixels,
                     };
-                    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`);
+                    this.console.log(`[Discovery] Placing landmark "${suggestion.landmark.name}" at ${distanceFeet}ft (${distanceInPixels}px) from ${camera.name}: dir=${direction}°, angle=${(angleOffset * 180 / Math.PI).toFixed(1)}°`);
                 }
                 else {
                     // Position in a grid pattern starting from center
@@ -40891,48 +40900,53 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             let polygon = [];
             const timestamp = Date.now();
             if (camera?.floorPlanPosition) {
-                // Get camera's FOV direction and range (cast to any for flexible access)
+                // Get camera's FOV direction (cast to any for flexible access)
                 const fov = (camera.fov || { mode: 'simple', angle: 90, direction: 0, range: 80 });
                 const direction = fov.direction || 0;
-                const range = fov.range || 80;
                 const fovAngle = fov.angle || 90;
+                // Get floor plan scale (pixels per foot)
+                const floorPlanScale = topology.floorPlanScale || 5;
                 // Convert direction to radians (0 = up/north, 90 = right/east)
                 const dirRad = (direction - 90) * Math.PI / 180;
                 const halfFov = (fovAngle / 2) * Math.PI / 180;
                 const camX = camera.floorPlanPosition.x;
                 const camY = camera.floorPlanPosition.y;
-                // Use bounding box if available to position zone accurately within FOV
+                // Use distanceFeet from the zone metadata for accurate positioning
+                const zoneData = zone;
+                const distanceFeet = zoneData.distanceFeet || 40; // Default 40ft if not set
+                const distanceInPixels = distanceFeet * floorPlanScale;
+                // Zone size based on coverage (larger coverage = wider zone)
+                const zoneWidthFeet = Math.sqrt(zone.coverage) * 30; // e.g., 50% coverage = ~21ft wide
+                const zoneWidthPixels = zoneWidthFeet * floorPlanScale;
+                const zoneDepthPixels = (zone.coverage * 20) * floorPlanScale; // Depth based on coverage
+                // Use bounding box for horizontal positioning if available
                 const bbox = zone.boundingBox; // [x, y, width, height] normalized 0-1
-                let innerRadius;
-                let outerRadius;
                 let angleStart;
                 let angleEnd;
+                let innerRadius;
+                let outerRadius;
                 if (bbox && bbox.length >= 4) {
-                    // Map bounding box to position within FOV
+                    // Map bounding box X to angle 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)}°`);
+                    // Use distanceFeet for depth, with a spread based on coverage
+                    innerRadius = Math.max(distanceInPixels - zoneDepthPixels / 2, 10);
+                    outerRadius = distanceInPixels + zoneDepthPixels / 2;
+                    this.console.log(`[Discovery] Zone "${zone.name}" at ${distanceFeet}ft using bbox [${bbox.join(',')}]`);
                 }
                 else {
-                    // Fallback: wedge-shaped zone offset by existing count
+                    // Fallback: wedge-shaped zone covering portion of FOV
                     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})`);
+                    // Spread horizontally based on existing zones
+                    const offset = (existingFromCamera % 3 - 1) * halfFov * 0.5;
+                    angleStart = dirRad + offset - halfFov * 0.3;
+                    angleEnd = dirRad + offset + halfFov * 0.3;
+                    // Use distanceFeet for depth
+                    innerRadius = Math.max(distanceInPixels - zoneDepthPixels / 2, 10);
+                    outerRadius = distanceInPixels + zoneDepthPixels / 2;
+                    this.console.log(`[Discovery] Zone "${zone.name}" at ${distanceFeet}ft using fallback spread`);
                 }
                 // Create arc polygon
                 const steps = 8;
@@ -40952,7 +40966,7 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
                         y: camY + Math.sin(angle) * outerRadius,
                     });
                 }
-                this.console.log(`[Discovery] Creating zone "${zone.name}" in ${camera.name}'s FOV: dir=${direction}°`);
+                this.console.log(`[Discovery] Creating zone "${zone.name}" at ${distanceFeet}ft (${distanceInPixels}px) from ${camera.name}`);
             }
             else {
                 // Fallback: rectangular zone at default location
@@ -42554,6 +42568,7 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
         const response = await fetch('../api/topology');
         if (response.ok) {
           topology = await response.json();
+          console.log('[Load] Loaded topology with', (topology.drawnZones || []).length, 'zones');
           if (!topology.drawings) topology.drawings = [];
           // Load floor plan scale if saved
           if (topology.floorPlanScale) {
@@ -43071,14 +43086,24 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
     async function saveTopology() {
       try {
         setStatus('Saving...', 'warning');
+        console.log('[Save] Saving topology with', (topology.drawnZones || []).length, 'zones');
         const response = await fetch('../api/topology', {
           method: 'PUT',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify(topology)
         });
-        if (response.ok) { setStatus('Saved successfully', 'success'); }
-        else { setStatus('Failed to save', 'error'); }
-      } catch (e) { console.error('Failed to save topology:', e); setStatus('Failed to save', 'error'); }
+        if (response.ok) {
+          console.log('[Save] Save successful');
+          setStatus('Saved successfully', 'success');
+        } else {
+          const errorText = await response.text();
+          console.error('[Save] Save failed:', response.status, errorText);
+          setStatus('Failed to save: ' + errorText, 'error');
+        }
+      } catch (e) {
+        console.error('Failed to save topology:', e);
+        setStatus('Failed to save', 'error');
+      }
     }
 
     function resizeCanvas() {
@@ -43878,9 +43903,13 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
         polygon: currentZonePoints.map(pt => ({ x: pt.x, y: pt.y })),
       };
 
+      console.log('[Zone] Creating zone:', zone.name, 'with', zone.polygon.length, 'points');
+
       if (!topology.drawnZones) topology.drawnZones = [];
       topology.drawnZones.push(zone);
 
+      console.log('[Zone] Total zones now:', topology.drawnZones.length);
+
       // Reset state
       zoneDrawingMode = false;
       currentZonePoints = [];
@@ -43889,7 +43918,19 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       setTool('select');
       updateUI();
       render();
-      setStatus('Zone "' + zone.name + '" created with ' + zone.polygon.length + ' points', 'success');
+
+      console.log('[Zone] After updateUI/render, zones in topology:', (topology.drawnZones || []).length);
+
+      setStatus('Zone "' + zone.name + '" created - saving...', 'success');
+
+      // Auto-save after creating a zone
+      saveTopology().then(() => {
+        console.log('[Zone] Save completed, zones in topology:', (topology.drawnZones || []).length);
+        setStatus('Zone "' + zone.name + '" saved', 'success');
+      }).catch(err => {
+        console.error('Failed to auto-save zone:', err);
+        setStatus('Zone created but auto-save failed - click Save', 'warning');
+      });
     }
 
     function selectZone(id) {
@@ -43914,9 +43955,9 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
         '<button class="btn btn-primary" onclick="deleteZone(\\'' + id + '\\')" style="background: #dc2626; width: 100%;">Delete Zone</button>';
     }
 
-    function updateZoneName(id, value) { const z = (topology.drawnZones || []).find(z => z.id === id); if (z) { z.name = value; updateUI(); render(); } }
-    function updateZoneType(id, value) { const z = (topology.drawnZones || []).find(z => z.id === id); if (z) { z.type = value; updateUI(); render(); } }
-    function updateZoneDesc(id, value) { const z = (topology.drawnZones || []).find(z => z.id === id); if (z) { z.description = value || undefined; } }
+    function updateZoneName(id, value) { const z = (topology.drawnZones || []).find(z => z.id === id); if (z) { z.name = value; updateUI(); render(); saveTopology(); } }
+    function updateZoneType(id, value) { const z = (topology.drawnZones || []).find(z => z.id === id); if (z) { z.type = value; updateUI(); render(); saveTopology(); } }
+    function updateZoneDesc(id, value) { const z = (topology.drawnZones || []).find(z => z.id === id); if (z) { z.description = value || undefined; saveTopology(); } }
     function deleteZone(id) {
       if (!confirm('Delete this zone?')) return;
       topology.drawnZones = (topology.drawnZones || []).filter(z => z.id !== id);
@@ -43924,7 +43965,8 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
       document.getElementById('properties-panel').innerHTML = '<h3>Properties</h3><p style="color: #666;">Select an item to edit.</p>';
       updateUI();
       render();
-      setStatus('Zone deleted', 'success');
+      setStatus('Zone deleted - saving...', 'success');
+      saveTopology().then(() => setStatus('Zone deleted', 'success'));
     }
 
     function useBlankCanvas() {