Merge pull request #1 from SpaceTime-Vision-Robotics-Laboratory/sebnae/streaming_mods

[PR] Streaming mode

Author: brittleru

README.md

@@ -1 +1,39 @@
-# Drone Base
+# Drone Base Framework
+
+A modular base framework for building drone control systems using Anafi Parrot drones.
+
+It is designed to be used as a git submodule in drone software projects.
+
+### Features
+- Abstraction over drone states, control and streaming.
+- Extensible for integrating custom modules
+- Lightweight and focused on real-time.
+
+### Submodule Installation
+To include this framework in your project:
+```bash
+git submodule add [email protected]:SpaceTime-Vision-Robotics-Laboratory/drone-base.git
+git submodule update --init --recursive
+```
+
+To clone a project that already includes this as a submodule:
+```bash
+git clone --recurse-submodules <LINK TO YOUR PROJECT>
+```
+
+### Setup as standalone
+Install the packages from the [requirements.txt](requirements.txt).
+
+
+### Examples
+Run the example [controller](examples/display_only_controller.py) that only displays the video stream from the drone and has keyboard control.
+```bash
+python -m examples.display_only_controller
+```
+
+Run the [video to frame](main/stream/saving/frames_to_video.py) to create a video from the frames generated
+from the video stream of a mission:
+```bash
+python -m main.stream.saving.frames_to_video
+```
+

main/basic_file.py

@@ -1,12 +1,14 @@
 class VideoConfig:
     """Configuration class for the drone video stream with validation"""
 
-    def __init__(self, width: int = 640, height: int = 360):
+    def __init__(self, width: int = 640, height: int = 360, cam_mode: str | None = None):
         """
         Sets the width and height of the video stream. Computes the center of the frame.
 
-        @param width: Width of the video stream in pixels, by default 640 (half of the PDRAW stream)
-        @param height: Height of the video stream in pixels, by default 360 (half of the PDRAW stream)
+        :param width: Width of the video stream in pixels, by default 640 (half of the PDRAW stream)
+        :param height: Height of the video stream in pixels, by default 360 (half of the PDRAW stream)
+        :param cam_mode: Camera mode to use, either "photo" or "recording" or default None.
+                          Photo mode has a stream for 1024x768. Recording mode is the default and it's 1280x720.
         """
         if width <= 0 or height <= 0:
             raise ValueError("Video width and height must be greater than zero.")
@@ -17,6 +19,14 @@ def __init__(self, width: int = 640, height: int = 360):
         self.frame_area = self.__compute_frame_area()
         self.max_queue_size = 30
 
+        if cam_mode not in ("photo", "recording", None):
+            raise ValueError(
+                f"Invalid camera mode for: \"{cam_mode}\". "
+                f"Possible values are \"photo\", \"recording\" or default None."
+            )
+
+        self.cam_mode = cam_mode
+
     def __compute_frame_center(self) -> tuple[int, int]:
         return self.width // 2, self.height // 2
 
@@ -41,3 +51,4 @@ def update_dimensions(self, width: int, height: int):
     print(f"Width: {v.width}, Height: {v.height}")
     print(f"Frame center: {v.frame_center_x}, Frame center: {v.frame_center_y}")
     print(f"Frame area: {v.frame_area}")
+    print(f"Camera mode: {v.cam_mode}")

main/config/video.py

@@ -1,11 +1,12 @@
 from pathlib import Path
 from typing import Final
 
-from main.control.manual.operations import DroneCommand, MovementVector
 from pynput.keyboard import KeyCode, Listener
+
 from main.config.drone import DroneSpeed, GimbalType
 from main.config.logger import LoggerSetup
 from main.control.drone_commander import DroneCommander
+from main.control.manual.operations import DroneCommand, MovementVector
 
 
 class KeyboardController:

main/control/manual/keyboard_controller.py

@@ -35,7 +35,7 @@ def __init__(
             log_path = Path(log_path) / self.start_time
         if results_path is not None:
             results_path = Path(results_path) / self.start_time
-        self.video_config = VideoConfig(width=640, height=360)
+        self.video_config = VideoConfig(width=640, height=360, cam_mode="photo")
 
         self.drone = olympe.Drone(ip)
         self.drone_commander = DroneCommander(self.drone, logger_dir=log_path)

main/stream/base_streaming_controller.py

@@ -81,7 +81,7 @@ def _run_processing_loop(self):
         with self._frame_display_context():
             while self._running.is_set() and threading.main_thread().is_alive():
                 try:
-                    frame = self.frame_queue.get_nowait()
+                    frame = self.frame_queue.get(timeout=0.1)
                     with self._lock:
                         self._frame_count += 1
                         if self.is_frame_saved:

main/stream/base_video_processor.py

@@ -70,20 +70,32 @@ def __analyze_frame_timing(self):
         self.logger.info("Average time between frames: %.3f s (%.2f fps)", avg_diff, 1 / avg_diff)
         self.logger.info("Median time between frames: %.3f s (%.2f fps)", median_diff, 1 / median_diff)
         self.logger.info("Standard deviation: %.3f s", std_diff)
-        self.logger.info("Min time between frames: %.3f s (%.2f fps)", min_diff, 1 / min_diff)
-        self.logger.info("Max time between frames: %.3f s (%.2f fps)", max_diff, 1 / max_diff)
+        try:
+            self.logger.info("Min time between frames: %.3f s (%.2f fps)", min_diff, 1 / min_diff)
+            self.logger.info("Max time between frames: %.3f s (%.2f fps)", max_diff, 1 / max_diff)
+        except ZeroDivisionError:
+            self.logger.info("Division by zero, skipping min and max fps calculation.")
 
         self.logger.info("Frame timing distribution:")
         for range_key, count in sorted(ranges.items()):
             percentage = (count / len(time_diffs)) * 100
-            self.logger.info("%s ms: %s frames (%s.1f %)", range_key, count, percentage)
-
-        return {
-            'avg_fps': 1 / avg_diff,
-            'min_fps': 1 / max_diff,
-            'max_fps': 1 / min_diff,
-            'std_dev': std_diff
-        }
+            self.logger.info("%s ms: %s frames (%.1f %%)", range_key, count, percentage)
+
+        try:
+            return {
+                'avg_fps': 1 / avg_diff,
+                'min_fps': 1 / max_diff,
+                'max_fps': 1 / min_diff,
+                'std_dev': std_diff
+            }
+        except ZeroDivisionError:
+            self.logger.info("Division by zero, skipping fps calculation.")
+            return {
+                'avg_fps': 0,
+                'min_fps': 0,
+                'max_fps': 0,
+                'std_dev': 0
+            }
 
     def create_video(self):
         self.__populate_frame_paths()
@@ -125,8 +137,21 @@ def create_video(input_dir: str | Path, output_path: str | Path = "output.mp4",
 
 
 if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Create a video from a frame folder.")
+    parser.add_argument(
+        "--input_dir",
+        default="./examples/results/2025-04-01_12-54-59/frames",
+        type=str,
+        help="Path to the input directory containing frames"
+    )
+    parser.add_argument("--output_path", default="./output.mp4", type=str, help="Path to save the output video")
+    parser.add_argument("--frame_type", default="png", type=str, help="Frame type (e.g., png, jpg)")
+    args = parser.parse_args()
+
     create_video(
-        input_dir="example/path/to/input/dir",
-        output_path="output.mp4",
-        frame_type="jpg"
+        input_dir=args.input_dir,
+        output_path=args.output_path,
+        frame_type=args.frame_type
     )

main/stream/saving/frames_to_video.py

@@ -7,6 +7,7 @@
 import numpy as np
 import olympe
 from olympe import PdrawRenderer
+from olympe.messages import camera
 
 from main.config.logger import LoggerSetup
 from main.config.video import VideoConfig
@@ -61,6 +62,10 @@ def start_streaming(self):
         )
         self.logger.info("Starting streaming...")
         self.drone.streaming.start()
+
+        if self.config.cam_mode in ("photo", "recording"):
+            self.drone(camera.set_camera_mode(cam_id=0, value=self.config.cam_mode))
+
         self.is_streaming = True
         if self.is_renderer_started:
             self.renderer = PdrawRenderer(pdraw=self.drone.streaming)