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

OTVision/track/track.py

@@ -1,144 +1,65 @@
 import logging
-import uuid
-from pathlib import Path
-from typing import Callable, Iterator
 
 from tqdm import tqdm
 
-from OTVision import dataformat
-from OTVision.config import (
-    CONFIG,
-    DETECT,
-    FILETYPES,
-    IOU,
-    OVERWRITE,
-    SIGMA_H,
-    SIGMA_IOU,
-    SIGMA_L,
-    T_MIN,
-    T_MISS_MAX,
-    TRACK,
-)
+from OTVision.application.config import Config
+from OTVision.application.get_current_config import GetCurrentConfig
 from OTVision.helpers.files import get_files
 from OTVision.helpers.input_types import check_types
 from OTVision.helpers.log import LOGGER_NAME
-from OTVision.track.exporter.filebased_exporter import FinishedChunkTrackExporter
-from OTVision.track.parser.chunk_parser_plugins import JsonChunkParser
-from OTVision.track.parser.frame_group_parser_plugins import (
-    TimeThresholdFrameGroupParser,
-)
-from OTVision.track.tracker.filebased_tracking import (
-    GroupedFilesTracker,
-    UnfinishedChunksBuffer,
-)
-from OTVision.track.tracker.tracker_plugin_iou import IouParameters, IouTracker
-
-
-def track_id_generator() -> Iterator[int]:
-    ID: int = 0
-    while True:
-        ID += 1
-        yield ID
-
+from OTVision.track.id_generator import StrIdGenerator, tracking_run_uuid_generator
+from OTVision.track.model.track_exporter import FinishedTracksExporter
+from OTVision.track.tracker.filebased_tracking import UnfinishedChunksBuffer
 
 log = logging.getLogger(LOGGER_NAME)
-STR_ID_GENERATOR = Callable[[], str]
-
-
-def tracker_metadata(
-    sigma_l: float, sigma_h: float, sigma_iou: float, t_min: float, t_miss_max: float
-) -> dict:
-    return {
-        dataformat.NAME: "IOU",
-        dataformat.SIGMA_L: sigma_l,
-        dataformat.SIGMA_H: sigma_h,
-        dataformat.SIGMA_IOU: sigma_iou,
-        dataformat.T_MIN: t_min,
-        dataformat.T_MISS_MAX: t_miss_max,
-    }
-
-
-def main(
-    paths: list[Path],
-    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],
-    overwrite: bool = CONFIG[TRACK][OVERWRITE],
-    tracking_run_id_generator: STR_ID_GENERATOR = lambda: str(uuid.uuid4()),
-) -> None:
-    """Read detections from otdet file, perform tracking using iou tracker and
-        save tracks to ottrk file.
-
-    Args:
-        paths (list[Path]): List of paths to detection files.
-        sigma_l (float, optional): Lower confidence threshold. Detections with
-            confidences below sigma_l are not even considered for tracking.
-            Defaults to CONFIG["TRACK"]["IOU"]["SIGMA_L"].
-        sigma_h (float, optional): Upper confidence threshold. Tracks are only
-            considered as valid if they contain at least one detection with a confidence
-            above sigma_h.
-            Defaults to CONFIG["TRACK"]["IOU"]["SIGMA_H"].
-        sigma_iou (float, optional): Intersection-Over-Union threshold. Two detections
-            in subsequent frames are considered to belong to the same track if their IOU
-            value exceeds sigma_iou and this is the highest IOU of all possible
-            combination of detections.
-            Defaults to CONFIG["TRACK"]["IOU"]["SIGMA_IOU"].
-        t_min (int, optional): Minimum number of detections to count as a valid track.
-            All tracks with less detections will be dissmissed.
-            Defaults to CONFIG["TRACK"]["IOU"]["T_MIN"].
-        t_miss_max (int, optional): Maximum number of missed detections before
-            continuing a track. If more detections are missing, the track will not be
-            continued.
-            Defaults to CONFIG["TRACK"]["IOU"]["T_MISS_MAX"].
-        overwrite (bool, optional): Whether or not to overwrite existing tracks files.
-            Defaults to CONFIG["TRACK"]["OVERWRITE"].
-        tracking_run_id_generator (IdGenerator): Generator used to create a unique id
-            for this tracking run
-    """
-
-    check_types(sigma_l, sigma_h, sigma_iou, t_min, t_miss_max)
-
-    filetypes = CONFIG[FILETYPES][DETECT]
-    detections_files = get_files(paths=paths, filetypes=filetypes)
-
-    start_msg = f"Start tracking of {len(detections_files)} detections files"
-    log.info(start_msg)
-    print(start_msg)
-
-    if not detections_files:
-        log.warning(f"No files of type '{filetypes}' found to track!")
-        return
-
-    iou_tracker: IouTracker = IouTracker(
-        parameters=IouParameters(sigma_l, sigma_h, sigma_iou, t_min, t_miss_max)
-    )
-
-    chunk_parser = JsonChunkParser()
-    group_parser = TimeThresholdFrameGroupParser(
-        tracker_data=tracker_metadata(sigma_l, sigma_h, sigma_iou, t_min, t_miss_max)
-    )
-
-    file_tracker = GroupedFilesTracker(
-        tracker=iou_tracker,
-        chunk_parser=chunk_parser,
-        frame_group_parser=group_parser,
-        id_generator_factory=lambda _: track_id_generator(),
-        overwrite=True,
-    )
-
-    buffer = UnfinishedChunksBuffer(
-        tracker=file_tracker,
-        keep_discarded=True,
-    )
-
-    exporter = FinishedChunkTrackExporter()
 
-    tracking_run_id = tracking_run_id_generator()
-    finished_chunk_stream = buffer.group_and_track(detections_files)
 
-    finished_chunk_progress = tqdm(
-        finished_chunk_stream, desc="export FrameChunk", total=len(detections_files)
-    )
-    exporter.export(tracking_run_id, iter(finished_chunk_progress), overwrite)
+class OtvisionTrack:
+    @property
+    def config(self) -> Config:
+        return self._get_current_config.get()
+
+    def __init__(
+        self,
+        get_current_config: GetCurrentConfig,
+        track_exporter: FinishedTracksExporter,
+        unfinished_chunks_buffer: UnfinishedChunksBuffer,
+        tracking_run_id_generator: StrIdGenerator = tracking_run_uuid_generator,
+    ) -> None:
+        self._get_current_config = get_current_config
+        self._track_exporter = track_exporter
+        self._buffer = unfinished_chunks_buffer
+        self._tracking_run_id_generator = tracking_run_id_generator
+
+    def start(self) -> None:
+        check_types(
+            self.config.track.sigma_l,
+            self.config.track.sigma_h,
+            self.config.track.sigma_iou,
+            self.config.track.t_min,
+            self.config.track.t_miss_max,
+        )
+
+        detections_files = get_files(
+            paths=self.config.track.paths, filetypes=[self.config.filetypes.detect]
+        )
+
+        start_msg = f"Start tracking of {len(detections_files)} detections files"
+        log.info(start_msg)
+        print(start_msg)
+
+        if not detections_files:
+            log.warning(
+                f"No files of type '{self.config.filetypes.detect}' " "found to track!"
+            )
+            return
+
+        tracking_run_id = self._tracking_run_id_generator()
+        finished_chunk_stream = self._buffer.group_and_track(detections_files)
+
+        finished_chunk_progress = tqdm(
+            finished_chunk_stream, desc="export FrameChunk", total=len(detections_files)
+        )
+        self._track_exporter.export(
+            tracking_run_id, iter(finished_chunk_progress), self.config.track.overwrite
+        )

OTVision/track/tracker/filebased_tracking.py

@@ -5,7 +5,8 @@ from typing import Callable, Iterator
 from more_itertools import peekable
 from tqdm import tqdm
 
-from OTVision.config import CONFIG, DEFAULT_FILETYPE, OVERWRITE, TRACK
+from OTVision.application.config import DEFAULT_FILETYPE, OVERWRITE, TRACK
+from OTVision.config import CONFIG
 from OTVision.domain.detection import TrackId
 from OTVision.domain.frame import DetectedFrame, FrameNo, IsLastFrame, TrackedFrame
 from OTVision.helpers.log import LOGGER_NAME
@@ -17,7 +18,7 @@ from OTVision.track.model.filebased.frame_chunk import (
 )
 from OTVision.track.model.filebased.frame_group import FrameGroup, FrameGroupParser
 from OTVision.track.model.tracking_interfaces import (
-    ID_GENERATOR,
+    IdGenerator,
     Tracker,
     UnfinishedTracksBuffer,
 )
@@ -35,7 +36,7 @@ class ChunkBasedTracker(Tracker):
     def track_frame(
         self,
         frames: DetectedFrame,
-        id_generator: ID_GENERATOR,
+        id_generator: IdGenerator,
     ) -> TrackedFrame:
         return self._tracker.track_frame(frames, id_generator)
 
@@ -43,7 +44,7 @@ class ChunkBasedTracker(Tracker):
         self,
         chunk: FrameChunk,
         is_last_chunk: bool,
-        id_generator: ID_GENERATOR,
+        id_generator: IdGenerator,
     ) -> TrackedChunk:
         frames_progress = tqdm(
             chunk.frames, desc="track Frame", total=len(chunk.frames), leave=False
@@ -63,14 +64,14 @@ class ChunkBasedTracker(Tracker):
         file: Path,
         frame_group: FrameGroup,
         is_last_file: bool,
-        id_generator: ID_GENERATOR,
+        id_generator: IdGenerator,
         frame_offset: int = 0,
     ) -> TrackedChunk:
         chunk = self._chunk_parser.parse(file, frame_group, frame_offset)
         return self.track_chunk(chunk, is_last_file, id_generator)
 
 
-ID_GENERATOR_FACTORY = Callable[[FrameGroup], ID_GENERATOR]
+IdGeneratorFactory = Callable[[FrameGroup], IdGenerator]
 
 
 class GroupedFilesTracker(ChunkBasedTracker):
@@ -80,7 +81,7 @@ class GroupedFilesTracker(ChunkBasedTracker):
         tracker: Tracker,
         chunk_parser: ChunkParser,
         frame_group_parser: FrameGroupParser,
-        id_generator_factory: ID_GENERATOR_FACTORY,
+        id_generator_factory: IdGeneratorFactory,
         overwrite: bool = CONFIG[TRACK][OVERWRITE],
         file_type: str = CONFIG[DEFAULT_FILETYPE][TRACK],
     ) -> None:

OTVision/track/tracker/tracker_plugin_iou.py

@@ -1,8 +1,10 @@
 from dataclasses import dataclass
 
+from OTVision.application.config import TrackConfig
+from OTVision.application.get_current_config import GetCurrentConfig
 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
+from OTVision.track.model.tracking_interfaces import IdGenerator, Tracker
 
 
 @dataclass(frozen=True)
@@ -138,34 +140,37 @@ def iou(
 
 
 class IouTracker(Tracker):
+    @property
+    def config(self) -> TrackConfig:
+        return self._get_current_config.get().track
 
-    def __init__(self, parameters: IouParameters):
+    def __init__(self, get_current_config: GetCurrentConfig):
         super().__init__()
-        self.parameters = parameters
+        self._get_current_config = get_current_config
         self.active_tracks: list[ActiveIouTrack] = []
 
     @property
     def sigma_l(self) -> float:
-        return self.parameters.sigma_l
+        return self.config.iou.sigma_l
 
     @property
     def sigma_h(self) -> float:
-        return self.parameters.sigma_h
+        return self.config.iou.sigma_h
 
     @property
     def sigma_iou(self) -> float:
-        return self.parameters.sigma_iou
+        return self.config.iou.sigma_iou
 
     @property
     def t_min(self) -> int:
-        return self.parameters.t_min
+        return self.config.iou.t_min
 
     @property
     def t_miss_max(self) -> int:
-        return self.parameters.t_miss_max
+        return self.config.iou.t_miss_max
 
     def track_frame(
-        self, frame: DetectedFrame, id_generator: ID_GENERATOR
+        self, frame: DetectedFrame, id_generator: IdGenerator
     ) -> TrackedFrame:
 
         detections = [d for d in frame.detections if d.conf >= self.sigma_l]
@@ -217,6 +222,7 @@ class IouTracker(Tracker):
             no=frame.no,
             occurrence=frame.occurrence,
             source=frame.source,
+            output=frame.output,
             detections=tracked_detections,
             image=frame.image,
             finished_tracks=set(finished_track_ids),

OTVision/transform/transform.py

@@ -31,8 +31,7 @@ import numpy as np
 import pandas as pd
 from tqdm import tqdm
 
-from OTVision.config import (
-    CONFIG,
+from OTVision.application.config import (
     DEFAULT_FILETYPE,
     FILETYPES,
     OVERWRITE,
@@ -40,6 +39,7 @@ from OTVision.config import (
     TRACK,
     TRANSFORM,
 )
+from OTVision.config import CONFIG
 from OTVision.helpers.files import (
     get_files,
     get_metadata,

OTVision/version.py

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

otvision-0.6.6.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: OTVision
+Version: 0.6.6
+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/
+Project-URL: Repository, https://github.com/OpenTrafficCam/OTVision
+Project-URL: Issues, https://github.com/OpenTrafficCam/OTVision/issues
+Project-URL: Changelog, https://github.com/OpenTrafficCam/OTVision/releases
+Author-email: OpenTrafficCam contributors <team@opentrafficcam.org>, platomo GmbH <info@platomo.de>
+License-Expression: GPL-3.0-only
+License-File: LICENSE
+Keywords: OpenTrafficCam,Traffic Analysis,Traffic Counting,Trajectories
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+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; sys_platform == 'win32'
+Requires-Dist: numpy==2.1.1; sys_platform != 'win32'
+Requires-Dist: opencv-python==4.10.0.84
+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.67.1
+Requires-Dist: ujson==5.10.0
+Requires-Dist: ultralytics==8.3.94
+Description-Content-Type: text/markdown
+
+# OTVision
+
+[![PyPI version](https://img.shields.io/pypi/v/OTVision.svg)](https://pypi.org/project/OTVision/)
+[![Tests](https://github.com/OpenTrafficCam/OTVision/actions/workflows/test.yml/badge.svg?tag=latest)](https://github.com/OpenTrafficCam/OTVision/actions/workflows/test.yml?query=tag%3Alatest)
+[![Tests](https://github.com/OpenTrafficCam/OTVision/actions/workflows/build-release.yml/badge.svg)](https://github.com/OpenTrafficCam/OTVision/actions/workflows/build-release.yml)
+
+OTVision is a core module of the [OpenTrafficCam framework](https://github.com/OpenTrafficCam) designed to detect and track objects (road users) in videos recorded by [OTCamera](https://github.com/OpenTrafficCam/OTCamera) or other camera systems. The resulting trajectories can be used for traffic analysis using [OTAnalytics](https://github.com/OpenTrafficCam/OTAnalytics).
+
+## Features
+
+- **Video Conversion**: Convert video files (h264 to mp4) with options to set frame rate and rotation
+- **Object Detection**: Detect road users in videos using state-of-the-art YOLO models
+- **Object Tracking**: Track detected objects through video frames using IOU-based tracking algorithms
+- **Coordinate Transformation**: Transform pixel coordinates to real-world UTM coordinates
+
+## Requirements
+
+### System Requirements
+
+- Python 3.12 or higher
+- CUDA-capable GPU (recommended for faster processing)
+- Dependencies listed in [requirements.txt](requirements.txt)
+
+## Installation
+
+### Installation from GitHub Releases
+
+Pre-built releases are available on GitHub for easy installation:
+
+1. Go to the [OTVision Releases page](https://github.com/OpenTrafficCam/OTVision/releases) on GitHub
+2. Download the appropriate release for your platform:
+   - **Windows**: Choose between `otvision-win.zip` (standard) or `otvision-win-cuda.zip` (with CUDA support)
+   - **Linux**: Choose between `otvision-linux.zip` (standard) or `otvision-linux-cuda.zip` (with CUDA support)
+   - **macOS**: Choose `OTVision-macos.zip`
+3. Extract the downloaded ZIP file
+4. Run the installation script:
+   - On Windows: Double-click `install.cmd`
+   - On Linux: Run `./install.sh`
+   - On macOS: Double-click `install.command`
+
+### Manual Installation
+
+1. Clone the repository:
+
+   ```bash
+   git clone https://github.com/OpenTrafficCam/OTVision.git
+   cd OTVision
+   ```
+
+2. Install the package:
+   - On Windows:
+     ```cmd
+     install.cmd
+     ```
+   - On Linux/macOS:
+     ```bash
+     ./install.sh
+     ```
+
+### Manual Development Installation
+
+For development purposes, if you want to contribute to the project:
+
+1. Clone the repository:
+
+   ```bash
+   git clone https://github.com/OpenTrafficCam/OTVision.git
+   cd OTVision
+   ```
+
+2. Install the development version:
+   - On Windows:
+     ```cmd
+     install_dev.cmd
+     ```
+   - On Linux/macOS:
+     ```bash
+     ./install_dev.sh
+     ```
+
+## Usage
+
+OTVision provides several command-line scripts for different functionalities:
+
+### Video Conversion
+
+Convert video files (e.g., h264 to mp4):
+
+```bash
+python convert.py --paths /path/to/videos/*.h264 --input-fps 20.0 --rotation 0
+```
+
+### Object Detection
+
+Detect objects in videos:
+
+```bash
+python detect.py --paths /path/to/videos/*.mp4 --weights yolov8s
+```
+
+### Object Tracking
+
+Track detected objects:
+
+```bash
+python track.py --paths /path/to/detections/*.otdet
+```
+
+### Coordinate Transformation
+
+Transform pixel coordinates to UTM coordinates:
+
+```bash
+python transform.py --paths /path/to/tracks/*.ottrk --refpts-file /path/to/reference_points.json
+```
+
+### Configuration
+
+OTVision can be configured using a YAML configuration file. A default configuration is provided in `user_config.otvision.yaml`. You can specify a custom configuration file using the `--config` option:
+
+```bash
+python detect.py --config /path/to/custom_config.yaml
+```
+
+## Documentation
+
+For detailed documentation, visit:
+
+- [OTVision Documentation](https://opentrafficcam.org/OTVision/)
+- [Getting Started Guide](https://opentrafficcam.org/OTVision/gettingstarted/firstuse/)
+- [Requirements](https://opentrafficcam.org/OTVision/gettingstarted/requirements/)
+- [Installation Guide](https://opentrafficcam.org/OTVision/gettingstarted/installation/)
+
+## Contributing
+
+We appreciate your support in the form of both code and comments. Please have a look at the [contribute](https://opentrafficcam.org/contribute) section of the OpenTrafficCam documentation for guidelines on how to contribute to the project.
+
+## License
+
+This software is licensed under the [GPL-3.0 License](LICENSE).
+
+## Contact
+
+- GitHub: [https://github.com/OpenTrafficCam](https://github.com/OpenTrafficCam)
+- Email: [team@opentrafficcam.org](mailto:team@opentrafficcam.org)