OTVision 0.6.8__tar.gz → 0.6.9__tar.gz

{otvision-0.6.8 → otvision-0.6.9}/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-0.6.9/OTVision/application/buffer.py

@@ -0,0 +1,28 @@
+from abc import abstractmethod
+from typing import Iterator
+
+from OTVision.abstraction.pipes_and_filter import Filter
+
+
+class Buffer[T, OBSERVING_TYPE](Filter[T, T]):
+    def __init__(self) -> None:
+        self._buffer: list[T] = []
+
+    def filter(self, pipe: Iterator[T]) -> Iterator[T]:
+        for element in pipe:
+            self.buffer(element)
+            yield element
+
+    def buffer(self, to_buffer: T) -> None:
+        self._buffer.append(to_buffer)
+
+    def _get_buffered_elements(self) -> list[T]:
+        return self._buffer
+
+    def _reset_buffer(self) -> None:
+        del self._buffer
+        self._buffer = list()
+
+    @abstractmethod
+    def on_flush(self, event: OBSERVING_TYPE) -> None:
+        raise NotImplementedError

{otvision-0.6.8 → otvision-0.6.9}/OTVision/application/config_parser.py

@@ -75,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)
@@ -286,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-0.6.8 → otvision-0.6.9}/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-0.6.9/OTVision/application/event/new_otvision_config.py

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

otvision-0.6.8/OTVision/application/detect/detection_file_save_path_provider.py → otvision-0.6.9/OTVision/application/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-0.6.9/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-0.6.9/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-0.6.8 → otvision-0.6.9}/OTVision/detect/builder.py

@@ -3,7 +3,6 @@ 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, DetectConfig
 from OTVision.application.config_parser import ConfigParser
 from OTVision.application.configure_logger import ConfigureLogger
@@ -12,9 +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.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 (
@@ -23,20 +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.detected_frame_producer import (
     DetectedFrameProducerFactory,
     SimpleDetectedFrameProducer,
 )
-from OTVision.detect.otdet import OtdetBuilder
-from OTVision.detect.otdet_file_writer import OtdetFileWriter
+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
@@ -44,7 +40,6 @@ 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
@@ -77,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:
@@ -118,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:
@@ -128,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,
@@ -146,9 +142,7 @@ 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

{otvision-0.6.8 → otvision-0.6.9}/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-0.6.8 → otvision-0.6.9}/OTVision/detect/detected_frame_producer.py

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

{otvision-0.6.8 → otvision-0.6.9}/OTVision/detect/detected_frame_producer_factory.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
@@ -21,21 +21,17 @@ class DetectedFrameProducerFactory:
         self._detected_frame_buffer = detected_frame_buffer
         self._get_current_config = get_current_config
 
-    def create(self) -> Generator[DetectedFrame, None, None]:
+    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,
-    ) -> Generator[DetectedFrame, None, None]:
+    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,
-    ) -> Generator[DetectedFrame, None, None]:
+    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())