OTVision 0.5.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

OTVision/detect/builder.py

@@ -1,16 +1,50 @@
 from argparse import ArgumentParser
 from functools import cached_property
 
+from OTVision.abstraction.observer import Subject
+from OTVision.application.buffer import Buffer
 from OTVision.application.configure_logger import ConfigureLogger
+from OTVision.application.detect.current_object_detector import CurrentObjectDetector
+from OTVision.application.detect.current_object_detector_metadata import (
+    CurrentObjectDetectorMetadata,
+)
+from OTVision.application.detect.detected_frame_factory import DetectedFrameFactory
+from OTVision.application.detect.detected_frame_producer import (
+    SimpleDetectedFrameProducer,
+)
+from OTVision.application.detect.detection_file_save_path_provider import (
+    DetectionFileSavePathProvider,
+)
+from OTVision.application.detect.factory import ObjectDetectorCachedFactory
 from OTVision.application.detect.get_detect_cli_args import GetDetectCliArgs
 from OTVision.application.detect.update_detect_config_with_cli_args import (
     UpdateDetectConfigWithCliArgs,
 )
+from OTVision.application.frame_count_provider import FrameCountProvider
 from OTVision.application.get_config import GetConfig
-from OTVision.config import ConfigParser
+from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.application.update_current_config import UpdateCurrentConfig
+from OTVision.config import Config, ConfigParser
 from OTVision.detect.cli import ArgparseDetectCliParser
+from OTVision.detect.detect import OTVisionVideoDetect
+from OTVision.detect.detected_frame_buffer import (
+    DetectedFrameBuffer,
+    DetectedFrameBufferEvent,
+    FlushEvent,
+)
 from OTVision.detect.otdet import OtdetBuilder
+from OTVision.detect.otdet_file_writer import OtdetFileWriter
+from OTVision.detect.plugin_av.rotate_frame import AvVideoFrameRotator
+from OTVision.detect.pyav_frame_count_provider import PyAVFrameCountProvider
+from OTVision.detect.timestamper import TimestamperFactory
+from OTVision.detect.video_input_source import VideoSource
+from OTVision.detect.yolo import YoloDetectionConverter, YoloFactory
 from OTVision.domain.cli import DetectCliParser
+from OTVision.domain.current_config import CurrentConfig
+from OTVision.domain.detect_producer_consumer import DetectedFrameProducer
+from OTVision.domain.detection import DetectedFrame
+from OTVision.domain.input_source_detect import InputSourceDetect
+from OTVision.domain.object_detection import ObjectDetectorFactory
 
 
 class DetectBuilder:
@@ -44,5 +78,103 @@ class DetectBuilder:
     def otdet_builder(self) -> OtdetBuilder:
         return OtdetBuilder()
 
+    @cached_property
+    def object_detector_factory(self) -> ObjectDetectorFactory:
+        return ObjectDetectorCachedFactory(
+            YoloFactory(
+                get_current_config=self.get_current_config,
+                detection_converter=self.detection_converter,
+                detected_frame_factory=self.frame_converter,
+            )
+        )
+
+    @cached_property
+    def detection_converter(self) -> YoloDetectionConverter:
+        return YoloDetectionConverter()
+
+    @cached_property
+    def frame_converter(self) -> DetectedFrameFactory:
+        return DetectedFrameFactory()
+
+    @cached_property
+    def current_config(self) -> CurrentConfig:
+        return CurrentConfig(Config())
+
+    @cached_property
+    def get_current_config(self) -> GetCurrentConfig:
+        return GetCurrentConfig(self.current_config)
+
+    @cached_property
+    def update_current_config(self) -> UpdateCurrentConfig:
+        return UpdateCurrentConfig(self.current_config)
+
     def __init__(self, argv: list[str] | None = None) -> None:
         self.argv = argv
+
+    @cached_property
+    def input_source(self) -> InputSourceDetect:
+        return VideoSource(
+            subject=Subject[FlushEvent](),
+            get_current_config=self.get_current_config,
+            frame_rotator=self.frame_rotator,
+            timestamper_factory=self.timestamper_factory,
+            save_path_provider=self.detection_file_save_path_provider,
+        )
+
+    @cached_property
+    def frame_rotator(self) -> AvVideoFrameRotator:
+        return AvVideoFrameRotator()
+
+    @cached_property
+    def timestamper_factory(self) -> TimestamperFactory:
+        return TimestamperFactory(self.frame_count_provider, self.get_current_config)
+
+    @cached_property
+    def detection_file_save_path_provider(self) -> DetectionFileSavePathProvider:
+        return DetectionFileSavePathProvider(self.get_current_config)
+
+    @cached_property
+    def frame_count_provider(self) -> FrameCountProvider:
+        return PyAVFrameCountProvider()
+
+    @cached_property
+    def otdet_file_writer(self) -> OtdetFileWriter:
+        return OtdetFileWriter(
+            builder=self.otdet_builder,
+            get_current_config=self.get_current_config,
+            current_object_detector_metadata=self.current_object_detector_metadata,
+            save_path_provider=self.detection_file_save_path_provider,
+        )
+
+    @cached_property
+    def current_object_detector_metadata(self) -> CurrentObjectDetectorMetadata:
+        return CurrentObjectDetectorMetadata(self.current_object_detector)
+
+    @cached_property
+    def current_object_detector(self) -> CurrentObjectDetector:
+        return CurrentObjectDetector(
+            get_current_config=self.get_current_config,
+            factory=self.object_detector_factory,
+        )
+
+    @cached_property
+    def detected_frame_buffer(
+        self,
+    ) -> Buffer[DetectedFrame, DetectedFrameBufferEvent, FlushEvent]:
+        return DetectedFrameBuffer(subject=Subject[DetectedFrameBufferEvent]())
+
+    @cached_property
+    def detected_frame_producer(self) -> DetectedFrameProducer:
+        return SimpleDetectedFrameProducer(
+            input_source=self.input_source,
+            detection_filter=self.current_object_detector,
+            detected_frame_buffer=self.detected_frame_buffer,
+        )
+
+    def build(self) -> OTVisionVideoDetect:
+        self.register_observers()
+        return OTVisionVideoDetect(self.detected_frame_producer)
+
+    def register_observers(self) -> None:
+        self.input_source.register(self.detected_frame_buffer.on_flush)
+        self.detected_frame_buffer.register(self.otdet_file_writer.write)

OTVision/detect/cli.py

@@ -1,7 +1,8 @@
 from argparse import ArgumentParser, BooleanOptionalAction, Namespace
-from datetime import timedelta
+from datetime import datetime, timedelta
 from pathlib import Path
 
+from OTVision.config import DATETIME_FORMAT
 from OTVision.domain.cli import CliParseError, DetectCliArgs, DetectCliParser
 from OTVision.helpers.files import check_if_all_paths_exist
 from OTVision.helpers.log import DEFAULT_LOG_FILE, VALID_LOG_LEVELS
@@ -105,6 +106,14 @@ class ArgparseDetectCliParser(DetectCliParser):
             help="Overwrite log file if it already exists.",
             required=False,
         )
+        self._parser.add_argument(
+            "--start-time",
+            default=None,
+            type=str,
+            help="Specify start date and time of the recording in format "
+            "YYYY-MM-DD_HH-MM-SS",
+            required=False,
+        )
         self._parser.add_argument(
             "--detect-start",
             default=None,
@@ -138,6 +147,7 @@ class ArgparseDetectCliParser(DetectCliParser):
             ),
             half=bool(args.half) if args.half else None,
             overwrite=args.overwrite,
+            start_time=self._parse_start_time(args.start_time),
             detect_start=(
                 int(args.detect_start) if args.detect_start is not None else None
             ),
@@ -148,6 +158,11 @@ class ArgparseDetectCliParser(DetectCliParser):
             logfile_overwrite=args.logfile_overwrite,
         )
 
+    def _parse_start_time(self, start_time: str | None) -> datetime | None:
+        if start_time is None:
+            return None
+        return datetime.strptime(start_time, DATETIME_FORMAT)
+
     def __assert_cli_args_valid(self, args: Namespace) -> None:
         if args.paths is None and args.config is None:
             raise CliParseError(

OTVision/detect/detect.py

@@ -19,290 +19,21 @@ OTVision main module to detect objects in single or multiple images or videos.
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-import logging
-import re
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
 
-from tqdm import tqdm
-
-from OTVision.config import Config
-from OTVision.dataformat import DATA, LENGTH, METADATA, RECORDED_START_DATE, VIDEO
-from OTVision.detect.otdet import OtdetBuilder, OtdetBuilderConfig
-from OTVision.detect.yolo import create_model
-from OTVision.helpers.date import parse_date_string_to_utc_datime
-from OTVision.helpers.files import (
-    FILE_NAME_PATTERN,
-    START_DATE,
-    InproperFormattedFilename,
-    get_files,
-    write_json,
+from OTVision.domain.detect_producer_consumer import (
+    DetectedFrameConsumer,
+    DetectedFrameProducer,
 )
-from OTVision.helpers.log import LOGGER_NAME
-from OTVision.helpers.video import get_duration, get_fps, get_video_dimensions
-from OTVision.track.preprocess import OCCURRENCE
-
-log = logging.getLogger(LOGGER_NAME)
-DATETIME_FORMAT = "%Y-%m-%d_%H-%M-%S"
-
 
-class OTVisionDetect:
-    @property
-    def config(self) -> Config:
-        if self._config is None:
-            raise ValueError("Config is missing!")
-        return self._config
 
-    def __init__(self, otdet_builder: OtdetBuilder) -> None:
-        self._config: Config | None = None
-        self._otdet_builder = otdet_builder
-
-    def update_config(self, config: Config) -> None:
-        self._config = config
+class OTVisionVideoDetect(DetectedFrameConsumer):
+    def __init__(self, producer: DetectedFrameProducer) -> None:
+        self._producer = producer
 
     def start(self) -> None:
-        """Starts the detection of objects in multiple videos and/or images.
-
-        Writes detections to one file per video/object.
-
-        """
-        filetypes = self.config.filetypes.video_filetypes.to_list()
-        video_files = get_files(paths=self.config.detect.paths, filetypes=filetypes)
-
-        start_msg = f"Start detection of {len(video_files)} video files"
-        log.info(start_msg)
-        print(start_msg)
-
-        if not video_files:
-            log.warning(f"No videos of type '{filetypes}' found to detect!")
-            return
-
-        model = create_model(
-            weights=self.config.detect.yolo_config.weights,
-            confidence=self.config.detect.yolo_config.conf,
-            iou=self.config.detect.yolo_config.iou,
-            img_size=self.config.detect.yolo_config.img_size,
-            half_precision=self.config.detect.half_precision,
-            normalized=self.config.detect.yolo_config.normalized,
-        )
-        for video_file in tqdm(video_files, desc="Detected video files", unit=" files"):
-            detections_file = derive_filename(
-                video_file=video_file,
-                detect_start=self.config.detect.detect_start,
-                detect_end=self.config.detect.detect_end,
-                detect_suffix=self.config.filetypes.detect,
-            )
-
-            try:
-                parse_start_time_from(video_file)
-            except InproperFormattedFilename:
-                log.warning(
-                    f"Video file name of '{video_file}' must include date "
-                    f"and time in format: {DATETIME_FORMAT}"
-                )
-                continue
-
-            if not self.config.detect.overwrite and detections_file.is_file():
-                log.warning(
-                    f"{detections_file} already exists. To overwrite, set overwrite "
-                    "to True"
-                )
-                continue
-
-            log.info(f"Detect {video_file}")
-
-            video_fps = get_fps(video_file)
-            detect_start_in_frames = convert_seconds_to_frames(
-                self.config.detect.detect_start, video_fps
-            )
-            detect_end_in_frames = convert_seconds_to_frames(
-                self.config.detect.detect_end, video_fps
-            )
-            detections = model.detect(
-                file=video_file,
-                detect_start=detect_start_in_frames,
-                detect_end=detect_end_in_frames,
-            )
-
-            video_width, video_height = get_video_dimensions(video_file)
-            actual_duration = get_duration(video_file)
-            actual_frames = len(detections)
-            if (expected_duration := self.config.detect.expected_duration) is not None:
-                actual_fps = actual_frames / expected_duration.total_seconds()
-            else:
-                actual_fps = actual_frames / actual_duration.total_seconds()
-            otdet = self._otdet_builder.add_config(
-                OtdetBuilderConfig(
-                    conf=model.confidence,
-                    iou=model.iou,
-                    video=video_file,
-                    video_width=video_width,
-                    video_height=video_height,
-                    expected_duration=expected_duration,
-                    recorded_fps=video_fps,
-                    actual_fps=actual_fps,
-                    actual_frames=actual_frames,
-                    detection_img_size=model.img_size,
-                    normalized=model.normalized,
-                    detection_model=model.weights,
-                    half_precision=model.half_precision,
-                    chunksize=1,
-                    classifications=model.classifications,
-                    detect_start=self.config.detect.detect_start,
-                    detect_end=self.config.detect.detect_end,
-                )
-            ).build(detections)
-
-            stamped_detections = add_timestamps(otdet, video_file, expected_duration)
-            write_json(
-                stamped_detections,
-                file=detections_file,
-                filetype=self.config.filetypes.detect,
-                overwrite=self.config.detect.overwrite,
-            )
-
-            log.info(f"Successfully detected and wrote {detections_file}")
-
-        finished_msg = "Finished detection"
-        log.info(finished_msg)
-        print(finished_msg)
-
-
-def derive_filename(
-    video_file: Path,
-    detect_suffix: str,
-    detect_start: int | None = None,
-    detect_end: int | None = None,
-) -> Path:
-    """
-    Generates a filename for detection files by appending specified start and end
-    markers and a suffix to the stem of the input video file.
-
-    Args:
-        video_file (Path): The input video file whose filename is to be modified.
-        detect_start (int | None): The starting marker to append to the filename.
-            If None, no starting marker will be appended.
-        detect_end (int | None): The ending marker to append to the filename. If None,
-            no ending marker will be appended.
-        detect_suffix (str): The file suffix to apply to the derived filename.
-
-    Returns:
-        Path: The modified video file path with the updated stem and suffix applied.
-    """
-    cutout = ""
-    if detect_start is not None:
-        cutout += f"_start_{detect_start}"
-    if detect_end is not None:
-        cutout += f"_end_{detect_end}"
-    new_stem = f"{video_file.stem}{cutout}"
-    return video_file.with_stem(new_stem).with_suffix(detect_suffix)
-
-
-def convert_seconds_to_frames(seconds: int | None, fps: float) -> int | None:
-    if seconds is None:
-        return None
-    return round(seconds * fps)
-
-
-class FormatNotSupportedError(Exception):
-    pass
-
-
-def add_timestamps(
-    detections: dict, video_file: Path, expected_duration: timedelta | None
-) -> dict:
-    return Timestamper().stamp(detections, video_file, expected_duration)
-
-
-class Timestamper:
-    def stamp(
-        self, detections: dict, video_file: Path, expected_duration: timedelta | None
-    ) -> dict:
-        """This method adds timestamps when the frame occurred in real time to each
-        frame.
-
-        Args:
-            detections (dict): dictionary containing all frames
-            video_file (Path): path to video file
-            expected_duration (timedelta | None): expected duration of the video used to
-                calculate the number of actual frames per second
-
-        Returns:
-            dict: input dictionary with additional occurrence per frame
-        """
-        start_time = parse_start_time_from(video_file)
-        actual_duration = get_duration(video_file)
-        if expected_duration:
-            time_per_frame = self._get_time_per_frame(detections, expected_duration)
-        else:
-            time_per_frame = self._get_time_per_frame(detections, actual_duration)
-        self._update_metadata(detections, start_time, actual_duration)
-        return self._stamp(detections, start_time, time_per_frame)
-
-    @staticmethod
-    def _get_time_per_frame(detections: dict, duration: timedelta) -> timedelta:
-        """Calculates the duration for each frame. This is done using the total
-        duration of the video and the number of frames.
-
-        Args:
-            detections (dict): dictionary containing all frames
-            video_file (Path): path to video file
-
-        Returns:
-            timedelta: duration per frame
-        """
-        number_of_frames = len(detections[DATA].keys())
-        return duration / number_of_frames
-
-    @staticmethod
-    def _update_metadata(
-        detections: dict, start_time: datetime, duration: timedelta
-    ) -> dict:
-        detections[METADATA][VIDEO][RECORDED_START_DATE] = start_time.timestamp()
-        detections[METADATA][VIDEO][LENGTH] = str(duration)
-        return detections
-
-    def _stamp(
-        self, detections: dict, start_date: datetime, time_per_frame: timedelta
-    ) -> dict:
-        """Add a timestamp (occurrence in real time) to each frame.
-
-        Args:
-            detections (dict): dictionary containing all frames
-            start_date (datetime): start date of the video recording
-            time_per_frame (timedelta): duration per frame
-
-        Returns:
-            dict: dictionary containing all frames with their occurrence in real time
-        """
-        data: dict = detections[DATA]
-        for key, value in data.items():
-            occurrence = start_date + (int(key) - 1) * time_per_frame
-            value[OCCURRENCE] = occurrence.timestamp()
-        return detections
-
-
-def parse_start_time_from(video_file: Path) -> datetime:
-    """Parse the given filename and retrieve the start date of the video.
-
-    Args:
-        video_file (Path): path to video file
-
-    Raises:
-        InproperFormattedFilename: if the filename is not formatted as expected, an
-        exception will be raised
-
-    Returns:
-        datetime: start date of the video
-    """
-    match = re.search(
-        FILE_NAME_PATTERN,
-        video_file.name,
-    )
-    if match:
-        start_date: str = match.group(START_DATE)
-        return parse_date_string_to_utc_datime(start_date, "%Y-%m-%d_%H-%M-%S").replace(
-            tzinfo=timezone.utc
-        )
+        """Starts the detection of objects in multiple videos and/or images."""
+        self.consume()
 
-    raise InproperFormattedFilename(f"Could not parse {video_file.name}.")
+    def consume(self) -> None:
+        for _ in self._producer.produce():
+            pass

OTVision/detect/detected_frame_buffer.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+
+from OTVision.application.buffer import Buffer
+from OTVision.domain.detection import DetectedFrame
+
+
+@dataclass
+class SourceMetadata:
+    source: str
+    duration: timedelta
+    height: int
+    width: int
+    fps: float
+    start_time: datetime
+
+
+@dataclass
+class FlushEvent:
+    source_metadata: SourceMetadata
+
+    @staticmethod
+    def create(
+        source: str,
+        duration: timedelta,
+        source_height: int,
+        source_width: int,
+        source_fps: float,
+        start_time: datetime,
+    ) -> "FlushEvent":
+        return FlushEvent(
+            SourceMetadata(
+                source,
+                duration,
+                source_height,
+                source_width,
+                source_fps,
+                start_time=start_time,
+            )
+        )
+
+
+@dataclass
+class DetectedFrameBufferEvent:
+    source_metadata: SourceMetadata
+    frames: list[DetectedFrame]
+
+
+class DetectedFrameBuffer(Buffer[DetectedFrame, DetectedFrameBufferEvent, FlushEvent]):
+    def _notify_observers(
+        self, elements: list[DetectedFrame], event: FlushEvent
+    ) -> None:
+        self._subject.notify(
+            DetectedFrameBufferEvent(
+                source_metadata=event.source_metadata, frames=elements
+            )
+        )

OTVision/detect/otdet.py

@@ -1,21 +1,23 @@
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Self
 
 from OTVision import dataformat, version
-from OTVision.track.preprocess import Detection
+from OTVision.domain.detection import DetectedFrame, Detection
 
 
 @dataclass
 class OtdetBuilderConfig:
     conf: float
     iou: float
-    video: Path
+    source: str
     video_width: int
     video_height: int
     expected_duration: timedelta | None
+    actual_duration: timedelta
     recorded_fps: float
+    recorded_start_date: datetime
     actual_fps: float
     actual_frames: int
     detection_img_size: int
@@ -50,37 +52,56 @@ class OtdetBuilder:
         self._config = None
         return self
 
-    def build(self, detections: list[list[Detection]]) -> dict:
+    def build(self, detections: list[DetectedFrame]) -> dict:
+        number_of_frames = len(detections)
         result = {
-            dataformat.METADATA: self._build_metadata(),
+            dataformat.METADATA: self._build_metadata(number_of_frames),
             dataformat.DATA: self._build_data(detections),
         }
         self.reset()
         return result
 
-    def _build_metadata(self) -> dict:
+    def _build_metadata(self, number_of_frames: int) -> dict:
         return {
             dataformat.OTDET_VERSION: version.otdet_version(),
-            dataformat.VIDEO: self._build_video_config(),
+            dataformat.VIDEO: self._build_video_config(number_of_frames),
             dataformat.DETECTION: self._build_detection_config(),
         }
 
-    def _build_data(self, frames: list[list[Detection]]) -> dict:
+    def _build_data(self, frames: list[DetectedFrame]) -> dict:
         data = {}
-        for frame, detections in enumerate(frames, start=1):
-            converted_detections = [detection.to_otdet() for detection in detections]
-            data[str(frame)] = {dataformat.DETECTIONS: converted_detections}
+        for frame in frames:
+            converted_detections = [
+                self.__convert_detection(detection) for detection in frame.detections
+            ]
+            data[str(frame.frame_number)] = {
+                dataformat.DETECTIONS: converted_detections,
+                dataformat.OCCURRENCE: frame.occurrence.timestamp(),
+            }
         return data
 
-    def _build_video_config(self) -> dict:
+    def __convert_detection(self, detection: Detection) -> dict:
+        return {
+            dataformat.CLASS: detection.label,
+            dataformat.CONFIDENCE: detection.conf,
+            dataformat.X: detection.x,
+            dataformat.Y: detection.y,
+            dataformat.W: detection.w,
+            dataformat.H: detection.h,
+        }
+
+    def _build_video_config(self, number_of_frames: int) -> dict:
+        source = Path(self.config.source)
         video_config = {
-            dataformat.FILENAME: str(self.config.video.stem),
-            dataformat.FILETYPE: str(self.config.video.suffix),
+            dataformat.FILENAME: str(source.stem),
+            dataformat.FILETYPE: str(source.suffix),
             dataformat.WIDTH: self.config.video_width,
             dataformat.HEIGHT: self.config.video_height,
             dataformat.RECORDED_FPS: self.config.recorded_fps,
             dataformat.ACTUAL_FPS: self.config.actual_fps,
-            dataformat.NUMBER_OF_FRAMES: self.config.actual_frames,
+            dataformat.NUMBER_OF_FRAMES: number_of_frames,
+            dataformat.RECORDED_START_DATE: self.config.recorded_start_date.timestamp(),
+            dataformat.LENGTH: str(self.config.actual_duration),
         }
         if self.config.expected_duration is not None:
             video_config[dataformat.EXPECTED_DURATION] = int(