@blueharford/scrypted-spatial-awareness 0.5.8 → 0.5.9

package/out/main.nodejs.js

@@ -36275,7 +36275,7 @@ class TopologyDiscoveryEngine {
                             ],
                         },
                     ],
-                    max_tokens: 500,
+                    max_tokens: 1500,
                     temperature: 0.3,
                 });
                 const content = result?.choices?.[0]?.message?.content;
@@ -36484,7 +36484,7 @@ class TopologyDiscoveryEngine {
             const prompt = CORRELATION_PROMPT.replace('{scenes}', scenesText);
             const result = await llm.getChatCompletion({
                 messages: [{ role: 'user', content: prompt }],
-                max_tokens: 800,
+                max_tokens: 2000,
                 temperature: 0.4,
             });
             const content = result?.choices?.[0]?.message?.content;
@@ -40224,12 +40224,38 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
         const topology = this.trackingEngine.getTopology();
         let updated = false;
         if (suggestion.type === 'landmark' && suggestion.landmark) {
+            // Calculate a reasonable position for the landmark
+            // Use the first visible camera's position as a starting point, or canvas center
+            let position = suggestion.landmark.position;
+            if (!position || (position.x === 0 && position.y === 0)) {
+                // 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;
+                if (camera?.floorPlanPosition) {
+                    // Position near the camera with some offset
+                    const offset = (topology.landmarks?.length || 0) * 30;
+                    position = {
+                        x: camera.floorPlanPosition.x + 50 + (offset % 100),
+                        y: camera.floorPlanPosition.y + 50 + Math.floor(offset / 100) * 30,
+                    };
+                }
+                else {
+                    // Position in a grid pattern starting from center
+                    const landmarkCount = topology.landmarks?.length || 0;
+                    const gridSize = 80;
+                    const cols = 5;
+                    position = {
+                        x: 200 + (landmarkCount % cols) * gridSize,
+                        y: 100 + Math.floor(landmarkCount / cols) * gridSize,
+                    };
+                }
+            }
             // Add new landmark to topology
             const landmark = {
                 id: `landmark_${Date.now()}`,
                 name: suggestion.landmark.name,
                 type: suggestion.landmark.type,
-                position: suggestion.landmark.position || { x: 0, y: 0 },
+                position,
                 description: suggestion.landmark.description,
                 visibleFromCameras: suggestion.landmark.visibleFromCameras,
                 aiSuggested: true,
@@ -40240,15 +40266,69 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             }
             topology.landmarks.push(landmark);
             updated = true;
-            this.console.log(`[Discovery] Added landmark: ${landmark.name}`);
+            this.console.log(`[Discovery] Added landmark: ${landmark.name} at (${position.x}, ${position.y})`);
+        }
+        if (suggestion.type === 'zone' && suggestion.zone) {
+            // Create a drawn zone from the discovery zone
+            const zone = suggestion.zone;
+            // Find cameras that see this zone type to determine position
+            const cameraWithZone = suggestion.sourceCameras?.[0];
+            const camera = cameraWithZone ? topology.cameras.find(c => c.deviceId === cameraWithZone || c.name === cameraWithZone) : null;
+            // Create a default polygon near the camera or at a default location
+            let centerX = 300;
+            let centerY = 200;
+            if (camera?.floorPlanPosition) {
+                centerX = camera.floorPlanPosition.x;
+                centerY = camera.floorPlanPosition.y + 80;
+            }
+            // Create a rectangular zone (user can edit later)
+            const size = 100;
+            const drawnZone = {
+                id: `zone_${Date.now()}`,
+                name: zone.name,
+                type: (zone.type || 'custom'),
+                description: zone.description,
+                polygon: [
+                    { x: centerX - size / 2, y: centerY - size / 2 },
+                    { x: centerX + size / 2, y: centerY - size / 2 },
+                    { x: centerX + size / 2, y: centerY + size / 2 },
+                    { x: centerX - size / 2, y: centerY + size / 2 },
+                ],
+            };
+            if (!topology.drawnZones) {
+                topology.drawnZones = [];
+            }
+            topology.drawnZones.push(drawnZone);
+            updated = true;
+            this.console.log(`[Discovery] Added zone: ${zone.name} (${zone.type})`);
         }
         if (suggestion.type === 'connection' && suggestion.connection) {
             // Add new connection to topology
             const conn = suggestion.connection;
+            // Ensure cameras have floor plan positions for visibility
+            const fromCamera = topology.cameras.find(c => c.deviceId === conn.fromCameraId || c.name === conn.fromCameraId);
+            const toCamera = topology.cameras.find(c => c.deviceId === conn.toCameraId || c.name === conn.toCameraId);
+            // Auto-assign floor plan positions if missing
+            if (fromCamera && !fromCamera.floorPlanPosition) {
+                const idx = topology.cameras.indexOf(fromCamera);
+                fromCamera.floorPlanPosition = {
+                    x: 150 + (idx % 3) * 200,
+                    y: 150 + Math.floor(idx / 3) * 150,
+                };
+                this.console.log(`[Discovery] Auto-positioned camera: ${fromCamera.name}`);
+            }
+            if (toCamera && !toCamera.floorPlanPosition) {
+                const idx = topology.cameras.indexOf(toCamera);
+                toCamera.floorPlanPosition = {
+                    x: 150 + (idx % 3) * 200,
+                    y: 150 + Math.floor(idx / 3) * 150,
+                };
+                this.console.log(`[Discovery] Auto-positioned camera: ${toCamera.name}`);
+            }
             const newConnection = {
                 id: `conn_${Date.now()}`,
-                fromCameraId: conn.fromCameraId,
-                toCameraId: conn.toCameraId,
+                fromCameraId: fromCamera?.deviceId || conn.fromCameraId,
+                toCameraId: toCamera?.deviceId || conn.toCameraId,
                 bidirectional: conn.bidirectional,
                 // Default exit/entry zones covering full frame
                 exitZone: [[0, 0], [100, 0], [100, 100], [0, 100]],
@@ -40262,7 +40342,7 @@ class SpatialAwarenessPlugin extends sdk_1.ScryptedDeviceBase {
             };
             topology.connections.push(newConnection);
             updated = true;
-            this.console.log(`[Discovery] Added connection: ${conn.fromCameraId} -> ${conn.toCameraId}`);
+            this.console.log(`[Discovery] Added connection: ${fromCamera?.name || conn.fromCameraId} -> ${toCamera?.name || conn.toCameraId}`);
         }
         if (updated) {
             // Save updated topology
@@ -42311,6 +42391,12 @@ exports.EDITOR_HTML = `<!DOCTYPE html>
         for (let i = 1; i < currentZonePoints.length; i++) {
           ctx.lineTo(currentZonePoints[i].x, currentZonePoints[i].y);
         }
+        // Close the polygon if we have 3+ points
+        if (currentZonePoints.length >= 3) {
+          ctx.closePath();
+          ctx.fillStyle = color;
+          ctx.fill();
+        }
         ctx.strokeStyle = strokeColor;
         ctx.lineWidth = 2;
         ctx.stroke();