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

OTVision/track/tracker/tracker_plugin_iou.py

@@ -0,0 +1,228 @@
+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,
+)
+
+
+@dataclass(frozen=True)
+class IouParameters:
+    sigma_l: float
+    sigma_h: float
+    sigma_iou: float
+    t_min: int
+    t_miss_max: int
+
+
+@dataclass(frozen=True, repr=True)
+class Coordinate:
+    x: float
+    y: float
+
+    @staticmethod
+    def center_of(detection: Detection) -> "Coordinate":
+        return Coordinate(detection.x, detection.y)
+
+
+@dataclass(frozen=True, repr=True)
+class BoundingBox:
+    xmin: float
+    ymin: float
+    xmax: float
+    ymax: float
+
+    @staticmethod
+    def from_xywh(detection: Detection) -> "BoundingBox":
+        """Calculates xyxy coordinates from Detection with xywh data:
+            pixel values for xcenter, ycenter, width and height.
+
+        Args:
+            detection (Detection): detection to compute BoundingBox for.
+
+        Returns:
+            BoundingBox with pixel coordinates: xmin, ymin, xmay, ymax
+        """
+        diff_w = detection.w / 2
+        diff_h = detection.h / 2
+        d = detection
+        return BoundingBox(d.x - diff_w, d.y - diff_h, d.x + diff_w, d.y + diff_h)
+
+    def as_tuple(self) -> tuple[float, float, float, float]:
+        return (self.xmin, self.ymin, self.xmax, self.ymax)
+
+
+@dataclass
+class ActiveIouTrack:
+    # TODO check invariant -> at least one element in lists
+    id: int
+    frame_no: list[FrameNo]
+    bboxes: list[BoundingBox]
+    center: list[Coordinate]
+    conf: list[float]
+    classes: list[str]
+    max_class: str
+    max_conf: float
+    first_frame: FrameNo
+    last_frame: FrameNo
+    track_age: int
+
+    def __init__(self, id: TrackId, frame: "Frame", detection: "Detection") -> None:
+        self.id = id
+        self.frame_no = [frame.no]
+        self.bboxes = [BoundingBox.from_xywh(detection)]
+        self.center = [Coordinate.center_of(detection)]
+        self.conf = [detection.conf]
+        self.classes = [detection.label]
+        self.max_class = detection.label
+        self.max_conf = detection.conf
+        self.first_frame = frame.no
+        self.last_frame = frame.no
+        self.track_age = 0
+
+    def add_detection(self, frame: Frame, detection: Detection) -> None:
+        self.frame_no.append(frame.no)
+        self.bboxes.append(BoundingBox.from_xywh(detection))
+        self.center.append(Coordinate.center_of(detection))
+        self.conf.append(detection.conf)
+        self.classes.append(detection.label)
+        self.max_conf = max(self.max_conf, detection.conf)
+        self.last_frame = max(self.last_frame, frame.no)
+        self.track_age = 0
+
+    @property
+    def frame_span(self) -> int:
+        return self.last_frame - self.first_frame
+
+    def iou_with(self, detection: Detection) -> float:
+        return iou(self.bboxes[-1], BoundingBox.from_xywh(detection))
+
+
+def iou(
+    bbox1: BoundingBox,
+    bbox2: BoundingBox,
+) -> float:
+    """
+    Calculates the intersection-over-union of two bounding boxes.
+
+    Args:
+        bbox1 (BoundingBox): first bounding box.
+        bbox2 (BoundingBox): second bounding box.
+
+    Returns:
+        int: intersection-over-onion of bbox1, bbox2
+    """
+
+    (xmin_1, ymin_1, xmax_1, ymax_1) = bbox1.as_tuple()
+    (xmin_2, ymin_2, xmax_2, ymax_2) = bbox2.as_tuple()
+
+    # get the overlap rectangle
+    overlap_xmin = max(xmin_1, xmin_2)
+    overlap_ymin = max(ymin_1, ymin_2)
+    overlap_xmax = min(xmax_1, xmax_2)
+    overlap_ymax = min(ymax_1, ymax_2)
+
+    # check if there is an overlap
+    if overlap_xmax - overlap_xmin <= 0 or overlap_ymax - overlap_ymin <= 0:
+        return 0
+
+    # if yes, calculate the ratio of the overlap to each ROI size and the unified size
+    size_1 = (xmax_1 - xmin_1) * (ymax_1 - ymin_1)
+    size_2 = (xmax_2 - xmin_2) * (ymax_2 - ymin_2)
+
+    size_intersection = (overlap_xmax - overlap_xmin) * (overlap_ymax - overlap_ymin)
+    size_union = size_1 + size_2 - size_intersection
+
+    return size_intersection / size_union
+
+
+class IouTracker(Tracker[S]):
+
+    def __init__(self, parameters: IouParameters):
+        super().__init__()
+        self.parameters = parameters
+        self.active_tracks: list[ActiveIouTrack] = []
+
+    @property
+    def sigma_l(self) -> float:
+        return self.parameters.sigma_l
+
+    @property
+    def sigma_h(self) -> float:
+        return self.parameters.sigma_h
+
+    @property
+    def sigma_iou(self) -> float:
+        return self.parameters.sigma_iou
+
+    @property
+    def t_min(self) -> int:
+        return self.parameters.t_min
+
+    @property
+    def t_miss_max(self) -> int:
+        return self.parameters.t_miss_max
+
+    def track_frame(
+        self, frame: Frame[S], id_generator: ID_GENERATOR
+    ) -> TrackedFrame[S]:
+
+        detections = [d for d in frame.detections if d.conf >= self.sigma_l]
+        tracked_detections: list[TrackedDetection] = []
+
+        finished_track_ids: list[TrackId] = []
+        discarded_track_ids: list[TrackId] = []
+
+        saved_tracks: list[ActiveIouTrack] = []
+        updated_tracks: list[ActiveIouTrack] = []
+        new_tracks: list[ActiveIouTrack] = []
+
+        # for each active track, check if detection with best iou match can be added
+        for track in self.active_tracks:
+            if detections:
+                # get det with highest iou
+                iou_pairs = (
+                    (i, det, track.iou_with(det)) for i, det in enumerate(detections)
+                )
+                best_index, best_match, best_iou = max(iou_pairs, key=lambda p: p[2])
+
+                if best_iou >= self.sigma_iou:
+                    track.add_detection(frame, best_match)
+                    updated_tracks.append(track)
+
+                    del detections[best_index]
+                    tracked_detections.append(best_match.of_track(track.id, False))
+
+            # if track was not updated, increase age (time without detection)
+            # if max age is reached, check confidence, if sufficient finish that track
+            if not updated_tracks or track is not updated_tracks[-1]:
+                if track.track_age < self.t_miss_max:
+                    track.track_age += 1
+                    saved_tracks.append(track)
+                elif track.max_conf >= self.sigma_h and track.frame_span >= self.t_min:
+                    finished_track_ids.append(track.id)
+                else:
+                    discarded_track_ids.append(track.id)
+
+        # start new track for each detection that could not be assigned
+        for det in detections:
+            track_id: TrackId = next(id_generator)
+            new_tracks.append(ActiveIouTrack(track_id, frame, det))
+            tracked_detections.append(det.of_track(track_id, True))
+
+        self.active_tracks = updated_tracks + saved_tracks + new_tracks
+
+        return TrackedFrame(
+            no=frame.no,
+            occurrence=frame.occurrence,
+            source=frame.source,
+            detections=tracked_detections,
+            image=frame.image,
+            finished_tracks=set(finished_track_ids),
+            discarded_tracks=set(discarded_track_ids),
+        )

OTVision/version.py

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

OTVision/view/view_track.py

@@ -26,7 +26,7 @@ import tkinter as tk
 from OTVision.config import CONFIG, PAD
 from OTVision.helpers.files import get_files, replace_filetype
 from OTVision.helpers.log import LOGGER_NAME
-from OTVision.track.track import main as track
+from OTVision.track.new_track import main as track
 from OTVision.view.view_helpers import FrameRun
 
 log = logging.getLogger(LOGGER_NAME)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OTVision
-Version: 0.6.0
+Version: 0.6.2
 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/
@@ -20,15 +20,16 @@ Requires-Dist: av==13.0.0
 Requires-Dist: fire==0.7.0
 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: pandas==2.2.2
+Requires-Dist: pandas==2.2.3
 Requires-Dist: pyyaml==6.0.2
 Requires-Dist: setuptools==74.0.0
 Requires-Dist: torch==2.3.1
 Requires-Dist: torchvision==0.18.1
-Requires-Dist: tqdm==4.66.5
+Requires-Dist: tqdm==4.67.1
 Requires-Dist: ujson==5.10.0
 Requires-Dist: ultralytics==8.3.74
 Description-Content-Type: text/markdown

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

@@ -1,7 +1,7 @@
 OTVision/__init__.py,sha256=b2goS-TYrN9y8WHmjG22z1oVwCrjV0WtGJE32NJfvJM,1042
 OTVision/config.py,sha256=x_Bh3mrfV434puVchuG0zLsTtjIl-_C0-ZbmRW3tyFM,24371
 OTVision/dataformat.py,sha256=BHF7qHzyNb80hI1EKfwcdJ9bgG_X4bp_hCXzdg7_MSA,1941
-OTVision/version.py,sha256=hg37ZIKD--k-ygX1n3HmsaIYwlaSQQT7L32Crd0BdTQ,175
+OTVision/version.py,sha256=fADL6JlfA7K_Y8SkaM8PKO79Wscnqe81tRANXC3Fy2U,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
@@ -26,7 +26,7 @@ OTVision/convert/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 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/cli.py,sha256=U2kXxfHWuxcsWMFfnfj_2ieOOIWw8yosYicucnddn2c,6026
+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
@@ -47,16 +47,30 @@ OTVision/domain/input_source_detect.py,sha256=9DzkTg5dh7_KmxE9oxdmxrcTYhvZY8hHLZ
 OTVision/domain/object_detection.py,sha256=gJ5Jd5uWGSjdIue-XKddb9krFynLZ59_XctMY4HE1ww,1288
 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=LMbXuLd7Nid565BtPJxv1SPqkvJhX4BF-yLJ8KMZavo,18118
+OTVision/helpers/files.py,sha256=g_ix1e_ti1ZlW4zOulvkUiupcE8KJV_OHGNGXQTQ71I,18478
 OTVision/helpers/formats.py,sha256=YLo_QLA2nhVREyv5N-xNW20c4nIL7DIF40E1lrsAyLE,4365
+OTVision/helpers/input_types.py,sha256=d94IYX0e-ersz3bl8xy9SklGUom-LjPUQ-BRsOmpH68,649
 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/iou.py,sha256=zpb4TbB34wZjUorhMLqMy6WspfsK-TkYvD75L-_ODM8,9491
-OTVision/track/iou_util.py,sha256=mqylrarqiauSewinxOm9CSa6dgVSl8G9bpCv--2m02M,4465
-OTVision/track/preprocess.py,sha256=QTKCdVWO8lj3mZ1nqDkKMLomHsiglCMYgqCe-zneick,14194
-OTVision/track/track.py,sha256=fKDP6jQ2pDLwxJOiDUYqs9fD3W67fNgwO3l8zUTYOw4,15344
+OTVision/track/track.py,sha256=BfErHX9_55unbNqVFksDku8uAjKjH5hTfdfmhXFIC3A,5060
+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/filebased/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+OTVision/track/model/filebased/frame_chunk.py,sha256=Wuz0pcgaf7P1a3EOipzDTAlCIYULC_f9DbncfKdnc50,6761
+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/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/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
@@ -66,10 +80,10 @@ OTVision/view/view.py,sha256=sBFGfr-lf8lG1BTaQ3Iu46GpZGhaVhSrqg8p5XUPJ4I,3302
 OTVision/view/view_convert.py,sha256=NUtmrmAAFCYdQS1U2av_eYUScXugQYjhD3e3H0pro6Q,5157
 OTVision/view/view_detect.py,sha256=E1JP9w5iv44hYkOr86In5d6V3sgn7Ld85KaRcY0oFZU,5951
 OTVision/view/view_helpers.py,sha256=a5yV_6ZxO5bxsSymOmxdHqzOEv0VFq4wFBopVRGuVRo,16195
-OTVision/view/view_track.py,sha256=ioHenonuTJQn8yDzlIDV8Jc1yzWA0GHbC9CotYGtxHQ,5389
+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.0.dist-info/METADATA,sha256=zVpew3Pg7uOrFOE7-a3RWmHQl56GNFWwpr2hAXNnOa0,2244
-otvision-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-otvision-0.6.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-otvision-0.6.0.dist-info/RECORD,,
+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/track/iou.py

@@ -1,282 +0,0 @@
-"""
-OTVision module to track road users in frames detected by OTVision
-"""
-
-# based on IOU Tracker written by Erik Bochinski originally licensed under the
-# MIT License, see
-# https://github.com/bochinski/iou-tracker/blob/master/LICENSE.
-
-
-# Copyright (C) 2022 OpenTrafficCam Contributors
-# <https://github.com/OpenTrafficCam
-# <team@opentrafficcam.org>
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from collections import defaultdict
-from dataclasses import dataclass
-from typing import Iterator
-
-from tqdm import tqdm
-
-from OTVision.config import CONFIG
-from OTVision.dataformat import (
-    AGE,
-    BBOXES,
-    CENTER,
-    CLASS,
-    CONFIDENCE,
-    DETECTIONS,
-    FINISHED,
-    FIRST,
-    FRAMES,
-    MAX_CLASS,
-    MAX_CONF,
-    START_FRAME,
-    TRACK_ID,
-    H,
-    W,
-    X,
-    Y,
-)
-
-from .iou_util import iou
-
-
-class TrackedDetections:
-    def __init__(
-        self,
-        detections: dict[str, dict],
-        detected_ids: set[int],
-        active_track_ids: set[int],
-    ) -> None:
-        self._detections = detections
-        self._detected_ids = detected_ids
-        self._active_track_ids = active_track_ids
-
-    def update_active_track_ids(self, new_active_ids: set[int]) -> None:
-        self._active_track_ids = {
-            _id for _id in self._active_track_ids if _id in new_active_ids
-        }
-
-    def is_finished(self) -> bool:
-        return len(self._active_track_ids) == 0
-
-
-@dataclass(frozen=True)
-class TrackingResult:
-    tracked_detections: TrackedDetections
-    active_tracks: list[dict]
-    last_track_frame: dict[int, int]
-
-
-def make_bbox(obj: dict) -> tuple[float, float, float, float]:
-    """Calculates xyxy coordinates from dict of xywh.
-
-    Args:
-        obj (dict): dict of pixel values for xcenter, ycenter, width and height
-
-    Returns:
-        tuple[float, float, float, float]: xmin, ymin, xmay, ymax
-    """
-    return (
-        obj[X] - obj[W] / 2,
-        obj[Y] - obj[H] / 2,
-        obj[X] + obj[W] / 2,
-        obj[Y] + obj[H] / 2,
-    )
-
-
-def center(obj: dict) -> tuple[float, float]:
-    """Retrieves center coordinates from dict.
-
-    Args:
-        obj (dict): _description_
-
-    Returns:
-        tuple[float, float]: _description_
-    """
-    return obj[X], obj[Y]
-
-
-def id_generator() -> Iterator[int]:
-    ID: int = 0
-    while True:
-        ID += 1
-        yield ID
-
-
-def track_iou(
-    detections: list,  # TODO: Type hint nested list during refactoring
-    sigma_l: float = CONFIG["TRACK"]["IOU"]["SIGMA_L"],
-    sigma_h: float = CONFIG["TRACK"]["IOU"]["SIGMA_H"],
-    sigma_iou: float = CONFIG["TRACK"]["IOU"]["SIGMA_IOU"],
-    t_min: int = CONFIG["TRACK"]["IOU"]["T_MIN"],
-    t_miss_max: int = CONFIG["TRACK"]["IOU"]["T_MISS_MAX"],
-    previous_active_tracks: list = [],
-    vehicle_id_generator: Iterator[int] = id_generator(),
-) -> TrackingResult:  # sourcery skip: low-code-quality
-    """
-    Simple IOU based tracker.
-    See "High-Speed Tracking-by-Detection Without Using Image Information
-    by E. Bochinski, V. Eiselein, T. Sikora" for
-    more information.
-
-    Args:
-        detections (list): list of detections per frame, usually generated
-        by util.load_mot
-        sigma_l (float): low detection threshold.
-        sigma_h (float): high detection threshold.
-        sigma_iou (float): IOU threshold.
-        t_min (float): minimum track length in frames.
-        previous_active_tracks (list): a list of remaining active tracks
-            from previous iterations.
-        vehicle_id_generator (Iterator[int]): provides ids for new tracks
-
-    Returns:
-        TrackingResult: new detections, a list of active tracks
-            and a lookup dic for each tracks last detection frame.
-    """
-
-    _check_types(sigma_l, sigma_h, sigma_iou, t_min, t_miss_max)
-
-    tracks_active: list = []
-    tracks_active.extend(previous_active_tracks)
-    # tracks_finished = []
-
-    vehIDs_finished: list = []
-    new_detections: dict = {}
-
-    for frame_num in tqdm(detections, desc="Tracked frames", unit=" frames"):
-        detections_frame = detections[frame_num][DETECTIONS]
-        # apply low threshold to detections
-        dets = [det for det in detections_frame if det[CONFIDENCE] >= sigma_l]
-        new_detections[frame_num] = {}
-        updated_tracks: list = []
-        saved_tracks: list = []
-        for track in tracks_active:
-            if dets:
-                # get det with highest iou
-                best_match = max(
-                    dets, key=lambda x: iou(track[BBOXES][-1], make_bbox(x))
-                )
-                if iou(track[BBOXES][-1], make_bbox(best_match)) >= sigma_iou:
-                    track[FRAMES].append(int(frame_num))
-                    track[BBOXES].append(make_bbox(best_match))
-                    track[CENTER].append(center(best_match))
-                    track[CONFIDENCE].append(best_match[CONFIDENCE])
-                    track[CLASS].append(best_match[CLASS])
-                    track[MAX_CONF] = max(track[MAX_CONF], best_match[CONFIDENCE])
-                    track[AGE] = 0
-
-                    updated_tracks.append(track)
-
-                    # remove best matching detection from detections
-                    del dets[dets.index(best_match)]
-                    # best_match[TRACK_ID] = track[TRACK_ID]
-                    best_match[FIRST] = False
-                    new_detections[frame_num][track[TRACK_ID]] = best_match
-
-            # if track was not updated
-            if not updated_tracks or track is not updated_tracks[-1]:
-                # finish track when the conditions are met
-                if track[AGE] < t_miss_max:
-                    track[AGE] += 1
-                    saved_tracks.append(track)
-                elif (
-                    track[MAX_CONF] >= sigma_h
-                    and track[FRAMES][-1] - track[FRAMES][0] >= t_min
-                ):
-                    # tracks_finished.append(track)
-                    vehIDs_finished.append(track[TRACK_ID])
-        # TODO: Alter der Tracks
-        # create new tracks
-        new_tracks = []
-        for det in dets:
-            vehID = next(vehicle_id_generator)
-            new_tracks.append(
-                {
-                    FRAMES: [int(frame_num)],
-                    BBOXES: [make_bbox(det)],
-                    CENTER: [center(det)],
-                    CONFIDENCE: [det[CONFIDENCE]],
-                    CLASS: [det[CLASS]],
-                    MAX_CLASS: det[CLASS],
-                    MAX_CONF: det[CONFIDENCE],
-                    TRACK_ID: vehID,
-                    START_FRAME: int(frame_num),
-                    AGE: 0,
-                }
-            )
-            # det[TRACK_ID] = vehID
-            det[FIRST] = True
-            new_detections[frame_num][vehID] = det
-        tracks_active = updated_tracks + saved_tracks + new_tracks
-
-    # finish all remaining active tracks
-    # tracks_finished += [
-    #     track
-    #     for track in tracks_active
-    #     if (
-    #         track["max_conf"] >= sigma_h
-    #         and track["frames"][-1] - track["frames"][0] >= t_min
-    #     )
-    # ]
-
-    # for track in tracks_finished:
-    #     track["max_class"] = pd.Series(track["class"]).mode().iat[0]
-
-    # TODO: #82 Use dict comprehensions in track_iou
-    # save last occurrence frame of tracks
-    last_track_frame: dict[int, int] = defaultdict(lambda: -1)
-
-    for frame_num, frame_det in tqdm(
-        new_detections.items(), desc="New detection frames", unit=" frames"
-    ):
-        for vehID, det in frame_det.items():
-            det[FINISHED] = False
-            det[TRACK_ID] = vehID
-            last_track_frame[vehID] = max(frame_num, last_track_frame[vehID])
-
-    # return tracks_finished
-    # TODO: #83 Remove unnecessary code (e.g. for tracks_finished) from track_iou
-
-    active_track_ids = {t[TRACK_ID] for t in tracks_active}
-    detected_ids = set(last_track_frame.keys())
-    return TrackingResult(
-        TrackedDetections(
-            detections=new_detections,
-            detected_ids=detected_ids,
-            active_track_ids={_id for _id in detected_ids if _id in active_track_ids},
-        ),
-        active_tracks=tracks_active,
-        last_track_frame=last_track_frame,
-    )
-    # return new_detections, tracks_active, last_track_frame
-
-
-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")