@blueharford/scrypted-spatial-awareness 0.6.15 → 0.6.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueharford/scrypted-spatial-awareness",
-  "version": "0.6.15",
+  "version": "0.6.17",
   "description": "Cross-camera object tracking for Scrypted NVR with spatial awareness",
   "author": "Joshua Seidel <blueharford>",
   "license": "Apache-2.0",

package/src/core/topology-discovery.ts

@@ -379,18 +379,33 @@ export class TopologyDiscoveryEngine {
       try {
         this.console.log(`[Discovery] Trying ${formatType} image format for ${cameraName}...`);
 
+        // Build prompt with camera context (height)
+        const cameraNode = this.topology ? findCamera(this.topology, cameraId) : null;
+        const mountHeight = cameraNode?.context?.mountHeight || 8;
+        const cameraRange = (cameraNode?.fov as any)?.range || 80;
+
+        // Add camera-specific context to the prompt
+        const contextPrefix = `CAMERA INFORMATION:
+- Camera Name: ${cameraName}
+- Mount Height: ${mountHeight} feet above ground
+- Approximate viewing range: ${cameraRange} feet
+
+Use the mount height to help estimate distances - objects at ground level will appear at different angles depending on distance from a camera mounted at ${mountHeight} feet.
+
+`;
+
         // Build multimodal message with provider-specific image format
         const result = await llm.getChatCompletion({
           messages: [
             {
               role: 'user',
               content: [
-                { type: 'text', text: SCENE_ANALYSIS_PROMPT },
+                { type: 'text', text: contextPrefix + SCENE_ANALYSIS_PROMPT },
                 buildImageContent(imageData, formatType),
               ],
             },
           ],
-          max_tokens: 1500,
+          max_tokens: 4000, // Increased for detailed scene analysis
           temperature: 0.3,
         });
 
@@ -403,7 +418,8 @@ export class TopologyDiscoveryEngine {
               jsonStr = jsonStr.replace(/```json?\n?/g, '').replace(/```$/g, '').trim();
             }
 
-            const parsed = JSON.parse(jsonStr);
+            // Try to recover truncated JSON
+            const parsed = this.parseJsonWithRecovery(jsonStr, cameraName);
 
             // Map parsed data to our types
             if (Array.isArray(parsed.landmarks)) {
@@ -544,6 +560,99 @@ export class TopologyDiscoveryEngine {
     return 'medium'; // Default to medium if not specified
   }
 
+  /** Try to parse JSON with recovery for truncated responses */
+  private parseJsonWithRecovery(jsonStr: string, context: string): any {
+    // First, try direct parse
+    try {
+      return JSON.parse(jsonStr);
+    } catch (e) {
+      // Log the raw response for debugging (first 500 chars)
+      this.console.log(`[Discovery] Raw LLM response for ${context} (first 500 chars): ${jsonStr.substring(0, 500)}...`);
+    }
+
+    // Try to recover truncated JSON by finding complete sections
+    try {
+      // Find where valid JSON might end (look for last complete object/array)
+      let recoveredJson = jsonStr;
+
+      // Try to close unclosed strings
+      const lastQuote = recoveredJson.lastIndexOf('"');
+      const lastColon = recoveredJson.lastIndexOf(':');
+      if (lastQuote > lastColon) {
+        // We might be in the middle of a string value
+        const beforeQuote = recoveredJson.substring(0, lastQuote);
+        const afterLastCompleteEntry = beforeQuote.lastIndexOf('},');
+        if (afterLastCompleteEntry > 0) {
+          recoveredJson = beforeQuote.substring(0, afterLastCompleteEntry + 1);
+        }
+      }
+
+      // Close any unclosed arrays/objects
+      let openBraces = (recoveredJson.match(/{/g) || []).length;
+      let closeBraces = (recoveredJson.match(/}/g) || []).length;
+      let openBrackets = (recoveredJson.match(/\[/g) || []).length;
+      let closeBrackets = (recoveredJson.match(/\]/g) || []).length;
+
+      // Add missing closing brackets/braces
+      while (closeBrackets < openBrackets) {
+        recoveredJson += ']';
+        closeBrackets++;
+      }
+      while (closeBraces < openBraces) {
+        recoveredJson += '}';
+        closeBraces++;
+      }
+
+      const recovered = JSON.parse(recoveredJson);
+      this.console.log(`[Discovery] Recovered truncated JSON for ${context}`);
+      return recovered;
+    } catch (recoveryError) {
+      // Last resort: try to extract just landmarks array
+      try {
+        const landmarksMatch = jsonStr.match(/"landmarks"\s*:\s*\[([\s\S]*?)(?:\]|$)/);
+        const zonesMatch = jsonStr.match(/"zones"\s*:\s*\[([\s\S]*?)(?:\]|$)/);
+
+        const result: any = { landmarks: [], zones: [], edges: {}, orientation: 'unknown' };
+
+        if (landmarksMatch) {
+          // Try to parse individual landmark objects
+          const landmarksStr = landmarksMatch[1];
+          const landmarkObjects = landmarksStr.match(/\{[^{}]*\}/g) || [];
+          result.landmarks = landmarkObjects.map((obj: string) => {
+            try {
+              return JSON.parse(obj);
+            } catch {
+              return null;
+            }
+          }).filter(Boolean);
+          this.console.log(`[Discovery] Extracted ${result.landmarks.length} landmarks from partial response for ${context}`);
+        }
+
+        if (zonesMatch) {
+          const zonesStr = zonesMatch[1];
+          const zoneObjects = zonesStr.match(/\{[^{}]*\}/g) || [];
+          result.zones = zoneObjects.map((obj: string) => {
+            try {
+              return JSON.parse(obj);
+            } catch {
+              return null;
+            }
+          }).filter(Boolean);
+          this.console.log(`[Discovery] Extracted ${result.zones.length} zones from partial response for ${context}`);
+        }
+
+        if (result.landmarks.length > 0 || result.zones.length > 0) {
+          return result;
+        }
+      } catch (extractError) {
+        // Give up
+      }
+
+      this.console.warn(`[Discovery] Could not recover JSON for ${context}`);
+      throw new Error(`Failed to parse LLM response: truncated or malformed JSON`);
+    }
+  }
+
   /** Resolve a camera reference (name or deviceId) to its deviceId */
   private resolveCameraRef(ref: string): string | null {
     if (!this.topology?.cameras || !ref) return null;

package/src/ui/editor-html.ts

@@ -1632,8 +1632,12 @@ export const EDITOR_HTML = `<!DOCTYPE html>
       const fov = camera.fov || { mode: 'simple', angle: 90, direction: 0, range: 80 };
       // Convert stored pixel range to feet for display
       const rangeInFeet = Math.round(pixelsToFeet(fov.range || 80));
+      // Get mount height from context or default to 8
+      const mountHeight = camera.context?.mountHeight || 8;
       panel.innerHTML = '<h3>Camera Properties</h3>' +
         '<div class="form-group"><label>Name</label><input type="text" value="' + camera.name + '" onchange="updateCameraName(\\'' + camera.deviceId + '\\', this.value)"></div>' +
+        '<div class="form-group"><label>Mount Height (feet)</label><input type="number" value="' + mountHeight + '" min="1" max="40" step="0.5" onchange="updateCameraMountHeight(\\'' + camera.deviceId + '\\', this.value)"></div>' +
+        '<div style="font-size: 11px; color: #666; margin-top: -10px; margin-bottom: 10px;">Height affects distance estimation in discovery</div>' +
         '<div class="form-group"><label class="checkbox-group"><input type="checkbox" ' + (camera.isEntryPoint ? 'checked' : '') + ' onchange="updateCameraEntry(\\'' + camera.deviceId + '\\', this.checked)">Entry Point</label></div>' +
         '<div class="form-group"><label class="checkbox-group"><input type="checkbox" ' + (camera.isExitPoint ? 'checked' : '') + ' onchange="updateCameraExit(\\'' + camera.deviceId + '\\', this.checked)">Exit Point</label></div>' +
         '<h4 style="margin-top: 15px; margin-bottom: 10px; color: #888;">Field of View</h4>' +
@@ -1652,6 +1656,12 @@ export const EDITOR_HTML = `<!DOCTYPE html>
     function updateCameraName(id, value) { const camera = topology.cameras.find(c => c.deviceId === id); if (camera) camera.name = value; updateUI(); }
     function updateCameraEntry(id, value) { const camera = topology.cameras.find(c => c.deviceId === id); if (camera) camera.isEntryPoint = value; }
     function updateCameraExit(id, value) { const camera = topology.cameras.find(c => c.deviceId === id); if (camera) camera.isExitPoint = value; }
+    function updateCameraMountHeight(id, value) {
+      const camera = topology.cameras.find(c => c.deviceId === id);
+      if (!camera) return;
+      if (!camera.context) camera.context = {};
+      camera.context.mountHeight = parseFloat(value) || 8;
+    }
     function updateCameraFov(id, field, value) {
       const camera = topology.cameras.find(c => c.deviceId === id);
       if (!camera) return;