Improve motion review and add motion search (#22253)

* implement motion search and motion previews

* tweaks

* fix merge issue

* fix copilot instructions

frigate/record/maintainer.py

@@ -50,11 +50,13 @@ class SegmentInfo:
         active_object_count: int,
         region_count: int,
         average_dBFS: int,
+        motion_heatmap: dict[str, int] | None = None,
     ) -> None:
         self.motion_count = motion_count
         self.active_object_count = active_object_count
         self.region_count = region_count
         self.average_dBFS = average_dBFS
+        self.motion_heatmap = motion_heatmap
 
     def should_discard_segment(self, retain_mode: RetainModeEnum) -> bool:
         keep = False
@@ -454,6 +456,59 @@ class RecordingMaintainer(threading.Thread):
             if end_time < retain_cutoff:
                 self.drop_segment(cache_path)
 
+    def _compute_motion_heatmap(
+        self, camera: str, motion_boxes: list[tuple[int, int, int, int]]
+    ) -> dict[str, int] | None:
+        """Compute a 16x16 motion intensity heatmap from motion boxes.
+
+        Returns a sparse dict mapping cell index (as string) to intensity (1-255).
+        Only cells with motion are included.
+
+        Args:
+            camera: Camera name to get detect dimensions from.
+            motion_boxes: List of (x1, y1, x2, y2) pixel coordinates.
+
+        Returns:
+            Sparse dict like {"45": 3, "46": 5}, or None if no boxes.
+        """
+        if not motion_boxes:
+            return None
+
+        camera_config = self.config.cameras.get(camera)
+        if not camera_config:
+            return None
+
+        frame_width = camera_config.detect.width
+        frame_height = camera_config.detect.height
+
+        if frame_width <= 0 or frame_height <= 0:
+            return None
+
+        GRID_SIZE = 16
+        counts: dict[int, int] = {}
+
+        for box in motion_boxes:
+            if len(box) < 4:
+                continue
+            x1, y1, x2, y2 = box
+
+            # Convert pixel coordinates to grid cells
+            grid_x1 = max(0, int((x1 / frame_width) * GRID_SIZE))
+            grid_y1 = max(0, int((y1 / frame_height) * GRID_SIZE))
+            grid_x2 = min(GRID_SIZE - 1, int((x2 / frame_width) * GRID_SIZE))
+            grid_y2 = min(GRID_SIZE - 1, int((y2 / frame_height) * GRID_SIZE))
+
+            for y in range(grid_y1, grid_y2 + 1):
+                for x in range(grid_x1, grid_x2 + 1):
+                    idx = y * GRID_SIZE + x
+                    counts[idx] = min(255, counts.get(idx, 0) + 1)
+
+        if not counts:
+            return None
+
+        # Convert to string keys for JSON storage
+        return {str(k): v for k, v in counts.items()}
+
     def segment_stats(
         self, camera: str, start_time: datetime.datetime, end_time: datetime.datetime
     ) -> SegmentInfo:
@@ -461,6 +516,8 @@ class RecordingMaintainer(threading.Thread):
         active_count = 0
         region_count = 0
         motion_count = 0
+        all_motion_boxes: list[tuple[int, int, int, int]] = []
+
         for frame in self.object_recordings_info[camera]:
             # frame is after end time of segment
             if frame[0] > end_time.timestamp():
@@ -479,6 +536,8 @@ class RecordingMaintainer(threading.Thread):
             )
             motion_count += len(frame[2])
             region_count += len(frame[3])
+            # Collect motion boxes for heatmap computation
+            all_motion_boxes.extend(frame[2])
 
         audio_values = []
         for frame in self.audio_recordings_info[camera]:
@@ -498,8 +557,14 @@ class RecordingMaintainer(threading.Thread):
 
         average_dBFS = 0 if not audio_values else np.average(audio_values)
 
+        motion_heatmap = self._compute_motion_heatmap(camera, all_motion_boxes)
+
         return SegmentInfo(
-            motion_count, active_count, region_count, round(average_dBFS)
+            motion_count,
+            active_count,
+            region_count,
+            round(average_dBFS),
+            motion_heatmap,
         )
 
     async def move_segment(
@@ -590,6 +655,7 @@ class RecordingMaintainer(threading.Thread):
                     Recordings.regions.name: segment_info.region_count,
                     Recordings.dBFS.name: segment_info.average_dBFS,
                     Recordings.segment_size.name: segment_size,
+                    Recordings.motion_heatmap.name: segment_info.motion_heatmap,
                 }
         except Exception as e:
             logger.error(f"Unable to store recording segment {cache_path}")