OTVision 0.6.1__py3-none-any.whl → 0.6.3__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/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

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/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,139 @@ 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
+
+
+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/helpers/files.py

@@ -329,6 +329,7 @@ def get_metadata(otdict: dict) -> dict:
 # TODO: Type hint nested dict during refactoring
 def denormalize_bbox(
     otdict: dict,
+    file_path: Path | None = None,
     keys_width: Union[list[str], None] = None,
     keys_height: Union[list[str], None] = None,
     metadata: dict[str, dict] = {},
@@ -337,6 +338,8 @@ def denormalize_bbox(
 
     Args:
         otdict (dict): dict of detections or tracks
+        file_path (Path): file path source of the given otdict
+            if all detections stem from the same file.
         keys_width (list[str], optional): list of keys describing horizontal position.
             Defaults to ["x", "w"].
         keys_height (list[str], optional): list of keys describing vertical position.
@@ -351,7 +354,9 @@ def denormalize_bbox(
     if keys_height is None:
         keys_height = [dataformat.Y, dataformat.H]
     log.debug("Denormalize frame wise")
-    otdict = _denormalize_transformation(otdict, keys_width, keys_height, metadata)
+    otdict = _denormalize_transformation(
+        otdict, keys_width, keys_height, metadata, file_path
+    )
     return otdict
 
 
@@ -361,6 +366,7 @@ def _denormalize_transformation(
     keys_width: list[str],
     keys_height: list[str],
     metadata: dict[str, dict] = {},
+    file_path: Path | None = None,
 ) -> dict:
     """Helper to do the actual denormalization.
 
@@ -371,6 +377,8 @@ def _denormalize_transformation(
         keys_height (list[str]): list of keys describing vertical position.
             Defaults to ["y", "h"].
         metadata (dict[str, dict]): dict of metadata per input file.
+        file_path (Path): file path source of otdict
+            if all detections stem from the same file.
 
     Returns:
         dict: denormalized dict
@@ -378,7 +386,7 @@ def _denormalize_transformation(
     changed_files = set()
 
     for frame in otdict[dataformat.DATA].values():
-        input_file = frame[INPUT_FILE_PATH]
+        input_file = file_path.as_posix() if file_path else frame[INPUT_FILE_PATH]
         metadate = metadata[input_file]
         width = metadate[dataformat.VIDEO][dataformat.WIDTH]
         height = metadate[dataformat.VIDEO][dataformat.HEIGHT]

OTVision/helpers/input_types.py

@@ -0,0 +1,15 @@
+def check_types(
+    sigma_l: float, sigma_h: float, sigma_iou: float, t_min: int, t_miss_max: int
+) -> None:
+    """Raise ValueErrors if wrong types"""
+
+    if not isinstance(sigma_l, (int, float)):
+        raise ValueError("sigma_l has to be int or float")
+    if not isinstance(sigma_h, (int, float)):
+        raise ValueError("sigma_h has to be int or float")
+    if not isinstance(sigma_iou, (int, float)):
+        raise ValueError("sigma_iou has to be int or float")
+    if not isinstance(t_min, int):
+        raise ValueError("t_min has to be int")
+    if not isinstance(t_miss_max, int):
+        raise ValueError("t_miss_max has to be int")

OTVision/track/exporter/filebased_exporter.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+
+from OTVision.config import CONFIG, DEFAULT_FILETYPE, TRACK
+from OTVision.track.model.filebased.frame_chunk import FinishedChunk
+from OTVision.track.model.filebased.frame_group import get_output_file
+from OTVision.track.model.track_exporter import FinishedTracksExporter
+
+
+class FinishedChunkTrackExporter(FinishedTracksExporter[FinishedChunk]):
+
+    def __init__(self, file_type: str = CONFIG[DEFAULT_FILETYPE][TRACK]) -> None:
+        super().__init__(file_type)
+
+    def get_detection_dicts(self, container: FinishedChunk) -> list[dict]:
+        return container.to_detection_dicts()
+
+    def get_result_path(self, container: FinishedChunk) -> Path:
+        return get_output_file(container.file, self.file_type)
+
+    def get_metadata(self, container: FinishedChunk) -> dict:
+        return container.metadata
+
+    def get_frame_group_id(self, container: FinishedChunk) -> int:
+        return container.frame_group_id