@blueharford/scrypted-spatial-awareness 0.5.7 → 0.5.9

package/out/main.nodejs.js

@@ -35076,35 +35076,48 @@ const { systemManager, mediaManager } = sdk_1.default;
  */
 async function mediaObjectToBase64(mediaObject) {
     try {
-        console.log(`[Image] Converting MediaObject, mimeType=${mediaObject?.mimeType}`);
-        // First convert to JPEG to ensure consistent format
-        const jpegMediaObject = await mediaManager.convertMediaObject(mediaObject, 'image/jpeg');
-        console.log(`[Image] Converted to JPEG MediaObject`);
-        // Get the buffer from the converted media object
-        const buffer = await mediaManager.convertMediaObjectToBuffer(jpegMediaObject, 'image/jpeg');
-        // Check if we got an actual Buffer (not a proxy)
-        const isRealBuffer = Buffer.isBuffer(buffer);
-        const bufferLength = isRealBuffer ? buffer.length : 0;
-        console.log(`[Image] Buffer: isBuffer=${isRealBuffer}, length=${bufferLength}`);
-        if (!isRealBuffer || bufferLength === 0) {
-            console.warn('[Image] Did not receive a valid Buffer');
-            // Try alternate approach: get raw data using any type
+        const mimeType = mediaObject?.mimeType || 'image/jpeg';
+        console.log(`[Image] Converting MediaObject, mimeType=${mimeType}`);
+        // Use createMediaObject to ensure we have a proper MediaObject with mimeType
+        // Then convert to buffer - this should handle the conversion internally
+        let buffer;
+        try {
+            // Try direct conversion with the source mime type
+            buffer = await mediaManager.convertMediaObjectToBuffer(mediaObject, mimeType);
+        }
+        catch (convErr) {
+            console.warn(`[Image] Direct conversion failed, trying with explicit JPEG:`, convErr);
+            // Try creating a new MediaObject with explicit mimeType
             try {
+                // Get raw data if available
                 const anyMedia = mediaObject;
                 if (typeof anyMedia.getData === 'function') {
-                    const data = await anyMedia.getData();
-                    if (data && Buffer.isBuffer(data)) {
-                        console.log(`[Image] Got data from getData(): ${data.length} bytes`);
-                        if (data.length > 1000) {
-                            const base64 = data.toString('base64');
-                            return { base64, mediaType: 'image/jpeg' };
-                        }
+                    const rawData = await anyMedia.getData();
+                    if (rawData && Buffer.isBuffer(rawData) && rawData.length > 1000) {
+                        console.log(`[Image] Got raw data: ${rawData.length} bytes`);
+                        buffer = rawData;
+                    }
+                    else {
+                        console.warn(`[Image] getData returned invalid data`);
+                        return null;
                     }
                 }
+                else {
+                    console.warn('[Image] No getData method available');
+                    return null;
+                }
             }
             catch (dataErr) {
-                console.warn('[Image] getData() failed:', dataErr);
+                console.warn('[Image] Alternate data fetch failed:', dataErr);
+                return null;
             }
+        }
+        // Check if we got an actual Buffer (not a proxy)
+        const isRealBuffer = Buffer.isBuffer(buffer);
+        const bufferLength = isRealBuffer ? buffer.length : 0;
+        console.log(`[Image] Buffer: isBuffer=${isRealBuffer}, length=${bufferLength}`);
+        if (!isRealBuffer || bufferLength === 0) {
+            console.warn('[Image] Did not receive a valid Buffer');
             return null;
         }
         // Check if buffer is too small to be a valid image (< 1KB is suspicious)
@@ -36262,7 +36275,7 @@ class TopologyDiscoveryEngine {
                             ],
                         },
                     ],
-                    max_tokens: 500,
+                    max_tokens: 1500,
                     temperature: 0.3,
                 });
                 const content = result?.choices?.[0]?.message?.content;
@@ -36471,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;
@@ -40211,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,
@@ -40227,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]],
@@ -40249,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
@@ -42298,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();