[issue/1002] Fix and enhance singleton sensor tagging with cache persistence

controller/src/controller/cache_manager.py

@@ -60,7 +60,33 @@ def refreshScenes(self):
 
       uid = scene_data['uid']
       if uid not in self.cached_scenes_by_uid:
+        # Creating new scene - check if there was an old scene with sensor cache
+        old_scene = self._old_scene_cache.get(uid) if hasattr(self, '_old_scene_cache') and self._old_scene_cache else None
         scene = Scene.deserialize(scene_data)
+
+        # Restore sensor cache from old scene if it existed (after scene invalidation/recreation)
+        # Note: Sensors without cached values (never received data) will naturally skip restoration
+        # since hasattr checks will return False
+        if old_scene and hasattr(old_scene, 'sensors'):
+          restored_count = 0
+          for sensor_id, old_sensor in old_scene.sensors.items():
+            if sensor_id in scene.sensors:
+              new_sensor = scene.sensors[sensor_id]
+              # Preserve sensor cache values if they exist
+              restored = False
+              if hasattr(old_sensor, 'value'):
+                new_sensor.value = old_sensor.value
+                restored = True
+              if hasattr(old_sensor, 'lastValue'):
+                new_sensor.lastValue = old_sensor.lastValue
+                restored = True
+              if hasattr(old_sensor, 'lastWhen'):
+                new_sensor.lastWhen = old_sensor.lastWhen
+                restored = True
+              if restored:
+                restored_count += 1
+          if restored_count > 0:
+            log.debug(f"Restored sensor cache for {restored_count} sensor(s) in scene {uid}")
       else:
         scene = self.cached_scenes_by_uid[uid]
         scene.updateScene(scene_data)
@@ -70,6 +96,11 @@ def refreshScenes(self):
       for sensorID in scene.sensors.keys():
         self._cached_scenes_by_sensorID[sensorID] = scene
       self.cached_scenes_by_uid[scene.uid] = scene
+
+    # Clear old scene cache after processing all scenes
+    if hasattr(self, '_old_scene_cache'):
+      self._old_scene_cache = None
+
     self._cache_refreshed = get_epoch_time()
     return
 
@@ -185,6 +216,8 @@ def sceneWithRemoteChildID(self, childID):
     return self.cached_child_transforms_by_uid.get(childID, None)
 
   def invalidate(self):
+    # Preserve old scene cache for sensor value restoration
+    self._old_scene_cache = self.cached_scenes_by_uid if hasattr(self, 'cached_scenes_by_uid') else {}
     self.cached_scenes_by_uid = None
     if not hasattr(self, 'cached_child_transforms_by_uid') or self.cached_child_transforms_by_uid is None:
       self.cached_child_transforms_by_uid = {}

controller/src/controller/detections_builder.py

@@ -9,21 +9,21 @@
 from scene_common.timestamp import get_iso_time
 
 
-def buildDetectionsDict(objects, scene):
+def buildDetectionsDict(objects, scene, include_sensors=False):
   result_dict = {}
   for obj in objects:
-    obj_dict = prepareObjDict(scene, obj, False)
+    obj_dict = prepareObjDict(scene, obj, False, include_sensors)
     result_dict[obj_dict['id']] = obj_dict
   return result_dict
 
-def buildDetectionsList(objects, scene, update_visibility=False):
+def buildDetectionsList(objects, scene, update_visibility=False, include_sensors=False):
   result_list = []
   for obj in objects:
-    obj_dict = prepareObjDict(scene, obj, update_visibility)
+    obj_dict = prepareObjDict(scene, obj, update_visibility, include_sensors)
     result_list.append(obj_dict)
   return result_list
 
-def prepareObjDict(scene, obj, update_visibility):
+def prepareObjDict(scene, obj, update_visibility, include_sensors=False):
   aobj = obj
   if isinstance(obj, TripwireEvent):
     aobj = obj.object
@@ -71,8 +71,38 @@ def prepareObjDict(scene, obj, update_visibility):
   chain_data = aobj.chain_data
   if len(chain_data.regions):
     obj_dict['regions'] = chain_data.regions
-  if len(chain_data.sensors):
-    obj_dict['sensors'] = chain_data.sensors
+
+  # Build sensor output from new structure (only if include_sensors is True)
+  if include_sensors:
+    sensors_output = {}
+
+    # Environmental sensors: readings + exposure as structured object
+    for sensor_id, state in chain_data.env_sensor_state.items():
+      values = state['readings'] if 'readings' in state and state['readings'] else []
+
+      # Calculate total exposure (including current value if present)
+      exposure_total = state['exposure']['total']
+      if state['exposure']['last_value'] is not None and hasattr(scene, 'when'):
+        # Add exposure from last reading to now; clamp negative intervals to zero
+        dt = scene.when - state['exposure']['last_time']
+        if dt > 0:
+          exposure_total += state['exposure']['last_value'] * dt
+
+      sensors_output[sensor_id] = {
+        'values': values,
+        'exposure': exposure_total
+      }
+
+    # Attribute sensors: events as structured object
+    for sensor_id, events in chain_data.attr_sensor_events.items():
+      if events:
+        sensors_output[sensor_id] = {
+          'values': events
+        }
+
+    if sensors_output:
+      obj_dict['sensors'] = sensors_output
+
   if hasattr(aobj, 'confidence'):
     obj_dict['confidence'] = aobj.confidence
   if hasattr(aobj, 'similarity'):

controller/src/controller/moving_object.py

@@ -5,7 +5,7 @@
 import datetime
 import struct
 import warnings
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from threading import Lock
 from typing import Dict, List
 
@@ -30,8 +30,10 @@
 class ChainData:
   regions: Dict
   publishedLocations: List[Point]
-  sensors: Dict
   persist: Dict
+  active_sensors: set = field(default_factory=set)
+  env_sensor_state: Dict = field(default_factory=dict)  # {'sensor_id': {'last_reading': (ts, val), 'exposure': {...}}}
+  attr_sensor_events: Dict = field(default_factory=dict)  # {'sensor_id': [(ts, val), ...]}
 
 class Chronoloc:
   def __init__(self, point: Point, when: datetime, bounds: Rectangle):
@@ -125,7 +127,7 @@ def _decodeReIDVector(self, reid):
 
   def setPersistentAttributes(self, info, persist_attributes):
     if self.chain_data is None:
-      self.chain_data = ChainData(regions={}, publishedLocations=[], sensors={}, persist={})
+      self.chain_data = ChainData(regions={}, publishedLocations=[], persist={})
     for attribute in persist_attributes:
       attr, sub_attrs = (list(attribute.items())[0] if isinstance(attribute, dict) else (attribute, None))
       if attr in info:
@@ -141,7 +143,7 @@ def setPersistentAttributes(self, info, persist_attributes):
 
   def setGID(self, gid):
     if self.chain_data is None:
-      self.chain_data = ChainData(regions={}, publishedLocations=[], sensors={}, persist={})
+      self.chain_data = ChainData(regions={}, publishedLocations=[], persist={})
     self.gid = gid
     self.first_seen = self.when
     return