OTVision 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

OTVision/__init__.py

@@ -18,13 +18,3 @@ OTVision init module
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-
-# TODO: Might need to change this
-from .convert.convert import main as convert
-from .track.track import main as track
-from .transform.transform import main as transform
-
-# from .view.view import main as view
-
-__all__: list = ["track", "convert", "transform"]

OTVision/application/buffer.py

@@ -22,7 +22,8 @@ class Buffer[T, SUBJECT_TYPE, OBSERVING_TYPE](Observable[SUBJECT_TYPE], Filter[T
         return self._buffer
 
     def _reset_buffer(self) -> None:
-        self._buffer = []
+        del self._buffer
+        self._buffer = list()
 
     def on_flush(self, event: OBSERVING_TYPE) -> None:
         buffered_elements = self._get_buffered_elements()

OTVision/application/detect/current_object_detector.py

@@ -2,8 +2,7 @@ from typing import Generator
 
 from OTVision.abstraction.pipes_and_filter import Filter
 from OTVision.application.get_current_config import GetCurrentConfig
-from OTVision.domain.detection import DetectedFrame
-from OTVision.domain.frame import Frame
+from OTVision.domain.frame import DetectedFrame, Frame
 from OTVision.domain.object_detection import ObjectDetector, ObjectDetectorFactory
 
 

OTVision/application/detect/detected_frame_factory.py

@@ -1,5 +1,5 @@
-from OTVision.domain.detection import DetectedFrame, Detection
-from OTVision.domain.frame import Frame, FrameKeys
+from OTVision.domain.detection import Detection
+from OTVision.domain.frame import DetectedFrame, Frame, FrameKeys
 
 
 class DetectedFrameFactory:
@@ -20,7 +20,8 @@ class DetectedFrameFactory:
 
         return DetectedFrame(
             source=frame[FrameKeys.source],
-            frame_number=frame[FrameKeys.frame],
+            no=frame[FrameKeys.frame],
             occurrence=frame[FrameKeys.occurrence],
             detections=detections,
+            image=frame[FrameKeys.data],
         )

OTVision/application/detect/detected_frame_producer.py

@@ -2,8 +2,7 @@ from typing import Generator
 
 from OTVision.abstraction.pipes_and_filter import Filter
 from OTVision.domain.detect_producer_consumer import DetectedFrameProducer
-from OTVision.domain.detection import DetectedFrame
-from OTVision.domain.frame import Frame
+from OTVision.domain.frame import DetectedFrame, Frame
 from OTVision.domain.input_source_detect import InputSourceDetect
 
 

OTVision/detect/builder.py

@@ -42,7 +42,7 @@ 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.frame import DetectedFrame
 from OTVision.domain.input_source_detect import InputSourceDetect
 from OTVision.domain.object_detection import ObjectDetectorFactory
 

OTVision/detect/detected_frame_buffer.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 
 from OTVision.application.buffer import Buffer
-from OTVision.domain.detection import DetectedFrame
+from OTVision.domain.frame import DetectedFrame
 
 
 @dataclass
@@ -55,3 +55,6 @@ class DetectedFrameBuffer(Buffer[DetectedFrame, DetectedFrameBufferEvent, FlushE
                 source_metadata=event.source_metadata, frames=elements
             )
         )
+
+    def buffer(self, to_buffer: DetectedFrame) -> None:
+        self._buffer.append(to_buffer.without_image())

OTVision/detect/otdet.py

@@ -4,7 +4,8 @@ from pathlib import Path
 from typing import Self
 
 from OTVision import dataformat, version
-from OTVision.domain.detection import DetectedFrame, Detection
+from OTVision.domain.detection import Detection
+from OTVision.domain.frame import DetectedFrame
 
 
 @dataclass
@@ -74,7 +75,7 @@ class OtdetBuilder:
             converted_detections = [
                 self.__convert_detection(detection) for detection in frame.detections
             ]
-            data[str(frame.frame_number)] = {
+            data[str(frame.no)] = {
                 dataformat.DETECTIONS: converted_detections,
                 dataformat.OCCURRENCE: frame.occurrence.timestamp(),
             }

OTVision/detect/video_input_source.py

@@ -7,7 +7,6 @@ import av
 from tqdm import tqdm
 
 from OTVision.abstraction.observer import Subject
-from OTVision.application.configure_logger import logger
 from OTVision.application.detect.detection_file_save_path_provider import (
     DetectionFileSavePathProvider,
 )
@@ -130,7 +129,7 @@ class VideoSource(InputSourceDetect):
                         counter += 1
                 self.notify_observers(video_file, video_fps)
             except Exception as e:
-                logger().error(f"Error processing {video_file}", exc_info=e)
+                log.error(f"Error processing {video_file}", exc_info=e)
 
     def __collect_files_to_detect(self) -> list[Path]:
         filetypes = self._current_config.filetypes.video_filetypes.to_list()

OTVision/detect/yolo.py

@@ -33,8 +33,8 @@ from OTVision.abstraction.pipes_and_filter import Filter
 from OTVision.application.detect.detected_frame_factory import DetectedFrameFactory
 from OTVision.application.get_current_config import GetCurrentConfig
 from OTVision.config import DetectConfig
-from OTVision.domain.detection import DetectedFrame, Detection
-from OTVision.domain.frame import Frame, FrameKeys
+from OTVision.domain.detection import Detection
+from OTVision.domain.frame import DetectedFrame, Frame, FrameKeys
 from OTVision.domain.object_detection import ObjectDetector, ObjectDetectorFactory
 from OTVision.helpers.log import LOGGER_NAME
 

OTVision/domain/detect_producer_consumer.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Generator
 
-from OTVision.domain.detection import DetectedFrame
+from OTVision.domain.frame import DetectedFrame
 
 
 class DetectedFrameConsumer(ABC):

OTVision/domain/detection.py

@@ -1,9 +1,34 @@
 from dataclasses import dataclass
-from datetime import datetime
+
+from OTVision.dataformat import (
+    CLASS,
+    CONFIDENCE,
+    FINISHED,
+    FIRST,
+    INTERPOLATED_DETECTION,
+    TRACK_ID,
+    H,
+    W,
+    X,
+    Y,
+)
+
+TrackId = int
 
 
 @dataclass(frozen=True, repr=True)
 class Detection:
+    """Detection data without track context data.
+
+    Attributes:
+        label (str): Assigned label, e.g. vehicle class.
+        conf (float): Confidence of detected class.
+        x (float): X-coordinate of detection center.
+        y (float): Y-coordinate of detection center.
+        w (float): Width of detection.
+        h (float): Height of detection.
+    """
+
     label: str
     conf: float
     x: float
@@ -11,10 +36,106 @@ class Detection:
     w: float
     h: float
 
+    def of_track(self, id: TrackId, is_first: bool) -> "TrackedDetection":
+        """Convert to TrackedDetection by adding track information.
+
+        Args:
+            id (TrackId): id of assigned track.
+            is_first (bool): whether this detection is first of track.
+
+        Returns:
+            TrackedDetection: This detection data with additional track information.
+        """
+        return TrackedDetection(
+            self.label,
+            self.conf,
+            self.x,
+            self.y,
+            self.w,
+            self.h,
+            is_first,
+            id,
+        )
+
+    def to_otdet(self) -> dict:
+        return {
+            CLASS: self.label,
+            CONFIDENCE: self.conf,
+            X: self.x,
+            Y: self.y,
+            W: self.w,
+            H: self.h,
+        }
+
+
+@dataclass(frozen=True, repr=True)
+class TrackedDetection(Detection):
+    """Detection with additional track data.
+    At the time a detection is tracked,
+    it might not be known whether it is the last of a track.
+
+    Attributes:
+        is_first (bool): whether this detection is the first in the track.
+        track_id (TrackId): id of the assigned track.
+    """
+
+    is_first: bool
+    track_id: TrackId
+
+    def finish(self, is_last: bool, is_discarded: bool) -> "FinishedDetection":
+        return FinishedDetection.from_tracked_detection(self, is_last, is_discarded)
+
+    def as_last_detection(self, is_discarded: bool) -> "FinishedDetection":
+        return FinishedDetection.from_tracked_detection(
+            self, is_last=True, is_discarded=is_discarded
+        )
+
+    def as_intermediate_detection(self, is_discarded: bool) -> "FinishedDetection":
+        return FinishedDetection.from_tracked_detection(
+            self, is_last=False, is_discarded=is_discarded
+        )
+
+
+@dataclass(frozen=True, repr=True)
+class FinishedDetection(TrackedDetection):
+    """Detection data with extended track information including is_finished.
+
+    Attributes:
+        is_last (bool): whether this detection is the last in the track.
+        is_discarded (bool): whether the detections's track was discarded.
+    """
+
+    is_last: bool
+    is_discarded: bool
+
+    @classmethod
+    def from_tracked_detection(
+        cls, tracked_detection: TrackedDetection, is_last: bool, is_discarded: bool
+    ) -> "FinishedDetection":
+        td = tracked_detection
+        return cls(
+            label=td.label,
+            conf=td.conf,
+            x=td.x,
+            y=td.y,
+            w=td.w,
+            h=td.h,
+            is_first=td.is_first,
+            track_id=td.track_id,
+            is_last=is_last,
+            is_discarded=is_discarded,
+        )
 
-@dataclass(frozen=True)
-class DetectedFrame:
-    source: str
-    frame_number: int
-    occurrence: datetime
-    detections: list[Detection]
+    def to_dict(self) -> dict:
+        return {
+            CLASS: self.label,
+            CONFIDENCE: self.conf,
+            X: self.x,
+            Y: self.y,
+            W: self.w,
+            H: self.h,
+            INTERPOLATED_DETECTION: False,
+            FIRST: self.is_first,
+            FINISHED: self.is_last,
+            TRACK_ID: self.track_id,
+        }

OTVision/domain/frame.py

@@ -1,8 +1,17 @@
+from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Literal, Optional, TypedDict
+from typing import Callable, Literal, Optional, Sequence, TypedDict
 
 from numpy import ndarray
 
+from OTVision.dataformat import FRAME, OCCURRENCE, TRACK_ID
+from OTVision.domain.detection import (
+    Detection,
+    FinishedDetection,
+    TrackedDetection,
+    TrackId,
+)
+
 
 class FrameKeys:
     """Keys to access Frame dictionary."""
@@ -27,3 +36,148 @@ class Frame(TypedDict):
     frame: int
     source: str
     occurrence: datetime
+
+
+FrameNo = int
+
+
+@dataclass(frozen=True, kw_only=True)
+class DetectedFrame:
+    """Frame metadata, optional image and respective detections.
+
+    Attributes:
+        no (FrameNo): Frame number.
+        occurrence (datetime): Time stamp, at which frame was recorded.
+        source (str): Source from where frame was obtained, e.g. video file path.
+        detections (Sequence[Detection]): A sequence of Detections occurring in frame.
+        image (Optional[ndarray]): Optional image data of frame.
+    """
+
+    no: FrameNo
+    occurrence: datetime
+    source: str
+    detections: Sequence[Detection]
+    image: Optional[ndarray] = None
+
+    def without_image(self) -> "DetectedFrame":
+        return DetectedFrame(
+            no=self.no,
+            occurrence=self.occurrence,
+            source=self.source,
+            detections=self.detections,
+            image=None,
+        )
+
+
+IsLastFrame = Callable[[FrameNo, TrackId], bool]
+
+
+@dataclass(frozen=True, kw_only=True)
+class TrackedFrame(DetectedFrame):
+    """Frame metadata with tracked detections.
+    Also provides additional aggregated information about:
+    observed, finished and unfinished tracks.
+
+    Attributes:
+        detections (Sequence[TrackedDetection]): overrides Frame.detections with more
+            specific type of detection.
+        observed_tracks (set[TrackId]): set of tracks of which detection occur in this
+            frame.
+        finished_tracks (set[TrackId]): track ids of tracks observed in this or prior
+            to this frame that can now be considered finished. These track ids should
+            no longer be observed/assigned in future frames. (successfully completed)
+        discarded_tracks (set[TrackId]): track ids, that are now considered discarded.
+            The corresponding tracks are no longer pursued, previous TrackedDetections
+            of these tracks are also considered discarded. Discarded tracks may be
+            observed but not finished.(unsuccessful, incomplete)
+        unfinished_tracks (set[TrackId]): observed tracks that are not yet finished
+            and were not discarded.
+    """
+
+    detections: Sequence[TrackedDetection]
+    finished_tracks: set[TrackId]
+    discarded_tracks: set[TrackId]
+    observed_tracks: set[TrackId] = field(init=False)
+    unfinished_tracks: set[TrackId] = field(init=False)
+
+    def __post_init__(self) -> None:
+        """
+        Derive observed and unfinished tracks from tracked detections and finished
+        track information.
+        """
+        observed = {d.track_id for d in self.detections}
+        object.__setattr__(self, "observed_tracks", observed)
+
+        unfinished = {
+            o
+            for o in self.observed_tracks
+            if o not in self.finished_tracks and o not in self.discarded_tracks
+        }
+        object.__setattr__(self, "unfinished_tracks", unfinished)
+
+    def finish(
+        self,
+        is_last: IsLastFrame,
+        discarded_tracks: set[TrackId],
+        keep_discarded: bool = False,
+    ) -> "FinishedFrame":
+        """Turn this TrackedFrame into a finished frame
+        by adding is_finished information to all its detections.
+
+        Args:
+            is_last (IsLastFrame): function to determine whether
+                a track is finished in a certain frame.
+            discarded_tracks (set[TrackId]): list of tracks considered discarded.
+                Used to mark corresponding tracks.
+            keep_discarded (bool): whether FinishedDetections marked as discarded
+                should be kept in detections list. Defaults to False.
+        Returns:
+            FinishedFrame: frame with FinishedDetections
+        """
+        if keep_discarded:
+            detections = [
+                det.finish(
+                    is_last=is_last(self.no, det.track_id),
+                    is_discarded=(det.track_id in discarded_tracks),
+                )
+                for det in self.detections
+            ]
+        else:
+            detections = [
+                det.finish(is_last=is_last(self.no, det.track_id), is_discarded=False)
+                for det in self.detections
+                if (det.track_id not in discarded_tracks)
+            ]
+
+        return FinishedFrame(
+            no=self.no,
+            occurrence=self.occurrence,
+            source=self.source,
+            finished_tracks=self.finished_tracks,
+            detections=detections,
+            image=self.image,
+            discarded_tracks=discarded_tracks,
+        )
+
+
+@dataclass(frozen=True, kw_only=True)
+class FinishedFrame(TrackedFrame):
+    """TrackedFrame with FinishedDetections.
+
+    Args:
+        detections (Sequence[FinishedDetection]): overrides TrackedFrame.detections
+            with more specific detection type.
+    """
+
+    detections: Sequence[FinishedDetection]
+
+    def to_detection_dicts(self) -> list[dict]:
+        frame_metadata = {FRAME: self.no, OCCURRENCE: self.occurrence.timestamp()}
+
+        # add frame metadata to each detection dict
+        detection_dict_list = [
+            {**detection.to_dict(), **frame_metadata} for detection in self.detections
+        ]
+
+        detection_dict_list.sort(key=lambda det: det[TRACK_ID])
+        return detection_dict_list

OTVision/domain/object_detection.py

@@ -2,8 +2,7 @@ from abc import ABC, abstractmethod
 from typing import Generator
 
 from OTVision.config import DetectConfig
-from OTVision.domain.detection import DetectedFrame
-from OTVision.domain.frame import Frame
+from OTVision.domain.frame import DetectedFrame, Frame
 
 
 class ObjectDetectorMetadata(ABC):

OTVision/track/model/filebased/frame_chunk.py

@@ -6,15 +6,15 @@ from typing import Sequence
 from tqdm import tqdm
 
 from OTVision.dataformat import FRAME, INPUT_FILE_PATH, TRACK_ID
-from OTVision.track.model.filebased.frame_group import FrameGroup, get_output_file
-from OTVision.track.model.frame import (
+from OTVision.domain.detection import TrackId
+from OTVision.domain.frame import (
+    DetectedFrame,
     FinishedFrame,
-    Frame,
     FrameNo,
     IsLastFrame,
     TrackedFrame,
-    TrackId,
 )
+from OTVision.track.model.filebased.frame_group import FrameGroup, get_output_file
 
 
 @dataclass(frozen=True)
@@ -25,13 +25,13 @@ class FrameChunk:
     Attributes:
         file (Path): common file path source of Frames.
         metadata (dict): otdet metadata.
-        frames (Sequence[Frame[Path]]): a sequence of untracked Frames.
+        frames (Sequence[DetectedFrame]): a sequence of untracked Frames.
         frame_group_id (int): id of FrameGroup this FrameCHunk is part of.
     """
 
     file: Path
     metadata: dict
-    frames: Sequence[Frame[Path]]
+    frames: Sequence[DetectedFrame]
     frame_group_id: int
 
     def check_output_file_exists(self, with_suffix: str) -> bool:
@@ -49,7 +49,7 @@ class TrackedChunk(FrameChunk):
     Attributes:
         is_last_chunk (bool): whether this chunk is the last of
             subsequently (related/connected) chunks.
-        frames (Sequence[TrackedFrame[Path]]): overrides frames
+        frames (Sequence[TrackedFrame]): overrides frames
             with more specific frame type.
         finished_tracks (set[TrackId]): aggregates finished tracks
             of given TrackedFrames.
@@ -62,7 +62,7 @@ class TrackedChunk(FrameChunk):
     """
 
     is_last_chunk: bool
-    frames: Sequence[TrackedFrame[Path]] = field(init=False)
+    frames: Sequence[TrackedFrame] = field(init=False)
 
     finished_tracks: set[TrackId] = field(init=False)
     observed_tracks: set[TrackId] = field(init=False)
@@ -75,7 +75,7 @@ class TrackedChunk(FrameChunk):
         file: Path,
         metadata: dict,
         is_last_chunk: bool,
-        frames: Sequence[TrackedFrame[Path]],
+        frames: Sequence[TrackedFrame],
         frame_group_id: int,
     ) -> None:
 
@@ -165,11 +165,11 @@ class FinishedChunk(TrackedChunk):
     """A chunk of FinishedFrames.
 
     Attributes:
-        frames (Sequence[FinishedFrame[Path]]): overrides frames
+        frames (Sequence[FinishedFrame]): overrides frames
             with more specific frame type.
     """
 
-    frames: Sequence[FinishedFrame[Path]]
+    frames: Sequence[FinishedFrame]
 
     def to_detection_dicts(self) -> list[dict]:
         chunk_metadata = {INPUT_FILE_PATH: self.file.as_posix()}

OTVision/track/model/tracking_interfaces.py

@@ -1,46 +1,40 @@
 from abc import ABC, abstractmethod
 from typing import Generic, Iterator, TypeVar
 
-from OTVision.track.model.frame import (
+from OTVision.domain.detection import TrackId
+from OTVision.domain.frame import (
+    DetectedFrame,
     FinishedFrame,
-    Frame,
     FrameNo,
     IsLastFrame,
     TrackedFrame,
-    TrackId,
 )
 
-S = TypeVar("S")  # Source type (e.g., Path, URL, str, etc.)
-# -> would look nicer in python 3.12
-
 ID_GENERATOR = Iterator[TrackId]
 
 
-class Tracker(ABC, Generic[S]):
+class Tracker(ABC):
     """Tracker interface for processing a stream of Frames
     to add tracking information, creating a lazy stream (generator)
     of TrackedFrames.
 
     Implementing class can specify template method:
     track_frame for processing a single frame.
-
-    Args:
-        Generic (S): generic type of Frame source (e.g. file path, or stream url)
     """
 
     def track(
-        self, frames: Iterator[Frame[S]], id_generator: ID_GENERATOR
-    ) -> Iterator[TrackedFrame[S]]:
+        self, frames: Iterator[DetectedFrame], id_generator: ID_GENERATOR
+    ) -> Iterator[TrackedFrame]:
         """Process the given stream of Frames,
         yielding TrackedFrames one by one as a lazy stream of TrackedFrames.
 
         Args:
-            frames (Iterator[Frame[S]]): (lazy) stream of Frames
+            frames (Iterator[DetectedFrame]): (lazy) stream of Frames
                 with untracked Detections.
             id_generator (ID_GENERATOR): provider of new (unique) track ids.
 
         Yields:
-            Iterator[TrackedFrame[S]]: (lazy) stream of TrackedFrames with
+            Iterator[TrackedFrame]: (lazy) stream of TrackedFrames with
                 TrackedDetections
         """
         for frame in frames:
@@ -49,19 +43,19 @@ class Tracker(ABC, Generic[S]):
     @abstractmethod
     def track_frame(
         self,
-        frame: Frame[S],
+        frame: DetectedFrame,
         id_generator: ID_GENERATOR,
-    ) -> TrackedFrame[S]:
+    ) -> TrackedFrame:
         """Process single Frame with untracked Detections,
         by adding tracking information,
         creating a TrackedFrame with TrackedDetections.
 
         Args:
-            frame (Frame[S]): the Frame (with source S) to be tracked.
+            frame (DetectedFrame): the Frame to be tracked.
             id_generator (ID_GENERATOR): provider of new (unique) track ids.
 
         Returns:
-            TrackedFrame[S]: TrackedFrame with TrackedDetections
+            TrackedFrame: TrackedFrame with TrackedDetections
         """
         pass
 
@@ -268,42 +262,42 @@ class UnfinishedTracksBuffer(ABC, Generic[C, F]):
         return finished_containers
 
 
-class UnfinishedFramesBuffer(UnfinishedTracksBuffer[TrackedFrame[S], FinishedFrame[S]]):
+class UnfinishedFramesBuffer(UnfinishedTracksBuffer[TrackedFrame, FinishedFrame]):
     """UnfinishedTracksBuffer implementation for Frames as Detection container."""
 
-    def __init__(self, tracker: Tracker[S], keep_discarded: bool = False):
+    def __init__(self, tracker: Tracker, keep_discarded: bool = False):
         super().__init__(keep_discarded)
         self._tracker = tracker
 
     def track(
-        self, frames: Iterator[Frame[S]], id_generator: ID_GENERATOR
-    ) -> Iterator[FinishedFrame[S]]:
+        self, frames: Iterator[DetectedFrame], id_generator: ID_GENERATOR
+    ) -> Iterator[FinishedFrame]:
         tracked_frame_stream = self._tracker.track(frames, id_generator)
         return self.track_and_finish(tracked_frame_stream)
 
-    def _get_last_track_frames(self, container: TrackedFrame[S]) -> dict[TrackId, int]:
+    def _get_last_track_frames(self, container: TrackedFrame) -> dict[TrackId, int]:
         return {o: container.no for o in container.observed_tracks}
 
-    def _get_unfinished_tracks(self, container: TrackedFrame[S]) -> set[TrackId]:
+    def _get_unfinished_tracks(self, container: TrackedFrame) -> set[TrackId]:
         return container.unfinished_tracks
 
-    def _get_observed_tracks(self, container: TrackedFrame[S]) -> set[TrackId]:
+    def _get_observed_tracks(self, container: TrackedFrame) -> set[TrackId]:
         return container.observed_tracks
 
-    def _get_newly_finished_tracks(self, container: TrackedFrame[S]) -> set[TrackId]:
+    def _get_newly_finished_tracks(self, container: TrackedFrame) -> set[TrackId]:
         return container.finished_tracks
 
-    def _get_newly_discarded_tracks(self, container: TrackedFrame[S]) -> set[TrackId]:
+    def _get_newly_discarded_tracks(self, container: TrackedFrame) -> set[TrackId]:
         return container.discarded_tracks
 
-    def _get_last_frame_of_container(self, container: TrackedFrame[S]) -> FrameNo:
+    def _get_last_frame_of_container(self, container: TrackedFrame) -> FrameNo:
         return container.no
 
     def _finish(
         self,
-        container: TrackedFrame[S],
+        container: TrackedFrame,
         is_last: IsLastFrame,
         discarded_tracks: set[TrackId],
         keep_discarded: bool,
-    ) -> FinishedFrame[S]:
+    ) -> FinishedFrame:
         return container.finish(is_last, discarded_tracks, keep_discarded)

OTVision/track/parser/chunk_parser_plugins.py

@@ -16,15 +16,15 @@ from OTVision.dataformat import (
     X,
     Y,
 )
+from OTVision.domain.detection import Detection
+from OTVision.domain.frame import DetectedFrame
 from OTVision.helpers.date import (
     parse_date_string_to_utc_datime,
     parse_timestamp_string_to_utc_datetime,
 )
 from OTVision.helpers.files import denormalize_bbox, read_json
-from OTVision.track.model.detection import Detection
 from OTVision.track.model.filebased.frame_chunk import ChunkParser, FrameChunk
 from OTVision.track.model.filebased.frame_group import FrameGroup
-from OTVision.track.model.frame import Frame
 
 
 class JsonChunkParser(ChunkParser):
@@ -47,7 +47,7 @@ class JsonChunkParser(ChunkParser):
 
     def convert(
         self, file: Path, frame_offset: int, input: dict[int, dict[str, Any]]
-    ) -> list[Frame[Path]]:
+    ) -> list[DetectedFrame]:
         detection_parser = DetectionParser()
         frames = []
 
@@ -58,10 +58,10 @@ class JsonChunkParser(ChunkParser):
             occurrence: datetime = parse_datetime(value[OCCURRENCE])
             data_detections = value[DETECTIONS]
             detections = detection_parser.convert(data_detections)
-            parsed_frame = Frame(
-                int(key) + frame_offset,
+            parsed_frame = DetectedFrame(
+                no=int(key) + frame_offset,
                 occurrence=occurrence,
-                source=file,
+                source=str(file),
                 detections=detections,
                 image=None,
             )

OTVision/track/track.py

@@ -111,7 +111,7 @@ def main(
         log.warning(f"No files of type '{filetypes}' found to track!")
         return
 
-    iou_tracker: IouTracker[Path] = IouTracker(
+    iou_tracker: IouTracker = IouTracker(
         parameters=IouParameters(sigma_l, sigma_h, sigma_iou, t_min, t_miss_max)
     )
 

OTVision/track/tracker/filebased_tracking.py

@@ -6,6 +6,8 @@ from more_itertools import peekable
 from tqdm import tqdm
 
 from OTVision.config import CONFIG, DEFAULT_FILETYPE, OVERWRITE, TRACK
+from OTVision.domain.detection import TrackId
+from OTVision.domain.frame import DetectedFrame, FrameNo, IsLastFrame, TrackedFrame
 from OTVision.helpers.log import LOGGER_NAME
 from OTVision.track.model.filebased.frame_chunk import (
     ChunkParser,
@@ -14,13 +16,6 @@ from OTVision.track.model.filebased.frame_chunk import (
     TrackedChunk,
 )
 from OTVision.track.model.filebased.frame_group import FrameGroup, FrameGroupParser
-from OTVision.track.model.frame import (
-    Frame,
-    FrameNo,
-    IsLastFrame,
-    TrackedFrame,
-    TrackId,
-)
 from OTVision.track.model.tracking_interfaces import (
     ID_GENERATOR,
     Tracker,
@@ -30,18 +25,18 @@ from OTVision.track.model.tracking_interfaces import (
 log = logging.getLogger(LOGGER_NAME)
 
 
-class ChunkBasedTracker(Tracker[Path]):
+class ChunkBasedTracker(Tracker):
 
-    def __init__(self, tracker: Tracker[Path], chunkParser: ChunkParser) -> None:
+    def __init__(self, tracker: Tracker, chunkParser: ChunkParser) -> None:
         super().__init__()
         self._chunk_parser = chunkParser
         self._tracker = tracker
 
     def track_frame(
         self,
-        frames: Frame[Path],
+        frames: DetectedFrame,
         id_generator: ID_GENERATOR,
-    ) -> TrackedFrame[Path]:
+    ) -> TrackedFrame:
         return self._tracker.track_frame(frames, id_generator)
 
     def track_chunk(
@@ -82,7 +77,7 @@ class GroupedFilesTracker(ChunkBasedTracker):
 
     def __init__(
         self,
-        tracker: Tracker[Path],
+        tracker: Tracker,
         chunk_parser: ChunkParser,
         frame_group_parser: FrameGroupParser,
         id_generator_factory: ID_GENERATOR_FACTORY,

OTVision/track/tracker/tracker_plugin_iou.py

@@ -1,14 +1,8 @@
 from dataclasses import dataclass
 
-from OTVision.track.model.detection import Detection, TrackedDetection
-from OTVision.track.model.frame import Frame, TrackedFrame
-from OTVision.track.model.tracking_interfaces import (
-    ID_GENERATOR,
-    FrameNo,
-    S,
-    Tracker,
-    TrackId,
-)
+from OTVision.domain.detection import Detection, TrackedDetection, TrackId
+from OTVision.domain.frame import DetectedFrame, FrameNo, TrackedFrame
+from OTVision.track.model.tracking_interfaces import ID_GENERATOR, Tracker
 
 
 @dataclass(frozen=True)
@@ -72,7 +66,9 @@ class ActiveIouTrack:
     last_frame: FrameNo
     track_age: int
 
-    def __init__(self, id: TrackId, frame: "Frame", detection: "Detection") -> None:
+    def __init__(
+        self, id: TrackId, frame: "DetectedFrame", detection: "Detection"
+    ) -> None:
         self.id = id
         self.frame_no = [frame.no]
         self.bboxes = [BoundingBox.from_xywh(detection)]
@@ -85,7 +81,7 @@ class ActiveIouTrack:
         self.last_frame = frame.no
         self.track_age = 0
 
-    def add_detection(self, frame: Frame, detection: Detection) -> None:
+    def add_detection(self, frame: DetectedFrame, detection: Detection) -> None:
         self.frame_no.append(frame.no)
         self.bboxes.append(BoundingBox.from_xywh(detection))
         self.center.append(Coordinate.center_of(detection))
@@ -141,7 +137,7 @@ def iou(
     return size_intersection / size_union
 
 
-class IouTracker(Tracker[S]):
+class IouTracker(Tracker):
 
     def __init__(self, parameters: IouParameters):
         super().__init__()
@@ -169,8 +165,8 @@ class IouTracker(Tracker[S]):
         return self.parameters.t_miss_max
 
     def track_frame(
-        self, frame: Frame[S], id_generator: ID_GENERATOR
-    ) -> TrackedFrame[S]:
+        self, frame: DetectedFrame, id_generator: ID_GENERATOR
+    ) -> TrackedFrame:
 
         detections = [d for d in frame.detections if d.conf >= self.sigma_l]
         tracked_detections: list[TrackedDetection] = []

OTVision/version.py

@@ -1,4 +1,4 @@
-__version__ = "v0.6.2"
+__version__ = "v0.6.4"
 
 
 def otdet_version() -> str:

{otvision-0.6.2.dist-info → otvision-0.6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OTVision
-Version: 0.6.2
+Version: 0.6.4
 Summary: OTVision is a core module of the OpenTrafficCam framework to perform object detection and tracking.
 Project-URL: Homepage, https://opentrafficcam.org/
 Project-URL: Documentation, https://opentrafficcam.org/overview/
@@ -22,8 +22,9 @@ Requires-Dist: geopandas==1.0.1
 Requires-Dist: ijson==3.3.0
 Requires-Dist: more-itertools==10.5.0
 Requires-Dist: moviepy==1.0.3
-Requires-Dist: numpy==1.26.4
-Requires-Dist: opencv-python==4.9.0.80
+Requires-Dist: numpy==1.26.4; sys_platform == 'win32'
+Requires-Dist: numpy==2.1.1; sys_platform != 'win32'
+Requires-Dist: opencv-python==4.11.0.86
 Requires-Dist: pandas==2.2.3
 Requires-Dist: pyyaml==6.0.2
 Requires-Dist: setuptools==74.0.0
@@ -31,7 +32,7 @@ Requires-Dist: torch==2.3.1
 Requires-Dist: torchvision==0.18.1
 Requires-Dist: tqdm==4.67.1
 Requires-Dist: ujson==5.10.0
-Requires-Dist: ultralytics==8.3.74
+Requires-Dist: ultralytics==8.3.94
 Description-Content-Type: text/markdown
 
 # OTVision

{otvision-0.6.2.dist-info → otvision-0.6.4.dist-info}/RECORD

@@ -1,22 +1,22 @@
-OTVision/__init__.py,sha256=b2goS-TYrN9y8WHmjG22z1oVwCrjV0WtGJE32NJfvJM,1042
+OTVision/__init__.py,sha256=CLnfgTlVHM4_nzDacvy06Z_Crc3hU6usd0mUyEvBf24,781
 OTVision/config.py,sha256=x_Bh3mrfV434puVchuG0zLsTtjIl-_C0-ZbmRW3tyFM,24371
 OTVision/dataformat.py,sha256=BHF7qHzyNb80hI1EKfwcdJ9bgG_X4bp_hCXzdg7_MSA,1941
-OTVision/version.py,sha256=fADL6JlfA7K_Y8SkaM8PKO79Wscnqe81tRANXC3Fy2U,175
+OTVision/version.py,sha256=yVwTz7eqQw6SQVvUKkYsgB6HAwAyCSDykNLqZF7h1bA,175
 OTVision/abstraction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/abstraction/observer.py,sha256=ZFGxUUjI3wUpf5ogXg2yDe-QjCcXre6SxH5zOogOx2U,1350
 OTVision/abstraction/pipes_and_filter.py,sha256=rzYaWDalXnlMbfpkgI91a0FL0q1llUlCRuIQsidYDv8,940
 OTVision/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/application/buffer.py,sha256=L2x3S2UsMKu-OD6DXWwjSjwmClE44zh_8PI1RotOdmI,1137
+OTVision/application/buffer.py,sha256=eoK3Rfvc_72cQD3EAASzmxhznjmnIFFh3LX9fqAzXyU,1166
 OTVision/application/configure_logger.py,sha256=RmRgYkvSXWqpFX3N2n0h2LDna3uL8AY-yfVZU66t5q4,611
 OTVision/application/frame_count_provider.py,sha256=zN_75IM-w9Xlc5rT8OArhiWhPHR8mUfFhdzhSmQQuaM,693
 OTVision/application/get_config.py,sha256=fRJZUWJvlTed6qriw82-B-05CAqfBma6NQ23WrKqYdE,771
 OTVision/application/get_current_config.py,sha256=RPVexRhJxY4ul8sU0W2OJaj98eTJxMlP-CiioQZCpEI,299
 OTVision/application/update_current_config.py,sha256=1p-F00myUofn-S97NMMfJ9SbemJiLKc_FS3ob_27YjM,321
 OTVision/application/detect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/application/detect/current_object_detector.py,sha256=dmPbZGIXE49TbBZP-KAZWPgiMEeyZKdiaD2VlLM1SxI,1380
+OTVision/application/detect/current_object_detector.py,sha256=J4U5k1s902agN90FYR4M_gO8MYYa_5XkYGREjStWCxQ,1343
 OTVision/application/detect/current_object_detector_metadata.py,sha256=xai0UBEzxr-rxXCc8mTmNDECds7mdsw2sem5HZxvQ4Q,1017
-OTVision/application/detect/detected_frame_factory.py,sha256=x7FPckcqVVov912ysBiUVvn6eVn3-rqd2rjzXrZBNrY,932
-OTVision/application/detect/detected_frame_producer.py,sha256=hUxmA2wx-OXRAjGZieDfsvRQUaJN7IT42R1Po4iUPhA,943
+OTVision/application/detect/detected_frame_factory.py,sha256=Rl6ElFYulgWPK_XZQSXZcT6caF8hvfzMKsOFefYO_pY,963
+OTVision/application/detect/detected_frame_producer.py,sha256=LD4AnQG04YGE68TpxmaRuWRZeCZfhp8oixk6SHTru7c,906
 OTVision/application/detect/detection_file_save_path_provider.py,sha256=nUyzgR7imrH8PkUl_72kdUDiolPXq1_RQqbpFwLI5Cs,2165
 OTVision/application/detect/factory.py,sha256=UWQHqpaT6FyhMTzTIBSGR06_Hxo8HKM2-IlSpP_djYA,926
 OTVision/application/detect/get_detect_cli_args.py,sha256=gezr17im8SwbuXW1suCodWRrFs8lSljNKu76SbWBgkY,265
@@ -25,26 +25,26 @@ OTVision/application/detect/update_detect_config_with_cli_args.py,sha256=NP4asZx
 OTVision/convert/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/convert/convert.py,sha256=vRIFcrAUf9MUWAuvF_q7JQ9aN89B1ouBOCtXrCLuDp8,11013
 OTVision/detect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/detect/builder.py,sha256=fOhbspd4TuCJMDR2Vvbc4hOJqyfHTo2f6x7l_wf-IiA,6971
+OTVision/detect/builder.py,sha256=ZFSUnDmx742DqxuEG3N8Hf7ynvE0jLkxvRYAApbB3zA,6967
 OTVision/detect/cli.py,sha256=qsmbt43j0KAyj8XVuo-QEHxQZJ80DVmpDGZ-d1lE14I,6025
 OTVision/detect/detect.py,sha256=YaVS-DJXdEmh-OzwE31UPNl2uk7mcFyO_CKKTgMeiuM,1328
-OTVision/detect/detected_frame_buffer.py,sha256=SlnwWIqvJsSp-qt9u5Vk094JCnhfpr5luA6A2h5ZRVc,1336
-OTVision/detect/otdet.py,sha256=VsprZPBH2hUna9wYQBAQVM9rM4X9L7cD5aNS9N5RFr0,4485
+OTVision/detect/detected_frame_buffer.py,sha256=BsyPQ9nI6QdN40ZZKA-eXTxRU_noYuDsH2UhzSdVkQY,1444
+OTVision/detect/otdet.py,sha256=6yYSNHayzBBVu4PBaMobkh7jBhQKQ6KbnQPOefwoJh8,4508
 OTVision/detect/otdet_file_writer.py,sha256=9xeBD5I44Yp3DblZWpnOQuBVRWDQ2eObyevmBid2Wyw,4252
 OTVision/detect/pyav_frame_count_provider.py,sha256=w7p9iM3F2fljV8SD7q491gQhIHANbVczqtalcUiKj-E,453
 OTVision/detect/timestamper.py,sha256=4wsbkv-ex4zGhPCcYWqQQ2JbqVVPCmVzoT2U6efsy-o,5232
-OTVision/detect/video_input_source.py,sha256=AoFn4OJvRYSZ63qEhZ_gk0ptPFBTZc37uaptFyPoZNc,8557
-OTVision/detect/yolo.py,sha256=h4RTUP5RYTKe4QNy19D_8A6MeNv3lVTDRhShTnOX_as,9845
+OTVision/detect/video_input_source.py,sha256=dVH2gPRV5yW4mpoIK6S0iQKWZJCwIhMnPLabJwDtbWI,8495
+OTVision/detect/yolo.py,sha256=YkeE1A-NULsOgx0y2SH16nzBNBYAAd-TdQLzYGfuBH8,9845
 OTVision/detect/plugin_av/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/detect/plugin_av/rotate_frame.py,sha256=4wJqTYI2HRlfa4p2Ffap33vLmKIzE_EwFvQraEkQ4R8,1055
 OTVision/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/domain/cli.py,sha256=XRIDSv4TJvXxwJw1UVznHSpaeUIRiikCabyGuiwh_2o,1049
 OTVision/domain/current_config.py,sha256=TKb6Nuei8n2v6k873w0AkDNAnvSwqphdi5h6hlZ4Y5k,274
-OTVision/domain/detect_producer_consumer.py,sha256=hWrK3Hh62Opm8t4uWASMw1MTSp1xtZYcE9cQiAfRzGs,859
-OTVision/domain/detection.py,sha256=FGI1R8cgTfgL3WOnvsFNMIV2aU7Zu2W4q75T-86yxyg,343
-OTVision/domain/frame.py,sha256=SKJlo_Gd9kRjD7JJR6GetBqiiJ7b1_Vn4KH4V6Q1iVA,751
+OTVision/domain/detect_producer_consumer.py,sha256=gD7NwscQZLmCxMDZpZkGql0oMrpGHDBBNvdTXs58Vvw,855
+OTVision/domain/detection.py,sha256=SZLP-87XE3NcTkeYz7GTqp4oPMiqI1P5gILp1_yHtxY,3761
+OTVision/domain/frame.py,sha256=qHduCRbBTgzGLIuu7MlLWvhzphPlD3V0nrjlEApmr00,6211
 OTVision/domain/input_source_detect.py,sha256=9DzkTg5dh7_KmxE9oxdmxrcTYhvZY8hHLZwhrh7Gz2o,1245
-OTVision/domain/object_detection.py,sha256=gJ5Jd5uWGSjdIue-XKddb9krFynLZ59_XctMY4HE1ww,1288
+OTVision/domain/object_detection.py,sha256=k2VoQlaUhnpAUtX-OdbgDdt4qN0o7zjFGA5rZn1gneY,1251
 OTVision/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/helpers/date.py,sha256=XK0fmXMombQ2CJ2_RXjk-bc-R8qqXRK2rDmCMBi0_G0,854
 OTVision/helpers/files.py,sha256=g_ix1e_ti1ZlW4zOulvkUiupcE8KJV_OHGNGXQTQ71I,18478
@@ -54,23 +54,21 @@ OTVision/helpers/log.py,sha256=fOSMTXQRQ3_3zzYL8pDlx85IXPwyDsI2WGpK-V_R47Q,4985
 OTVision/helpers/machine.py,sha256=8Bz_Eg7PS0IL4riOVeJcEIi5D9E8Ju8-JomTkW975p8,2166
 OTVision/helpers/video.py,sha256=xyI35CiWXqoeGd3HeLhZUPxrLz8GccWyzHusxoweJr4,1480
 OTVision/track/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/track/track.py,sha256=BfErHX9_55unbNqVFksDku8uAjKjH5hTfdfmhXFIC3A,5060
+OTVision/track/track.py,sha256=hrmvwIR4nV6wA8DUuYPSCrDXr7cAP13WXo_gZDBX7hE,5054
 OTVision/track/exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/track/exporter/filebased_exporter.py,sha256=7LFoHcqrlNCd0KDQZA5qI2sZFlxecazJ6sBwdVvvdWE,947
 OTVision/track/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/track/model/detection.py,sha256=SZLP-87XE3NcTkeYz7GTqp4oPMiqI1P5gILp1_yHtxY,3761
-OTVision/track/model/frame.py,sha256=p07Va0zhXPvkXSZR9ewgMuBK0XHD7AFNRA4HhCfaew0,5290
 OTVision/track/model/track_exporter.py,sha256=FUuMsdNqWmjqRQasqB6A_0h73NAt-Mt8V93O_ajCHf4,3228
-OTVision/track/model/tracking_interfaces.py,sha256=VqI8K_0DbeKgOX1d1D25b0jcn9zIvgVDlzLrfEpUEqM,10992
+OTVision/track/model/tracking_interfaces.py,sha256=UCCikNv3RQScyHj0Db9jvDS3RaxZXPKLmS1VAYynZ4U,10785
 OTVision/track/model/filebased/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/track/model/filebased/frame_chunk.py,sha256=Wuz0pcgaf7P1a3EOipzDTAlCIYULC_f9DbncfKdnc50,6761
+OTVision/track/model/filebased/frame_chunk.py,sha256=rXhQCHXWGJbePy5ZW3JZCdltGz5mZxFdcrW0mgez-2k,6771
 OTVision/track/model/filebased/frame_group.py,sha256=f-hXS1Vc5U_qf2cgNbYVeSTZ3dg5NUJhasOEHuuX1HE,2977
 OTVision/track/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/track/parser/chunk_parser_plugins.py,sha256=0fj5KtSqPtlzvttyQ-tizPF9w6gwVwHSpupr5ONj8cU,3092
+OTVision/track/parser/chunk_parser_plugins.py,sha256=ojBv_mCOXABmygxz5mhXzeysur3ECmT4a4VlGkeT11k,3108
 OTVision/track/parser/frame_group_parser_plugins.py,sha256=N5jS6Aq2Aq4gc0ouX0UOBqCUagNLRQRjS_81k_OzZi4,4575
 OTVision/track/tracker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/track/tracker/filebased_tracking.py,sha256=kb8CmzwyBipDaPrXdLg2g2rTZGalTC6uAvGbGQwmdVI,6553
-OTVision/track/tracker/tracker_plugin_iou.py,sha256=aMZoKptwG9_TPmlohnT8VVNlbmoVODPf1GLxaINi-ZE,7235
+OTVision/track/tracker/filebased_tracking.py,sha256=bYE1_NX08dy3KDrBpD8aTobtQqg9Id8h4WudZgUEZ5Q,6546
+OTVision/track/tracker/tracker_plugin_iou.py,sha256=4e4DUOClwn8cYYyloUj2ux7DTCVeAs7WMptmAeDMNWY,7234
 OTVision/transform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/transform/get_homography.py,sha256=29waW61uzCCB7tlBAS2zck9sliAxZqnjjOa4jOOHHIc,5970
 OTVision/transform/reference_points_picker.py,sha256=LOmwzCaqbJnXVhaTSaZtkCzTMDamYjbTpY8I99pN0rg,16578
@@ -83,7 +81,7 @@ OTVision/view/view_helpers.py,sha256=a5yV_6ZxO5bxsSymOmxdHqzOEv0VFq4wFBopVRGuVRo
 OTVision/view/view_track.py,sha256=vmfMqpbUfnzg_EsWiL-IIKNOApVF09dzSojHpUfYY6M,5393
 OTVision/view/view_transform.py,sha256=HvRd8g8geKRy0OoiZUDn_oC3SJC5nuXhZf3uZelfGKg,5473
 OTVision/view/helpers/OTC.ico,sha256=G9kwlDtgBXmXO3yxW6Z-xVFV2q4nUGuz9E1VPHSu_I8,21662
-otvision-0.6.2.dist-info/METADATA,sha256=8-TR4TiioaiSZsl6UjTD1mDHflVsjpg7gAvYjHCT9Oc,2282
-otvision-0.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-otvision-0.6.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-otvision-0.6.2.dist-info/RECORD,,
+otvision-0.6.4.dist-info/METADATA,sha256=CRrwlIK6lpWLhfxKM2iDakGS3T2wpFkMsmbyfk52ASA,2361
+otvision-0.6.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+otvision-0.6.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+otvision-0.6.4.dist-info/RECORD,,

OTVision/track/model/detection.py

@@ -1,141 +0,0 @@
-from dataclasses import dataclass
-
-from OTVision.dataformat import (
-    CLASS,
-    CONFIDENCE,
-    FINISHED,
-    FIRST,
-    INTERPOLATED_DETECTION,
-    TRACK_ID,
-    H,
-    W,
-    X,
-    Y,
-)
-
-TrackId = int
-
-
-@dataclass(frozen=True, repr=True)
-class Detection:
-    """Detection data without track context data.
-
-    Attributes:
-        label (str): Assigned label, e.g. vehicle class.
-        conf (float): Confidence of detected class.
-        x (float): X-coordinate of detection center.
-        y (float): Y-coordinate of detection center.
-        w (float): Width of detection.
-        h (float): Height of detection.
-    """
-
-    label: str
-    conf: float
-    x: float
-    y: float
-    w: float
-    h: float
-
-    def of_track(self, id: TrackId, is_first: bool) -> "TrackedDetection":
-        """Convert to TrackedDetection by adding track information.
-
-        Args:
-            id (TrackId): id of assigned track.
-            is_first (bool): whether this detection is first of track.
-
-        Returns:
-            TrackedDetection: This detection data with additional track information.
-        """
-        return TrackedDetection(
-            self.label,
-            self.conf,
-            self.x,
-            self.y,
-            self.w,
-            self.h,
-            is_first,
-            id,
-        )
-
-    def to_otdet(self) -> dict:
-        return {
-            CLASS: self.label,
-            CONFIDENCE: self.conf,
-            X: self.x,
-            Y: self.y,
-            W: self.w,
-            H: self.h,
-        }
-
-
-@dataclass(frozen=True, repr=True)
-class TrackedDetection(Detection):
-    """Detection with additional track data.
-    At the time a detection is tracked,
-    it might not be known whether it is the last of a track.
-
-    Attributes:
-        is_first (bool): whether this detection is the first in the track.
-        track_id (TrackId): id of the assigned track.
-    """
-
-    is_first: bool
-    track_id: TrackId
-
-    def finish(self, is_last: bool, is_discarded: bool) -> "FinishedDetection":
-        return FinishedDetection.from_tracked_detection(self, is_last, is_discarded)
-
-    def as_last_detection(self, is_discarded: bool) -> "FinishedDetection":
-        return FinishedDetection.from_tracked_detection(
-            self, is_last=True, is_discarded=is_discarded
-        )
-
-    def as_intermediate_detection(self, is_discarded: bool) -> "FinishedDetection":
-        return FinishedDetection.from_tracked_detection(
-            self, is_last=False, is_discarded=is_discarded
-        )
-
-
-@dataclass(frozen=True, repr=True)
-class FinishedDetection(TrackedDetection):
-    """Detection data with extended track information including is_finished.
-
-    Attributes:
-        is_last (bool): whether this detection is the last in the track.
-        is_discarded (bool): whether the detections's track was discarded.
-    """
-
-    is_last: bool
-    is_discarded: bool
-
-    @classmethod
-    def from_tracked_detection(
-        cls, tracked_detection: TrackedDetection, is_last: bool, is_discarded: bool
-    ) -> "FinishedDetection":
-        td = tracked_detection
-        return cls(
-            label=td.label,
-            conf=td.conf,
-            x=td.x,
-            y=td.y,
-            w=td.w,
-            h=td.h,
-            is_first=td.is_first,
-            track_id=td.track_id,
-            is_last=is_last,
-            is_discarded=is_discarded,
-        )
-
-    def to_dict(self) -> dict:
-        return {
-            CLASS: self.label,
-            CONFIDENCE: self.conf,
-            X: self.x,
-            Y: self.y,
-            W: self.w,
-            H: self.h,
-            INTERPOLATED_DETECTION: False,
-            FIRST: self.is_first,
-            FINISHED: self.is_last,
-            TRACK_ID: self.track_id,
-        }

OTVision/track/model/frame.py

@@ -1,149 +0,0 @@
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Callable, Generic, Optional, Sequence, TypeVar
-
-from PIL.Image import Image
-
-from OTVision.dataformat import FRAME, OCCURRENCE, TRACK_ID
-from OTVision.track.model.detection import (
-    Detection,
-    FinishedDetection,
-    TrackedDetection,
-    TrackId,
-)
-
-FrameNo = int
-S = TypeVar("S")
-
-
-@dataclass(frozen=True)
-class Frame(Generic[S]):
-    """Frame metadata, optional image and respective detections.
-
-    Attributes:
-        no (FrameNo): Frame number.
-        occurrence (datetime): Time stamp, at which frame was recorded.
-        source (S): Generic source from where frame was obtained, e.g. video file path.
-        detections (Sequence[Detection]): A sequence of Detections occurring in frame.
-        image (Optional[Image]): Optional image data of frame.
-    """
-
-    no: FrameNo
-    occurrence: datetime
-    source: S
-    detections: Sequence[Detection]
-    image: Optional[Image]
-
-
-IsLastFrame = Callable[[FrameNo, TrackId], bool]
-
-
-@dataclass(frozen=True)
-class TrackedFrame(Frame[S]):
-    """Frame metadata with tracked detections.
-    Also provides additional aggregated information about:
-    observed, finished and unfinished tracks.
-
-    Attributes:
-        detections (Sequence[TrackedDetection]): overrides Frame.detections with more
-            specific type of detection.
-        observed_tracks (set[TrackId]): set of tracks of which detection occur in this
-            frame.
-        finished_tracks (set[TrackId]): track ids of tracks observed in this or prior
-            to this frame that can now be considered finished. These track ids should
-            no longer be observed/assigned in future frames. (successfully completed)
-        discarded_tracks (set[TrackId]): track ids, that are now considered discarded.
-            The corresponding tracks are no longer pursued, previous TrackedDetections
-            of these tracks are also considered discarded. Discarded tracks may be
-            observed but not finished.(unsuccessful, incomplete)
-        unfinished_tracks (set[TrackId]): observed tracks that are not yet finished
-            and were not discarded.
-    """
-
-    detections: Sequence[TrackedDetection]
-    finished_tracks: set[TrackId]
-    discarded_tracks: set[TrackId]
-    observed_tracks: set[TrackId] = field(init=False)
-    unfinished_tracks: set[TrackId] = field(init=False)
-
-    def __post_init__(self) -> None:
-        """
-        Derive observed and unfinished tracks from tracked detections and finished
-        track information.
-        """
-        observed = {d.track_id for d in self.detections}
-        object.__setattr__(self, "observed_tracks", observed)
-
-        unfinished = {
-            o
-            for o in self.observed_tracks
-            if o not in self.finished_tracks and o not in self.discarded_tracks
-        }
-        object.__setattr__(self, "unfinished_tracks", unfinished)
-
-    def finish(
-        self,
-        is_last: IsLastFrame,
-        discarded_tracks: set[TrackId],
-        keep_discarded: bool = False,
-    ) -> "FinishedFrame":
-        """Turn this TrackedFrame into a finished frame
-        by adding is_finished information to all its detections.
-
-        Args:
-            is_last (IsLastFrame): function to determine whether
-                a track is finished in a certain frame.
-            discarded_tracks (set[TrackId]): list of tracks considered discarded.
-                Used to mark corresponding tracks.
-            keep_discarded (bool): whether FinishedDetections marked as discarded
-                should be kept in detections list. Defaults to False.
-        Returns:
-            FinishedFrame: frame with FinishedDetections
-        """
-        if keep_discarded:
-            detections = [
-                det.finish(
-                    is_last=is_last(self.no, det.track_id),
-                    is_discarded=(det.track_id in discarded_tracks),
-                )
-                for det in self.detections
-            ]
-        else:
-            detections = [
-                det.finish(is_last=is_last(self.no, det.track_id), is_discarded=False)
-                for det in self.detections
-                if (det.track_id not in discarded_tracks)
-            ]
-
-        return FinishedFrame(
-            no=self.no,
-            occurrence=self.occurrence,
-            source=self.source,
-            finished_tracks=self.finished_tracks,
-            detections=detections,
-            image=self.image,
-            discarded_tracks=discarded_tracks,
-        )
-
-
-@dataclass(frozen=True)
-class FinishedFrame(TrackedFrame[S]):
-    """TrackedFrame with FinishedDetections.
-
-    Args:
-        detections (Sequence[FinishedDetection]): overrides TrackedFrame.detections
-            with more specific detection type.
-    """
-
-    detections: Sequence[FinishedDetection]
-
-    def to_detection_dicts(self) -> list[dict]:
-        frame_metadata = {FRAME: self.no, OCCURRENCE: self.occurrence.timestamp()}
-
-        # add frame metadata to each detection dict
-        detection_dict_list = [
-            {**detection.to_dict(), **frame_metadata} for detection in self.detections
-        ]
-
-        detection_dict_list.sort(key=lambda det: det[TRACK_ID])
-        return detection_dict_list