@blueharford/scrypted-spatial-awareness 0.6.5 → 0.6.7

package/out/main.nodejs.js

@@ -40054,7 +40054,7 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             });
         }
     }
-    handleTrainingEndRequest(response) {
+    async handleTrainingEndRequest(response) {
         if (!this.trackingEngine) {
             response.send(JSON.stringify({ error: 'Tracking engine not running' }), {
                 code: 500,
@@ -40064,6 +40064,39 @@ class SpatialAwarenessPlugin extends sdk_1.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' },
             });
@@ -40311,34 +40344,53 @@ 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 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.boundingBox;
                     let angleOffset;
                     let distanceMultiplier;
                     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;
                     const distance = range * distanceMultiplier;