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

OTVision/abstraction/pipes_and_filter.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generator
+from typing import Iterator
 
 
 class Filter[IN, OUT](ABC):
@@ -14,14 +14,14 @@ class Filter[IN, OUT](ABC):
     """
 
     @abstractmethod
-    def filter(self, pipe: Generator[IN, None, None]) -> Generator[OUT, None, None]:
+    def filter(self, pipe: Iterator[IN]) -> Iterator[OUT]:
         """Process elements from the input pipe and produce output elements.
 
         Args:
-            pipe (Generator[IN, None, None]): Input stream of elements to be processed.
+            pipe (Iterator[IN]): Input stream of elements to be processed.
 
         Returns:
-            Generator[OUT, None, None]: Output stream of processed elements.
+            Iterator[OUT]: Output stream of processed elements.
 
         """
 

OTVision/application/buffer.py

@@ -1,16 +1,14 @@
 from abc import abstractmethod
-from typing import Generator
+from typing import Iterator
 
-from OTVision.abstraction.observer import Observable, Subject
 from OTVision.abstraction.pipes_and_filter import Filter
 
 
-class Buffer[T, SUBJECT_TYPE, OBSERVING_TYPE](Observable[SUBJECT_TYPE], Filter[T, T]):
-    def __init__(self, subject: Subject[SUBJECT_TYPE]) -> None:
-        super().__init__(subject)
+class Buffer[T, OBSERVING_TYPE](Filter[T, T]):
+    def __init__(self) -> None:
         self._buffer: list[T] = []
 
-    def filter(self, pipe: Generator[T, None, None]) -> Generator[T, None, None]:
+    def filter(self, pipe: Iterator[T]) -> Iterator[T]:
         for element in pipe:
             self.buffer(element)
             yield element
@@ -25,11 +23,6 @@ class Buffer[T, SUBJECT_TYPE, OBSERVING_TYPE](Observable[SUBJECT_TYPE], Filter[T
         del self._buffer
         self._buffer = list()
 
-    def on_flush(self, event: OBSERVING_TYPE) -> None:
-        buffered_elements = self._get_buffered_elements()
-        self._notify_observers(buffered_elements, event)
-        self._reset_buffer()
-
     @abstractmethod
-    def _notify_observers(self, elements: list[T], event: OBSERVING_TYPE) -> None:
+    def on_flush(self, event: OBSERVING_TYPE) -> None:
         raise NotImplementedError

OTVision/application/config.py

@@ -2,6 +2,12 @@ from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from pathlib import Path
 
+from OTVision.plugin.ffmpeg_video_writer import (
+    ConstantRateFactor,
+    EncodingSpeed,
+    VideoCodec,
+)
+
 AVAILABLE_WEIGHTS = "AVAILABLEWEIGHTS"
 CALIBRATIONS = "CALIBRATIONS"
 COL_WIDTH = "COLWIDTH"
@@ -58,6 +64,10 @@ LOG_DIR = "LOG_DIR"
 START_TIME = "START_TIME"
 DETECT_END = "DETECT_END"
 DETECT_START = "DETECT_START"
+WRITE_VIDEO = "WRITE_VIDEO"
+VIDEO_CODEC = "VIDEO_CODEC"
+ENCODING_SPEED = "ENCODING_SPEED"
+CRF = "CRF"
 DATETIME_FORMAT = "%Y-%m-%d_%H-%M-%S"
 DEFAULT_EXPECTED_DURATION: timedelta = timedelta(minutes=15)
 """Default length of a video is 15 minutes."""
@@ -289,6 +299,10 @@ class DetectConfig:
     start_time: datetime | None = None
     detect_start: int | None = None
     detect_end: int | None = None
+    write_video: bool = False
+    video_codec: VideoCodec = VideoCodec.H264_SOFTWARE
+    encoding_speed: EncodingSpeed = EncodingSpeed.FAST
+    crf: ConstantRateFactor = ConstantRateFactor.DEFAULT
 
     def to_dict(self) -> dict:
         expected_duration = (
@@ -306,6 +320,10 @@ class DetectConfig:
             START_TIME: self.start_time,
             DETECT_START: self.detect_start,
             DETECT_END: self.detect_end,
+            WRITE_VIDEO: self.write_video,
+            VIDEO_CODEC: self.video_codec.value,
+            ENCODING_SPEED: self.encoding_speed.value,
+            CRF: self.crf.name,
         }
 
 

OTVision/application/config_parser.py

@@ -5,12 +5,14 @@ from OTVision.application.config import (
     COL_WIDTH,
     CONF,
     CONVERT,
+    CRF,
     DATETIME_FORMAT,
     DEFAULT_FILETYPE,
     DELETE_INPUT,
     DETECT,
     DETECT_END,
     DETECT_START,
+    ENCODING_SPEED,
     EXPECTED_DURATION,
     FLUSH_BUFFER_SIZE,
     FONT,
@@ -51,8 +53,10 @@ from OTVision.application.config import (
     TRANSFORM,
     UNDISTORT,
     VID,
+    VIDEO_CODEC,
     WEIGHTS,
     WINDOW,
+    WRITE_VIDEO,
     YOLO,
     Config,
     ConvertConfig,
@@ -71,14 +75,21 @@ from OTVision.application.config import (
 from OTVision.domain.serialization import Deserializer
 
 
+class InvalidOtvisionConfigError(Exception):
+    pass
+
+
 class ConfigParser:
 
     def __init__(self, deserializer: Deserializer) -> None:
         self._deserialize = deserializer
 
     def parse(self, file: Path) -> Config:
-        data = self._deserialize.deserialize(file)
-        return self.parse_from_dict(data)
+        raw_data = self._deserialize.deserialize(file)
+        config = self.parse_from_dict(raw_data)
+
+        self.validate_config(config)
+        return config
 
     def parse_from_dict(self, d: dict) -> Config:
         log_dict = d.get(LOG)
@@ -181,15 +192,19 @@ class ConfigParser:
 
         start_time = self._parse_start_time(data)
         return DetectConfig(
-            sources,
-            data.get(RUN_CHAINED, DetectConfig.run_chained),
-            yolo_config,
-            expected_duration,
-            data.get(OVERWRITE, DetectConfig.overwrite),
-            data.get(HALF_PRECISION, DetectConfig.half_precision),
-            start_time,
-            data.get(DETECT_START, DetectConfig.detect_start),
-            data.get(DETECT_END, DetectConfig.detect_end),
+            paths=sources,
+            run_chained=data.get(RUN_CHAINED, DetectConfig.run_chained),
+            yolo_config=yolo_config,
+            expected_duration=expected_duration,
+            overwrite=data.get(OVERWRITE, DetectConfig.overwrite),
+            half_precision=data.get(HALF_PRECISION, DetectConfig.half_precision),
+            start_time=start_time,
+            detect_start=data.get(DETECT_START, DetectConfig.detect_start),
+            detect_end=data.get(DETECT_END, DetectConfig.detect_end),
+            write_video=data.get(WRITE_VIDEO, DetectConfig.write_video),
+            video_codec=data.get(VIDEO_CODEC, DetectConfig.video_codec),
+            encoding_speed=data.get(ENCODING_SPEED, DetectConfig.encoding_speed),
+            crf=data.get(CRF, DetectConfig.crf),
         )
 
     def parse_yolo_config(self, data: dict) -> YoloConfig:
@@ -278,3 +293,45 @@ class ConfigParser:
             save_dir=save_dir,
             flush_buffer_size=flush_buffer_size,
         )
+
+    def validate_config(self, config: Config) -> None:
+        self.validate_flush_buffer_support_track_lifecycle(config)
+
+    def validate_flush_buffer_support_track_lifecycle(self, config: Config) -> None:
+        """Validate that the flush buffer size supports complete track lifecycle.
+
+        In streaming mode, the flush buffer size must be larger than the tracking
+        parameters t_min and t_miss_max to ensure tracks can complete their full
+        lifecycle before being flushed. This prevents premature flushing of
+        unfinished tracks.
+
+        Args:
+            config (Config): The configuration to validate
+
+        Raises:
+            InvalidOtvisionConfigError: If the flush buffer size is not greater
+                than both t_min and t_miss_max values
+
+        Note:
+            This validation only applies when stream configuration is present.
+            The constraint ensures that:
+            - Tracks have enough frames to reach minimum track length (t_min)
+            - Tracks can handle maximum missing frames (t_miss_max) before completion
+        """
+
+        if config.stream is None:
+            return
+
+        flush_buffer_size = config.stream.flush_buffer_size
+        if (
+            config.track.t_min < flush_buffer_size
+            and config.track.t_miss_max < flush_buffer_size
+        ):
+            return
+
+        raise InvalidOtvisionConfigError(
+            f"The flush buffer size ({flush_buffer_size}) must be greater than the "
+            f"t_min ({config.track.t_min}) and t_miss_max "
+            f"({config.track.t_miss_max}) values to allow tracks to complete "
+            "before flushing."
+        )

OTVision/application/detect/current_object_detector.py

@@ -1,4 +1,4 @@
-from typing import Generator
+from typing import Iterator
 
 from OTVision.abstraction.pipes_and_filter import Filter
 from OTVision.application.get_current_config import GetCurrentConfig
@@ -33,7 +33,5 @@ class CurrentObjectDetector(Filter[Frame, DetectedFrame]):
         detect_config = self._get_current_config.get().detect
         return self._factory.create(detect_config)
 
-    def filter(
-        self, pipe: Generator[Frame, None, None]
-    ) -> Generator[DetectedFrame, None, None]:
+    def filter(self, pipe: Iterator[Frame]) -> Iterator[DetectedFrame]:
         return self.get().detect(pipe)

OTVision/application/detect/update_detect_config_with_cli_args.py

@@ -84,6 +84,22 @@ class UpdateDetectConfigWithCliArgs:
                 if cli_args.detect_end is not None
                 else detect_config.detect_end
             ),
+            write_video=(
+                cli_args.write_video
+                if cli_args.write_video is not None
+                else detect_config.write_video
+            ),
+            video_codec=(
+                cli_args.video_codec
+                if cli_args.video_codec is not None
+                else detect_config.video_codec
+            ),
+            encoding_speed=(
+                cli_args.encoding_speed
+                if cli_args.encoding_speed is not None
+                else detect_config.encoding_speed
+            ),
+            crf=cli_args.crf if cli_args.crf is not None else detect_config.crf,
         )
 
     def _update_log_config(self, config: Config, cli_args: DetectCliArgs) -> _LogConfig:

OTVision/application/event/new_otvision_config.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class NewOtvisionConfigEvent:
+    pass

OTVision/application/event/new_video_start.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class NewVideoStartEvent:
+    output: str
+    width: int
+    height: int
+    fps: float

OTVision/application/{detect/detection_file_save_path_provider.py → otvision_save_path_provider.py}

@@ -3,8 +3,9 @@ from pathlib import Path
 from OTVision.application.get_current_config import GetCurrentConfig
 
 
-class DetectionFileSavePathProvider:
-    """Provides a mechanism to generate file save paths for detections.
+class OtvisionSavePathProvider:
+    """Provides a mechanism to generate file save paths for OTVision tasks such as
+    detect and track.
 
     This class is responsible for deriving the appropriate filenames for
     detection files based on the source and current configuration
@@ -19,11 +20,11 @@ class DetectionFileSavePathProvider:
     def __init__(self, get_current_config: GetCurrentConfig) -> None:
         self._get_current_config = get_current_config
 
-    def provide(self, source: str) -> Path:
+    def provide(self, source: str, file_type: str) -> Path:
         config = self._get_current_config.get()
         return derive_filename(
             video_file=Path(source),
-            detect_suffix=config.filetypes.detect,
+            file_type=file_type,
             detect_start=config.detect.detect_start,
             detect_end=config.detect.detect_end,
         )
@@ -31,7 +32,7 @@ class DetectionFileSavePathProvider:
 
 def derive_filename(
     video_file: Path,
-    detect_suffix: str,
+    file_type: str,
     detect_start: int | None = None,
     detect_end: int | None = None,
 ) -> Path:
@@ -45,7 +46,7 @@ def derive_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.
+        file_type (str): The file suffix to apply to the derived filename.
 
     Returns:
         Path: The modified video file path with the updated stem and suffix applied.
@@ -56,4 +57,4 @@ def derive_filename(
     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)
+    return video_file.with_stem(new_stem).with_suffix(file_type)

OTVision/application/track/ottrk.py

@@ -0,0 +1,203 @@
+from collections import defaultdict
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Self
+
+from OTVision import dataformat, version
+from OTVision.detect.otdet import (
+    OtdetBuilderConfig,
+    OtdetMetadataBuilder,
+    extract_expected_duration_from_otdet,
+    extract_start_date_from_otdet,
+)
+from OTVision.domain.detection import TrackedDetection, TrackId
+from OTVision.domain.frame import FrameNo, TrackedFrame
+
+
+@dataclass
+class OttrkBuilderConfig:
+    otdet_builder_config: OtdetBuilderConfig
+    number_of_frames: int
+    sigma_l: float
+    sigma_h: float
+    sigma_iou: float
+    t_min: int
+    t_miss_max: int
+    tracking_run_id: str
+    frame_group: int
+
+
+class OttrkBuilderError(Exception):
+    pass
+
+
+class OttrkBuilder:
+    @property
+    def config(self) -> OttrkBuilderConfig:
+        if self._config is None:
+            raise OttrkBuilderError("Ottrk builder config is not set")
+        return self._config
+
+    def __init__(self, otdet_metadata_builder: OtdetMetadataBuilder) -> None:
+        self._config: OttrkBuilderConfig | None = None
+        self._otdet_metadata_builder = otdet_metadata_builder
+        self._tracked_detections: dict[TrackId, list[dict]] = defaultdict(list)
+
+    def build(self) -> dict:
+        result = {
+            dataformat.METADATA: self.build_metadata(),
+            dataformat.DATA: {
+                dataformat.DETECTIONS: self._build_data(),
+            },
+        }
+        self.reset()
+        return result
+
+    def build_metadata(self) -> dict:
+        otdet_metadata = self._otdet_metadata_builder.build(
+            self.config.number_of_frames
+        )
+        start_date = extract_start_date_from_otdet(otdet_metadata)
+        duration = extract_expected_duration_from_otdet(otdet_metadata)
+        end_date = start_date + duration
+        ottrk_metadata = self._build_track_metadata(start_date, end_date)
+        return {
+            **otdet_metadata,
+            **ottrk_metadata,
+        }
+
+    def _build_track_metadata(self, start_date: datetime, end_date: datetime) -> dict:
+        result = create_ottrk_metadata_entry(
+            start_date=start_date,
+            end_date=end_date,
+            sigma_l=self.config.sigma_l,
+            sigma_h=self.config.sigma_h,
+            sigma_iou=self.config.sigma_iou,
+            t_min=self.config.t_min,
+            t_miss_max=self.config.t_miss_max,
+        )
+        result[dataformat.TRACKING_RUN_ID] = self.config.tracking_run_id
+        result[dataformat.FRAME_GROUP] = self.config.frame_group
+        return result
+
+    def _build_data(self) -> list[dict]:
+        return sorted(
+            (
+                detection
+                for detections in self._tracked_detections.values()
+                for detection in detections
+            ),
+            key=lambda detection: (
+                detection[dataformat.FRAME],
+                detection[dataformat.OCCURRENCE],
+            ),
+        )
+
+    def set_config(self, config: OttrkBuilderConfig) -> Self:
+        self._config = config
+        self._otdet_metadata_builder.add_config(config.otdet_builder_config)
+        return self
+
+    def add_tracked_frames(self, tracked_frames: list[TrackedFrame]) -> Self:
+        finished_tracks = set()
+        discarded_tracks = set()
+
+        for tracked_frame in tracked_frames:
+            finished_tracks.update(tracked_frame.finished_tracks)
+            discarded_tracks.update(tracked_frame.discarded_tracks)
+
+            for detection in tracked_frame.detections:
+                self._tracked_detections[detection.track_id].append(
+                    self._serialize_tracked_detection(
+                        frame_no=tracked_frame.no,
+                        detection=detection,
+                        occurrence=tracked_frame.occurrence,
+                    )
+                )
+        self.__sort_detections()
+        self.discard_tracks(discarded_tracks)
+        self.finish_tracks(finished_tracks)
+        return self
+
+    def _serialize_tracked_detection(
+        self,
+        frame_no: FrameNo,
+        detection: TrackedDetection,
+        occurrence: datetime,
+    ) -> dict:
+        result = detection.to_otdet()
+        result[dataformat.INTERPOLATED_DETECTION] = False
+        result[dataformat.FIRST] = detection.is_first
+        result[dataformat.FINISHED] = False
+        result[dataformat.TRACK_ID] = detection.track_id
+        result[dataformat.FRAME] = frame_no
+        result[dataformat.OCCURRENCE] = occurrence.timestamp()
+        result[dataformat.INPUT_FILE_PATH] = self.config.otdet_builder_config.source
+        return result
+
+    def __sort_detections(self) -> None:
+        for detections in self._tracked_detections.values():
+            detections.sort(key=lambda detection: (detection[dataformat.OCCURRENCE]))
+
+    def reset(self) -> Self:
+        self._config = None
+        self._otdet_metadata_builder.reset()
+        self._tracked_detections = defaultdict(list)
+        return self
+
+    def discard_tracks(self, tracks: set[TrackId]) -> Self:
+        for track_id in tracks:
+            self.discard_track(track_id)
+        return self
+
+    def discard_track(self, track_id: TrackId) -> Self:
+        try:
+            del self._tracked_detections[track_id]
+        except KeyError:
+            pass
+        return self
+
+    def finish_tracks(self, tracks: set[TrackId]) -> Self:
+        for track_id in tracks:
+            self.finish_track(track_id)
+        return self
+
+    def finish_track(self, track_id: TrackId) -> Self:
+        if track_id in self._tracked_detections:
+            self._tracked_detections[track_id][-1][dataformat.FINISHED] = True
+        return self
+
+
+def create_ottrk_metadata_entry(
+    start_date: datetime,
+    end_date: datetime,
+    sigma_l: float,
+    sigma_h: float,
+    sigma_iou: float,
+    t_min: int,
+    t_miss_max: int,
+) -> dict:
+    return {
+        dataformat.OTTRACK_VERSION: version.ottrack_version(),
+        dataformat.TRACKING: {
+            dataformat.OTVISION_VERSION: version.otvision_version(),
+            dataformat.FIRST_TRACKED_VIDEO_START: start_date.timestamp(),
+            dataformat.LAST_TRACKED_VIDEO_END: end_date.timestamp(),
+            dataformat.TRACKER: create_tracker_metadata(
+                sigma_l, sigma_h, sigma_iou, t_min, t_miss_max
+            ),
+        },
+    }
+
+
+def create_tracker_metadata(
+    sigma_l: float, sigma_h: float, sigma_iou: float, t_min: int, t_miss_max: int
+) -> dict:
+    return {
+        dataformat.NAME: "IOU",
+        dataformat.SIGMA_L: sigma_l,
+        dataformat.SIGMA_H: sigma_h,
+        dataformat.SIGMA_IOU: sigma_iou,
+        dataformat.T_MIN: t_min,
+        dataformat.T_MISS_MAX: t_miss_max,
+    }

OTVision/application/track/tracking_run_id.py

@@ -0,0 +1,35 @@
+from typing import Callable
+
+StrIdGenerator = Callable[[], str]
+
+
+class CurrentTrackingRunId:
+    def __init__(self) -> None:
+        self._current_tracking_run_id: str | None = None
+
+    def update(self, tracking_run_id: str) -> None:
+        self._current_tracking_run_id = tracking_run_id
+
+    def get(self) -> str:
+        if self._current_tracking_run_id is None:
+            raise ValueError("Tracking run id is not set!")
+        return self._current_tracking_run_id
+
+
+class GenerateNewTrackingRunId:
+    def __init__(
+        self, id_generator: StrIdGenerator, current: CurrentTrackingRunId
+    ) -> None:
+        self._generate_id = id_generator
+        self._current = current
+
+    def generate(self) -> None:
+        self._current.update(self._generate_id())
+
+
+class GetCurrentTrackingRunId:
+    def __init__(self, current: CurrentTrackingRunId) -> None:
+        self._current = current
+
+    def get(self) -> str:
+        return self._current.get()

OTVision/application/video/generate_video.py

@@ -0,0 +1,15 @@
+from OTVision.abstraction.pipes_and_filter import Filter
+from OTVision.domain.frame import Frame
+from OTVision.domain.input_source_detect import InputSourceDetect
+
+
+class GenerateVideo:
+    def __init__(
+        self, input_source: InputSourceDetect, video_writer: Filter[Frame, Frame]
+    ) -> None:
+        self._input_source = input_source
+        self._video_writer = video_writer
+
+    def generate(self) -> None:
+        for frame in self._video_writer.filter(self._input_source.produce()):
+            pass

OTVision/config.py

@@ -77,6 +77,7 @@ from OTVision.application.config import (
     VIDEOS,
     WEIGHTS,
     WINDOW,
+    WRITE_VIDEO,
     YOLO,
     Config,
 )
@@ -176,6 +177,7 @@ CONFIG[DETECT][OVERWRITE] = True
 CONFIG[DETECT][HALF_PRECISION] = False
 CONFIG[DETECT][DETECT_START] = None
 CONFIG[DETECT][DETECT_END] = None
+CONFIG[DETECT][WRITE_VIDEO] = False
 
 # TRACK
 CONFIG[TRACK] = {}