OTVision 0.6.7__py3-none-any.whl → 0.6.9__py3-none-any.whl

OTVision/detect/builder.py

@@ -3,8 +3,7 @@ from argparse import ArgumentParser
 from functools import cached_property
 
 from OTVision.abstraction.observer import Subject
-from OTVision.application.buffer import Buffer
-from OTVision.application.config import Config
+from OTVision.application.config import Config, DetectConfig
 from OTVision.application.config_parser import ConfigParser
 from OTVision.application.configure_logger import ConfigureLogger
 from OTVision.application.detect.current_object_detector import CurrentObjectDetector
@@ -12,12 +11,6 @@ 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 (
@@ -26,16 +19,20 @@ from OTVision.application.detect.update_detect_config_with_cli_args import (
 from OTVision.application.frame_count_provider import FrameCountProvider
 from OTVision.application.get_config import GetConfig
 from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.application.otvision_save_path_provider import OtvisionSavePathProvider
 from OTVision.application.update_current_config import UpdateCurrentConfig
 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.detected_frame_producer import (
+    DetectedFrameProducerFactory,
+    SimpleDetectedFrameProducer,
+)
+from OTVision.detect.otdet import OtdetBuilder, OtdetMetadataBuilder
+from OTVision.detect.otdet_file_writer import OtdetFileWriter, OtdetFileWrittenEvent
 from OTVision.detect.plugin_av.rotate_frame import AvVideoFrameRotator
 from OTVision.detect.pyav_frame_count_provider import PyAVFrameCountProvider
 from OTVision.detect.timestamper import TimestamperFactory
@@ -43,10 +40,10 @@ 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.frame import DetectedFrame
 from OTVision.domain.input_source_detect import InputSourceDetect
 from OTVision.domain.object_detection import ObjectDetectorFactory
 from OTVision.domain.serialization import Deserializer
+from OTVision.domain.video_writer import VideoWriter
 from OTVision.plugin.yaml_serialization import YamlDeserializer
 
 
@@ -75,7 +72,7 @@ class DetectBuilder(ABC):
 
     @cached_property
     def otdet_builder(self) -> OtdetBuilder:
-        return OtdetBuilder()
+        return OtdetBuilder(OtdetMetadataBuilder())
 
     @cached_property
     def object_detector_factory(self) -> ObjectDetectorFactory:
@@ -116,8 +113,8 @@ class DetectBuilder(ABC):
         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)
+    def detection_file_save_path_provider(self) -> OtvisionSavePathProvider:
+        return OtvisionSavePathProvider(self.get_current_config)
 
     @cached_property
     def frame_count_provider(self) -> FrameCountProvider:
@@ -126,6 +123,7 @@ class DetectBuilder(ABC):
     @cached_property
     def otdet_file_writer(self) -> OtdetFileWriter:
         return OtdetFileWriter(
+            subject=Subject[OtdetFileWrittenEvent](),
             builder=self.otdet_builder,
             get_current_config=self.get_current_config,
             current_object_detector_metadata=self.current_object_detector_metadata,
@@ -144,17 +142,23 @@ class DetectBuilder(ABC):
         )
 
     @cached_property
-    def detected_frame_buffer(
-        self,
-    ) -> Buffer[DetectedFrame, DetectedFrameBufferEvent, FlushEvent]:
+    def detected_frame_buffer(self) -> DetectedFrameBuffer:
         return DetectedFrameBuffer(subject=Subject[DetectedFrameBufferEvent]())
 
     @cached_property
     def detected_frame_producer(self) -> DetectedFrameProducer:
         return SimpleDetectedFrameProducer(
+            producer_factory=self.detected_frame_producer_factory,
+        )
+
+    @cached_property
+    def detected_frame_producer_factory(self) -> DetectedFrameProducerFactory:
+        return DetectedFrameProducerFactory(
             input_source=self.input_source,
+            video_writer_filter=self.video_file_writer,
             detection_filter=self.current_object_detector,
             detected_frame_buffer=self.detected_frame_buffer,
+            get_current_config=self.get_current_config,
         )
 
     @cached_property
@@ -165,6 +169,10 @@ class DetectBuilder(ABC):
     def yaml_deserializer(self) -> Deserializer:
         return YamlDeserializer()
 
+    @property
+    def detect_config(self) -> DetectConfig:
+        return self.current_config.get().detect
+
     def __init__(self, argv: list[str] | None = None) -> None:
         self.argv = argv
 
@@ -173,6 +181,15 @@ class DetectBuilder(ABC):
     def input_source(self) -> InputSourceDetect:
         raise NotImplementedError
 
+    @property
+    @abstractmethod
+    def video_file_writer(self) -> VideoWriter:
+        raise NotImplementedError
+
+    @abstractmethod
+    def register_observers(self) -> None:
+        raise NotImplementedError
+
     def build(self) -> OTVisionVideoDetect:
         self.register_observers()
         self._preload_object_detection_model()
@@ -181,7 +198,3 @@ class DetectBuilder(ABC):
     def _preload_object_detection_model(self) -> None:
         model = self.current_object_detector.get()
         model.preload()
-
-    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

@@ -6,6 +6,11 @@ from OTVision.application.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
+from OTVision.plugin.ffmpeg_video_writer import (
+    ConstantRateFactor,
+    EncodingSpeed,
+    VideoCodec,
+)
 
 
 class ArgparseDetectCliParser(DetectCliParser):
@@ -128,6 +133,34 @@ class ArgparseDetectCliParser(DetectCliParser):
             help="Specify end of detection in seconds.",
             required=False,
         )
+        self._parser.add_argument(
+            "--write-video",
+            default=None,
+            action="store_true",
+            help="Write video to output folder. Not supported on Windows.",
+            required=False,
+        )
+        self._parser.add_argument(
+            "--video-codec",
+            default=None,
+            choices=VideoCodec.as_list(),
+            help="Video codec for video writer. Default is 'libx264'",
+            required=False,
+        )
+        self._parser.add_argument(
+            "--encoding-speed",
+            default=None,
+            choices=EncodingSpeed.as_list(),
+            help="Encoding speed for video writer. Default is 'fast'",
+            required=False,
+        )
+        self._parser.add_argument(
+            "--crf",
+            default=None,
+            choices=ConstantRateFactor.as_list(),
+            help="Constant rate factor for video writer. Default is 'DEFAULT'",
+            required=False,
+        )
 
     def parse(self) -> DetectCliArgs:
         args = self._parser.parse_args(self._argv)
@@ -151,11 +184,21 @@ class ArgparseDetectCliParser(DetectCliParser):
             detect_start=(
                 int(args.detect_start) if args.detect_start is not None else None
             ),
-            detect_end=int(args.detect_end) if args.detect_end is not None else None,
+            detect_end=(int(args.detect_end) if args.detect_end is not None else None),
             logfile=Path(args.logfile),
             log_level_console=args.log_level_console,
             log_level_file=args.log_level_file,
             logfile_overwrite=args.logfile_overwrite,
+            write_video=args.write_video,
+            video_codec=(
+                VideoCodec(args.video_codec) if args.video_codec is not None else None
+            ),
+            encoding_speed=(
+                EncodingSpeed(args.encoding_speed)
+                if args.encoding_speed is not None
+                else None
+            ),
+            crf=ConstantRateFactor[args.crf] if args.crf is not None else None,
         )
 
     def _parse_start_time(self, start_time: str | None) -> datetime | None:

OTVision/detect/detected_frame_buffer.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 
+from OTVision.abstraction.observer import Observable, Subject
 from OTVision.application.buffer import Buffer
 from OTVision.domain.frame import DetectedFrame
 
@@ -49,7 +50,18 @@ class DetectedFrameBufferEvent:
     frames: list[DetectedFrame]
 
 
-class DetectedFrameBuffer(Buffer[DetectedFrame, DetectedFrameBufferEvent, FlushEvent]):
+class DetectedFrameBuffer(
+    Buffer[DetectedFrame, FlushEvent], Observable[DetectedFrameBufferEvent]
+):
+    def __init__(self, subject: Subject[DetectedFrameBufferEvent]) -> None:
+        Buffer.__init__(self)
+        Observable.__init__(self, subject)
+
+    def on_flush(self, event: FlushEvent) -> None:
+        buffered_elements = self._get_buffered_elements()
+        self._notify_observers(buffered_elements, event)
+        self._reset_buffer()
+
     def _notify_observers(
         self, elements: list[DetectedFrame], event: FlushEvent
     ) -> None:

OTVision/detect/detected_frame_producer.py

@@ -0,0 +1,14 @@
+from typing import Iterator
+
+from OTVision.detect.detected_frame_producer_factory import DetectedFrameProducerFactory
+from OTVision.domain.detect_producer_consumer import DetectedFrameProducer
+from OTVision.domain.frame import DetectedFrame
+
+
+class SimpleDetectedFrameProducer(DetectedFrameProducer):
+
+    def __init__(self, producer_factory: DetectedFrameProducerFactory) -> None:
+        self._producer_factory = producer_factory
+
+    def produce(self) -> Iterator[DetectedFrame]:
+        return self._producer_factory.create()

OTVision/detect/detected_frame_producer_factory.py

@@ -0,0 +1,39 @@
+from typing import Iterator
+
+from OTVision.abstraction.pipes_and_filter import Filter
+from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.domain.frame import DetectedFrame, Frame
+from OTVision.domain.input_source_detect import InputSourceDetect
+
+
+class DetectedFrameProducerFactory:
+    def __init__(
+        self,
+        input_source: InputSourceDetect,
+        video_writer_filter: Filter[Frame, Frame],
+        detection_filter: Filter[Frame, DetectedFrame],
+        detected_frame_buffer: Filter[DetectedFrame, DetectedFrame],
+        get_current_config: GetCurrentConfig,
+    ) -> None:
+        self._input_source = input_source
+        self._video_writer_filter = video_writer_filter
+        self._detection_filter = detection_filter
+        self._detected_frame_buffer = detected_frame_buffer
+        self._get_current_config = get_current_config
+
+    def create(self) -> Iterator[DetectedFrame]:
+        if self._get_current_config.get().detect.write_video:
+            return self.__create_with_video_writer()
+        return self.__create_without_video_writer()
+
+    def __create_without_video_writer(self) -> Iterator[DetectedFrame]:
+        return self._detected_frame_buffer.filter(
+            self._detection_filter.filter(self._input_source.produce())
+        )
+
+    def __create_with_video_writer(self) -> Iterator[DetectedFrame]:
+        return self._detected_frame_buffer.filter(
+            self._detection_filter.filter(
+                self._video_writer_filter.filter(self._input_source.produce())
+            )
+        )

OTVision/detect/file_based_detect_builder.py

@@ -1,19 +1,55 @@
 from functools import cached_property
 
 from OTVision.abstraction.observer import Subject
+from OTVision.application.event.new_video_start import NewVideoStartEvent
 from OTVision.detect.builder import DetectBuilder
 from OTVision.detect.detected_frame_buffer import FlushEvent
 from OTVision.detect.video_input_source import VideoSource
-from OTVision.domain.input_source_detect import InputSourceDetect
+from OTVision.domain.video_writer import VideoWriter
+from OTVision.plugin.ffmpeg_video_writer import (
+    FfmpegVideoWriter,
+    PixelFormat,
+    VideoFormat,
+    append_save_suffix_to_save_location,
+)
 
 
 class FileBasedDetectBuilder(DetectBuilder):
+
     @cached_property
-    def input_source(self) -> InputSourceDetect:
+    def input_source(self) -> VideoSource:
         return VideoSource(
-            subject=Subject[FlushEvent](),
+            subject_flush=Subject[FlushEvent](),
+            subject_new_video_start=Subject[NewVideoStartEvent](),
             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 video_file_writer(self) -> VideoWriter:
+        # Using save_location_strategy=keep_original_save_location is not supported for
+        # file-based detection. Otherwise, we would be overwriting the input source that
+        # we are reading from.
+        return FfmpegVideoWriter(
+            save_location_strategy=append_save_suffix_to_save_location,
+            encoding_speed=self.detect_config.encoding_speed,
+            input_format=VideoFormat.RAW,
+            output_format=VideoFormat.MP4,
+            input_pixel_format=PixelFormat.RGB24,
+            output_pixel_format=PixelFormat.YUV420P,
+            output_video_codec=self.detect_config.video_codec,
+            constant_rate_factor=self.detect_config.crf,
+        )
+
+    def register_observers(self) -> None:
+        if self.detect_config.write_video:
+            self.input_source.subject_new_video_start.register(
+                self.video_file_writer.notify_on_new_video_start
+            )
+            self.input_source.subject_flush.register(
+                self.video_file_writer.notify_on_flush_event
+            )
+        self.input_source.subject_flush.register(self.detected_frame_buffer.on_flush)
+        self.detected_frame_buffer.register(self.otdet_file_writer.write)

OTVision/detect/otdet.py

@@ -1,3 +1,4 @@
+import re
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -6,6 +7,14 @@ from typing import Self
 from OTVision import dataformat, version
 from OTVision.domain.detection import Detection
 from OTVision.domain.frame import DetectedFrame
+from OTVision.helpers.date import parse_datetime
+from OTVision.helpers.files import (
+    FULL_FILE_NAME_PATTERN,
+    HOSTNAME,
+    InproperFormattedFilename,
+)
+
+MISSING_START_DATE = datetime(1900, 1, 1)
 
 
 @dataclass
@@ -35,7 +44,7 @@ class OtdetBuilderError(Exception):
     pass
 
 
-class OtdetBuilder:
+class OtdetMetadataBuilder:
     @property
     def config(self) -> OtdetBuilderConfig:
         if self._config is None:
@@ -45,51 +54,14 @@ class OtdetBuilder:
     def __init__(self) -> None:
         self._config: OtdetBuilderConfig | None = None
 
-    def add_config(self, config: OtdetBuilderConfig) -> Self:
-        self._config = config
-        return self
-
-    def reset(self) -> Self:
-        self._config = None
-        return self
-
-    def build(self, detections: list[DetectedFrame]) -> dict:
-        number_of_frames = len(detections)
+    def build(self, number_of_frames: int) -> dict:
         result = {
-            dataformat.METADATA: self._build_metadata(number_of_frames),
-            dataformat.DATA: self._build_data(detections),
-        }
-        self.reset()
-        return result
-
-    def _build_metadata(self, number_of_frames: int) -> dict:
-        return {
             dataformat.OTDET_VERSION: version.otdet_version(),
             dataformat.VIDEO: self._build_video_config(number_of_frames),
             dataformat.DETECTION: self._build_detection_config(),
         }
-
-    def _build_data(self, frames: list[DetectedFrame]) -> dict:
-        data = {}
-        for frame in frames:
-            converted_detections = [
-                self.__convert_detection(detection) for detection in frame.detections
-            ]
-            data[str(frame.no)] = {
-                dataformat.DETECTIONS: converted_detections,
-                dataformat.OCCURRENCE: frame.occurrence.timestamp(),
-            }
-        return data
-
-    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,
-        }
+        self.reset()
+        return result
 
     def _build_video_config(self, number_of_frames: int) -> dict:
         source = Path(self.config.source)
@@ -128,6 +100,69 @@ class OtdetBuilder:
             dataformat.DETECT_END: self.config.detect_end,
         }
 
+    def add_config(self, config: OtdetBuilderConfig) -> Self:
+        self._config = config
+        return self
+
+    def reset(self) -> Self:
+        self._config = None
+        return self
+
+
+class OtdetBuilder:
+    @property
+    def config(self) -> OtdetBuilderConfig:
+        if self._config is None:
+            raise OtdetBuilderError("Otdet builder config is not set")
+        return self._config
+
+    def __init__(self, metadata_builder: OtdetMetadataBuilder) -> None:
+        self._config: OtdetBuilderConfig | None = None
+        self._metadata_builder = metadata_builder
+
+    def add_config(self, config: OtdetBuilderConfig) -> Self:
+        self._config = config
+        self._metadata_builder.add_config(config)
+        return self
+
+    def reset(self) -> Self:
+        self._config = None
+        return self
+
+    def build(self, detections: list[DetectedFrame]) -> dict:
+        number_of_frames = len(detections)
+        result = {
+            dataformat.METADATA: self._build_metadata(number_of_frames),
+            dataformat.DATA: self._build_data(detections),
+        }
+        self.reset()
+        return result
+
+    def _build_metadata(self, number_of_frames: int) -> dict:
+        return self._metadata_builder.build(number_of_frames)
+
+    def _build_data(self, frames: list[DetectedFrame]) -> dict:
+        data = {}
+        for frame in frames:
+            converted_detections = [
+                self.__convert_detection(detection) for detection in frame.detections
+            ]
+            data[str(frame.no)] = {
+                dataformat.DETECTIONS: converted_detections,
+                dataformat.OCCURRENCE: frame.occurrence.timestamp(),
+            }
+        return data
+
+    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 serialize_video_length(video_length: timedelta) -> str:
     """Serialize a timedelta object to a video length string in 'H+:MM:SS' format.
@@ -180,3 +215,36 @@ def parse_video_length(video_length: str) -> timedelta:
             f"Could not parse video length '{video_length}'. "
             "Expected format 'HH:MM:SS'."
         ) from cause
+
+
+def extract_start_date_from_otdet(metadata: dict) -> datetime:
+    if dataformat.RECORDED_START_DATE in metadata[dataformat.VIDEO].keys():
+        recorded_start_date = metadata[dataformat.VIDEO][dataformat.RECORDED_START_DATE]
+        return parse_datetime(recorded_start_date)
+    return MISSING_START_DATE
+
+
+def extract_expected_duration_from_otdet(metadata: dict) -> timedelta:
+    if dataformat.EXPECTED_DURATION in metadata[dataformat.VIDEO].keys():
+        if expected_duration := metadata[dataformat.VIDEO][
+            dataformat.EXPECTED_DURATION
+        ]:
+            return timedelta(seconds=int(expected_duration))
+    return extract_otdet_video_length(metadata)
+
+
+def extract_otdet_video_length(metadata: dict) -> timedelta:
+    video_length = metadata[dataformat.VIDEO][dataformat.LENGTH]
+    return parse_video_length(video_length)
+
+
+def extract_hostname_from_otdet(metadata: dict) -> str:
+    video_name = Path(metadata[dataformat.VIDEO][dataformat.FILENAME]).name
+    match = re.search(
+        FULL_FILE_NAME_PATTERN,
+        video_name,
+    )
+    if match:
+        return match.group(HOSTNAME)
+
+    raise InproperFormattedFilename(f"Could not parse {video_name}.")

OTVision/detect/otdet_file_writer.py

@@ -1,12 +1,12 @@
 import logging
+from dataclasses import dataclass
 
+from OTVision.abstraction.observer import Observer, Subject
 from OTVision.application.detect.current_object_detector_metadata import (
     CurrentObjectDetectorMetadata,
 )
-from OTVision.application.detect.detection_file_save_path_provider import (
-    DetectionFileSavePathProvider,
-)
 from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.application.otvision_save_path_provider import OtvisionSavePathProvider
 from OTVision.detect.detected_frame_buffer import DetectedFrameBufferEvent
 from OTVision.detect.otdet import OtdetBuilder, OtdetBuilderConfig
 from OTVision.helpers.files import write_json
@@ -15,6 +15,14 @@ from OTVision.helpers.log import LOGGER_NAME
 log = logging.getLogger(LOGGER_NAME)
 
 
+@dataclass(frozen=True)
+class OtdetFileWrittenEvent:
+    """Event that is emitted when an OTDET file is written."""
+
+    otdet_builder_config: OtdetBuilderConfig
+    number_of_frames: int
+
+
 class OtdetFileWriter:
     """Handles writing object detection results to a file in OTDET format.
 
@@ -28,18 +36,20 @@ class OtdetFileWriter:
             settings.
         current_object_detector_metadata (CurrentObjectDetectorMetadata): Provides
             metadata about the current object detector.
-        save_path_provider (DetectionFileSavePathProvider): determines the save path for
+        save_path_provider (OtvisionSavePathProvider): determines the save path for
             the otdet file to be written.
 
     """
 
     def __init__(
         self,
+        subject: Subject[OtdetFileWrittenEvent],
         builder: OtdetBuilder,
         get_current_config: GetCurrentConfig,
         current_object_detector_metadata: CurrentObjectDetectorMetadata,
-        save_path_provider: DetectionFileSavePathProvider,
+        save_path_provider: OtvisionSavePathProvider,
     ):
+        self._subject = subject
         self._builder = builder
         self._get_current_config = get_current_config
         self._current_object_detector_metadata = current_object_detector_metadata
@@ -68,31 +78,32 @@ class OtdetFileWriter:
             actual_fps = actual_frames / source_metadata.duration.total_seconds()
 
         class_mapping = self._current_object_detector_metadata.get().classifications
-        otdet = self._builder.add_config(
-            OtdetBuilderConfig(
-                conf=detect_config.confidence,
-                iou=detect_config.iou,
-                source=source_metadata.output,
-                video_width=source_metadata.width,
-                video_height=source_metadata.height,
-                expected_duration=expected_duration,
-                actual_duration=source_metadata.duration,
-                recorded_fps=source_metadata.fps,
-                recorded_start_date=source_metadata.start_time,
-                actual_fps=actual_fps,
-                actual_frames=actual_frames,
-                detection_img_size=detect_config.img_size,
-                normalized=detect_config.normalized,
-                detection_model=detect_config.weights,
-                half_precision=detect_config.half_precision,
-                chunksize=1,
-                classifications=class_mapping,
-                detect_start=detect_config.detect_start,
-                detect_end=detect_config.detect_end,
-            )
-        ).build(event.frames)
+        builder_config = OtdetBuilderConfig(
+            conf=detect_config.confidence,
+            iou=detect_config.iou,
+            source=source_metadata.output,
+            video_width=source_metadata.width,
+            video_height=source_metadata.height,
+            expected_duration=expected_duration,
+            actual_duration=source_metadata.duration,
+            recorded_fps=source_metadata.fps,
+            recorded_start_date=source_metadata.start_time,
+            actual_fps=actual_fps,
+            actual_frames=actual_frames,
+            detection_img_size=detect_config.img_size,
+            normalized=detect_config.normalized,
+            detection_model=detect_config.weights,
+            half_precision=detect_config.half_precision,
+            chunksize=1,
+            classifications=class_mapping,
+            detect_start=detect_config.detect_start,
+            detect_end=detect_config.detect_end,
+        )
+        otdet = self._builder.add_config(builder_config).build(event.frames)
 
-        detections_file = self._save_path_provider.provide(source_metadata.output)
+        detections_file = self._save_path_provider.provide(
+            source_metadata.output, config.filetypes.detect
+        )
         detections_file.parent.mkdir(parents=True, exist_ok=True)
         write_json(
             otdet,
@@ -105,3 +116,15 @@ class OtdetFileWriter:
 
         finished_msg = "Finished detection"
         log.info(finished_msg)
+        self.__notify(num_frames=actual_frames, builder_config=builder_config)
+
+    def __notify(self, num_frames: int, builder_config: OtdetBuilderConfig) -> None:
+        self._subject.notify(
+            OtdetFileWrittenEvent(
+                number_of_frames=num_frames, otdet_builder_config=builder_config
+            )
+        )
+
+    def register_observer(self, observer: Observer[OtdetFileWrittenEvent]) -> None:
+        """Register an observer to receive notifications about otdet file writes.."""
+        self._subject.register(observer)