OTVision 0.5.3__py3-none-any.whl

OTVision/helpers/log.py

@@ -0,0 +1,131 @@
+"""
+OTVision helpers for logging
+"""
+
+# 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/>.
+
+
+import logging
+import sys
+from datetime import datetime
+from pathlib import Path
+
+LOGGER_NAME = "OTVision Logger"
+
+DEFAULT_LOG_NAME = f"{datetime.now().strftime(r'%Y-%m-%d_%H-%M-%S')}"
+LOG_EXT = "log"
+DEFAULT_LOG_FILE = Path(f"logs/{DEFAULT_LOG_NAME}.{LOG_EXT}")
+
+VALID_LOG_LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+LOG_FORMAT: str = (
+    "%(asctime)s %(levelname)s (%(filename)s::%(funcName)s::%(lineno)d): %(message)s"
+)
+
+LOG_LEVEL_INTEGERS = {
+    "DEBUG": 10,
+    "INFO": 20,
+    "WARNING": 30,
+    "ERROR": 40,
+    "CRITICAL": 50,
+}
+
+
+class LogFileAlreadyExists(Exception):
+    pass
+
+
+class _OTVisionLogger:
+    """Class for creating a logging.Logger.
+    Should only be instantiated once in the same module as this class.
+    To access this instance, use logging.getLogger(LOGGER_NAME)
+    with LOGGER_NAME from the same module where this class is defined.
+    """
+
+    def __init__(self, name: str = LOGGER_NAME) -> None:
+        self.logger = logging.getLogger(name=name)
+        self.logger.setLevel("DEBUG")
+        self._set_formatter()
+
+    def _set_formatter(self) -> None:
+        self.formatter = logging.Formatter(LOG_FORMAT)
+
+    def _add_handler(self, handler: logging.Handler, level: str) -> None:
+        handler.setFormatter(self.formatter)
+        handler.setLevel(level=level)
+        self.logger.addHandler(handler)
+
+    def add_file_handler(
+        self,
+        log_file: Path = DEFAULT_LOG_FILE,
+        level: str = "DEBUG",
+        overwrite: bool = False,
+    ) -> None:
+        """Add a file handler to the already existing global instance of
+        _OTVisionLogger.
+
+        Should only be used once in each of OTVisions command line or
+        graphical user interfaces.
+
+        Args:
+            log_file (Path): file path to write the logs. Defaults to None.
+            level (str): Logging level of the file handler.
+                One from "DEBUG", "INFO", "WARNING", "ERROR" or "CRITICAL".
+            overwrite (bool): if True, overwrite existing log file. Defaults to False.
+
+        IMPORTANT:
+            log_file and level are not intended to be optional, they have to be provided
+            in every case. The default values provided are a safety net.
+        """
+        if log_file.exists() and not overwrite:
+            raise LogFileAlreadyExists(
+                f"Log file '{log_file}' already exists. "
+                "Please specify option to overwrite the log file when using the CLI."
+            )
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        log_file.touch()
+        file_handler = logging.FileHandler(log_file, mode="w")
+        self._add_handler(file_handler, level)
+
+    def add_console_handler(self, level: str = "WARNING") -> None:
+        """Add a console handler to the already existing global instance of
+        _OTVisionLogger.
+        Should only be used once in each of OTVisions command line or
+        graphical user interfaces.
+
+        Args:
+            level (str): Logging level of the console handler.
+                One from "DEBUG", "INFO", "WARNING", "ERROR" or "CRITICAL".
+                Defaults to "WARNING".
+
+        IMPORTANT:
+            level is not intended to be optional, it has to be provided
+            in every case. The default value provided is a safety net.
+        """
+        console_handler = logging.StreamHandler(sys.stdout)
+        self._add_handler(console_handler, level)
+
+    def _remove_handlers(self) -> None:
+        for handler in self.logger.handlers:
+            self.logger.removeHandler(handler)
+
+
+# This here should be the only time the _OTVisionLogger is "directly" instantiated
+# In all other module that should be logged from, use logging.getLogger(LOGGER_NAME)
+
+log = _OTVisionLogger()

OTVision/helpers/machine.py

@@ -0,0 +1,71 @@
+"""
+OTVision helpers to gather information about the machine and the system
+"""
+
+# 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/>.
+
+
+import platform
+
+OS = platform.system().replace("Darwin", "Mac")
+"""OS OTVision is currently running on"""
+
+ON_WINDOWS = OS == "Windows"
+"""Wether OS is Windows or not"""
+
+ON_LINUX = OS == "Linux"
+"""Wether OS is Linux or not"""
+
+ON_MAC = OS == "Mac"
+"""Wether OS is MacOS or not"""
+
+OS_RELEASE = platform.release()
+"""Release of the OS OTVision is currently running on"""
+
+OS_VERSION = platform.version()
+"""Specific version of the OS OTVision is currently running on"""
+
+PY_MAJOR_VERSION = int(platform.python_version_tuple()[0])
+"""Python major version digit (e.g. 3 for 3.9.5) OTVision is currently running with"""
+
+PY_MINOR_VERSION = int(platform.python_version_tuple()[1])
+"""Python minor version digit (e.g. 9 for 3.9.5) OTVision is currently running with"""
+
+PY_PATCH_VERSION = int(platform.python_version_tuple()[2])
+"""Python patch version digit (e.g. 5 for 3.9.5) OTVision is currently running with"""
+
+
+def _has_cuda() -> bool:
+    """Returns True if CUDA is installed on machine
+
+    Returns:
+        Bool: If CUDA is installed on machine or not
+    """
+    import torch
+
+    return torch.cuda.is_available()
+
+
+def print_has_cuda() -> None:
+    """Returns True if CUDA is installed on machine
+
+    Returns:
+        Bool: If CUDA is installed on machine or not
+    """
+
+    print(f"This system has cuda: {_has_cuda()}")

OTVision/helpers/video.py

@@ -0,0 +1,54 @@
+from datetime import timedelta
+from pathlib import Path
+
+from moviepy.video.io.VideoFileClip import VideoFileClip
+
+
+def get_video_dimensions(video: Path) -> tuple[int, int]:
+    """Get video width and height.
+
+    Args:
+        video (Path): the video file
+
+    Returns:
+        tuple[int, int]: width and height of video
+    """
+    with VideoFileClip(str(video)) as clip:
+        video_dimensions = clip.size
+        return video_dimensions
+
+
+def get_fps(video: Path) -> float:
+    """Get video's fps.
+
+    Args:
+        video (Path): the video file
+
+    Returns:
+        float: the video's fps
+    """
+    with VideoFileClip(str(video)) as clip:
+        fps = clip.fps
+        return fps
+
+
+def get_duration(video_file: Path) -> timedelta:
+    """Get the duration of the video
+    Args:
+        video_file (Path): path to video file
+    Returns:
+        timedelta: duration of the video
+    """
+    with VideoFileClip(str(video_file.absolute())) as clip:
+        return timedelta(seconds=clip.duration)
+
+
+def get_number_of_frames(video_file: Path) -> int:
+    """Get the number of frames of the video
+    Args:
+        video_file (Path): path to video file
+    Returns:
+        timedelta: number of frames of the video
+    """
+    with VideoFileClip(str(video_file.absolute())) as clip:
+        return clip.reader.nframes

OTVision/track/iou.py

@@ -0,0 +1,282 @@
+"""
+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")

OTVision/track/iou_util.py

@@ -0,0 +1,140 @@
+"""
+Utils for using iou tracker
+"""
+
+# ---------------------------------------------------------
+# IOU Tracker
+# Copyright (c) 2017 TU Berlin, Communication Systems Group
+# Licensed under The MIT License, see
+# https://github.com/bochinski/iou-tracker/blob/master/LICENSE
+# for details.
+# Written by Erik Bochinski
+# ---------------------------------------------------------
+
+from typing import Union
+
+import numpy as np
+
+
+# TODO: Remove if not needed
+def nms(
+    boxes: np.ndarray,
+    scores: np.ndarray,
+    overlapThresh: float,
+    classes: Union[np.ndarray, None] = None,
+) -> Union[tuple[np.ndarray, np.ndarray, np.ndarray], tuple[np.ndarray, np.ndarray]]:
+    """
+    perform non-maximum suppression. based on Malisiewicz et al.
+    Args:
+        boxes (numpy.ndarray): boxes to process
+        scores (numpy.ndarray): corresponding scores for each box
+        overlapThresh (float): overlap threshold for boxes to merge
+        classes (numpy.ndarray, optional): class ids for each box.
+
+    Returns:
+        (tuple): tuple containing:
+
+        boxes (list): nms boxes
+        scores (list): nms scores
+        classes (list, optional): nms classes if specified
+    """
+    # # if there are no boxes, return an empty list
+    # if len(boxes) == 0:
+    #     return [], [], [] if classes else [], []
+
+    # if the bounding boxes integers, convert them to floats --
+    # this is important since we'll be doing a bunch of divisions
+    if boxes.dtype.kind == "i":
+        boxes = boxes.astype("float")
+
+    if scores.dtype.kind == "i":
+        scores = scores.astype("float")
+
+    # initialize the list of picked indexes
+    pick = []
+
+    # grab the coordinates of the bounding boxes
+    x1 = boxes[:, 0]
+    y1 = boxes[:, 1]
+    x2 = boxes[:, 2]
+    y2 = boxes[:, 3]
+    # score = boxes[:, 4]
+    # compute the area of the bounding boxes and sort the bounding
+    # boxes by the bottom-right y-coordinate of the bounding box
+    area = (x2 - x1 + 1) * (y2 - y1 + 1)
+    idxs = np.argsort(scores)
+
+    # keep looping while some indexes still remain in the indexes
+    # list
+    while len(idxs) > 0:
+        # grab the last index in the indexes list and add the
+        # index value to the list of picked indexes
+        last = len(idxs) - 1
+        i = idxs[last]
+        pick.append(i)
+
+        # find the largest (x, y) coordinates for the start of
+        # the bounding box and the smallest (x, y) coordinates
+        # for the end of the bounding box
+        xx1 = np.maximum(x1[i], x1[idxs[:last]])
+        yy1 = np.maximum(y1[i], y1[idxs[:last]])
+        xx2 = np.minimum(x2[i], x2[idxs[:last]])
+        yy2 = np.minimum(y2[i], y2[idxs[:last]])
+
+        # compute the width and height of the bounding box
+        w = np.maximum(0, xx2 - xx1 + 1)
+        h = np.maximum(0, yy2 - yy1 + 1)
+
+        # compute the ratio of overlap
+        overlap = (w * h) / area[idxs[:last]]
+
+        # delete all indexes from the index list that have
+        idxs = np.delete(
+            idxs,
+            np.concatenate((np.array([last]), np.where(overlap > overlapThresh)[0])),
+        )
+
+    if classes is not None:
+        return boxes[pick], scores[pick], classes[pick]
+    else:
+        return boxes[pick], scores[pick]
+
+
+def iou(
+    bbox1: Union[list[float], tuple[float, float, float, float]],
+    bbox2: Union[list[float], tuple[float, float, float, float]],
+) -> float:
+    """
+    Calculates the intersection-over-union of two bounding boxes.
+
+    Args:
+        bbox1 (list of floats): bounding box in format x1,y1,x2,y2.
+        bbox2 (list of floats): bounding box in format x1,y1,x2,y2.
+
+    Returns:
+        int: intersection-over-onion of bbox1, bbox2
+    """
+
+    bbox1 = [float(x) for x in bbox1]
+    bbox2 = [float(x) for x in bbox2]
+
+    (x0_1, y0_1, x1_1, y1_1) = bbox1
+    (x0_2, y0_2, x1_2, y1_2) = bbox2
+
+    # get the overlap rectangle
+    overlap_x0 = max(x0_1, x0_2)
+    overlap_y0 = max(y0_1, y0_2)
+    overlap_x1 = min(x1_1, x1_2)
+    overlap_y1 = min(y1_1, y1_2)
+
+    # check if there is an overlap
+    if overlap_x1 - overlap_x0 <= 0 or overlap_y1 - overlap_y0 <= 0:
+        return 0
+
+    # if yes, calculate the ratio of the overlap to each ROI size and the unified size
+    size_1 = (x1_1 - x0_1) * (y1_1 - y0_1)
+    size_2 = (x1_2 - x0_2) * (y1_2 - y0_2)
+    size_intersection = (overlap_x1 - overlap_x0) * (overlap_y1 - overlap_y0)
+    size_union = size_1 + size_2 - size_intersection
+
+    return size_intersection / size_union