OTVision 0.5.3__py3-none-any.whl

OTVision/transform/transform.py

@@ -0,0 +1,352 @@
+"""
+OTVision main module for transforming tracks from pixel to world coordinates
+"""
+
+# 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
+from copy import deepcopy
+from pathlib import Path
+from typing import Union
+
+import cv2
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+from OTVision.config import (
+    CONFIG,
+    DEFAULT_FILETYPE,
+    FILETYPES,
+    OVERWRITE,
+    REFPTS,
+    TRACK,
+    TRANSFORM,
+)
+from OTVision.helpers.files import (
+    get_files,
+    get_metadata,
+    read_json,
+    replace_filetype,
+    write_json,
+)
+from OTVision.helpers.formats import _get_epsg_from_utm_zone, _ottrk_detections_to_df
+from OTVision.helpers.log import LOGGER_NAME
+
+from .get_homography import get_homography
+
+log = logging.getLogger(LOGGER_NAME)
+
+
+def main(
+    paths: list[Path],
+    refpts_file: Union[Path, None] = None,
+    overwrite: bool = CONFIG[TRANSFORM][OVERWRITE],
+) -> None:  # sourcery skip: merge-dict-assign
+    """Transform tracks files containing trajectories in pixel coordinates to .gpkg
+    files with trajectories in utm coordinates using either one single refpts file for
+    all tracks files containing corresponding reference points in both pixel and utm
+    coordinates or using specific refpts files for each tracks file
+    (path must be the same except for the extension).
+    Info: refpts file can be created using OTVision.transform.reference_points_picker
+
+    Args:
+        paths (list[Path]): List of paths to tracks files.
+        refpts_file (Path, optional): Path to reference points file.
+            If given, this file will be used for transformation of all tracks files.
+            If not given, for every tracks file a refpts file with same stem is needed.
+            Defaults to None.
+        overwrite (bool, optional): Whether or not to overwrite existing tracks files in
+            world coordinates.
+            Defaults to CONFIG["TRANSFORM"]["OVERWRITE"].
+    """
+
+    track_filetype = CONFIG[FILETYPES][TRACK]
+
+    if refpts_file:
+        log.info(f"Reading global reference points file at {refpts_file}")
+
+        refpts_filetype = CONFIG[FILETYPES][REFPTS]
+
+        if not refpts_file.exists():
+            raise FileNotFoundError(
+                f"No reference points file with filetype: '{refpts_filetype}' found!"
+            )
+
+        refpts = read_refpts(reftpts_file=refpts_file)
+        (
+            homography,
+            refpts_utm_upshift_predecimal,
+            upshift_utm,
+            utm_zone,
+            hemisphere,
+            homography_eval_dict,
+        ) = get_homography(refpts=refpts)
+
+        log.info("Successfully read reference points file")
+
+    tracks_files = get_files(paths=paths, filetypes=CONFIG[FILETYPES][TRACK])
+
+    start_msg = f"Start transformation of {len(tracks_files)} video files"
+    log.info(start_msg)
+    print(start_msg)
+
+    if not tracks_files:
+        raise FileNotFoundError(
+            f"No files of type '{track_filetype}' found to transform!"
+        )
+
+    for tracks_file in tqdm(
+        tracks_files, desc="Transformed track files", unit=" files"
+    ):
+        gpkg_file = tracks_file.with_suffix(".gpkg")
+
+        if not overwrite and gpkg_file.is_file():
+            log.warning(
+                f"{gpkg_file} already exists. To overwrite, set overwrite to True"
+            )
+            continue
+
+        log.info(f"Transform {tracks_file}")
+
+        # Try reading refpts and getting homography if not done above
+        if not refpts_file:
+            associated_refpts_file = replace_filetype(
+                files=[tracks_file], new_filetype=CONFIG[DEFAULT_FILETYPE][REFPTS]
+            )[0]
+            if not associated_refpts_file.exists():
+                raise FileNotFoundError(
+                    f"No reference points file found for tracks file: {tracks_file}!"
+                )
+
+            log.info(f"Found associated refpts file {associated_refpts_file}")
+            refpts = read_refpts(reftpts_file=associated_refpts_file)
+            log.info("Read read associated refpts file")
+            (
+                homography,
+                refpts_utm_upshift_predecimal,
+                upshift_utm,
+                utm_zone,
+                hemisphere,
+                homography_eval_dict,
+            ) = get_homography(refpts=refpts)
+
+            log.debug("Homography matrix created")
+
+        # Read tracks
+        tracks_px_df, metadata_dict = read_tracks(tracks_file)
+        log.debug("Tracks read")
+
+        # Actual transformation
+        tracks_utm_df = transform(
+            tracks_px=tracks_px_df,
+            homography=homography,
+            refpts_utm_upshifted_predecimal_pt1_1row=refpts_utm_upshift_predecimal,
+            upshift_utm=upshift_utm,
+        )
+
+        log.debug("Tracks transformed")
+
+        # Add crs information tp metadata dict
+        # TODO: Declare constant for the dictionary keys
+        metadata_dict["transformer"] = {}
+        metadata_dict["transformer"]["utm"] = True
+        metadata_dict["transformer"]["utm_zone"] = utm_zone
+        metadata_dict["transformer"]["hemisphere"] = hemisphere
+        metadata_dict["transformer"]["epsg"] = _get_epsg_from_utm_zone(
+            utm_zone=utm_zone, hemisphere=hemisphere
+        )
+        metadata_dict["transformer"]["accuracy"] = homography_eval_dict
+
+        log.debug(f"metadata: {metadata_dict}")
+
+        # Write tracks
+        write_tracks(
+            tracks_utm_df=tracks_utm_df,
+            metadata_dict=metadata_dict,
+            utm_zone=utm_zone,
+            hemisphere=hemisphere,
+            tracks_file=tracks_file,
+        )
+
+        log.info(f"Successfully transformed and wrote {tracks_file}")
+
+    finished_msg = "Finished transformation"
+    log.info(finished_msg)
+    print(finished_msg)
+
+
+# TODO: Type hint nested dict during refactoring
+def read_tracks(tracks_file: Path) -> tuple[pd.DataFrame, dict]:
+    """Reads .ottrk file, returns pandas DataFrame of trajectories
+    in pixel coordinates and dict of metadata
+
+    Args:
+        tracks_file (str or Pathlib.Path): Path to .ottrk file
+
+    Returns:
+        pandas.DataFrame: DataFrame of trajectories in pixel coordinates
+        dict: Dict of metadata
+    """
+
+    # Read dicts and turn tracks into DataFrame
+    tracks_dict = read_json(tracks_file, filetype=tracks_file.suffix)
+    metadata_dict = get_metadata(tracks_dict)
+    tracks_df = _ottrk_detections_to_df(tracks_dict["data"]["detections"])
+
+    return tracks_df, metadata_dict
+
+
+def read_refpts(
+    reftpts_file: Path,
+) -> dict:  # TODO: Type hint nested dict during refactoring
+    """Reads .otrfpts file, returns dict of matching reference points
+    in both pixel and utm coordinates
+
+    Args:
+        reftpts_file (str or pathlib.Path): Path to .rfpts file
+
+    Returns:
+        dict: Matching reference points in both pixel and utm coordinates
+    """
+
+    return read_json(reftpts_file, filetype=reftpts_file.suffix, decompress=False)
+
+
+def transform(
+    tracks_px: pd.DataFrame,
+    homography: np.ndarray,
+    refpts_utm_upshifted_predecimal_pt1_1row: np.ndarray,
+    upshift_utm: np.ndarray,
+    x_col: str = "x",
+    y_col: str = "y",
+    lon_col: str = "lon_utm",
+    lat_col: str = "lat_utm",
+) -> pd.DataFrame:
+    """Transforms trajectories from pixel to utm coordinates using homography from
+    get_homography using corresponding reference points, adds utm coordinates to
+    trajectories
+
+    Args:
+        tracks_px (pandas.DataFrame): Trajectories in pixel coordinates
+        homography (numpy.ndarry): Homography matrix between pixel and utm coordinates
+        refpts_utm_upshifted_predecimal_pt1_1row (numpy.ndarry): Thousands digits
+            of reference points in utm coorindates
+        upshift_utm (numpy.ndarry): Upshift of reference points coordinates
+        x_col (str, optional): Column name of x-pixel values. Defaults to "x".
+        y_col (str, optional): Column name of y-pixel values. Defaults to "y".
+        lon_col (str, optional): Column name of lon values. Defaults to "lon_utm".
+        lat_col (str, optional): Column name of lat values. Defaults to "lat_utm".
+
+    Returns:
+        pandas.DataFrame: Trajectories in utm coordinates
+    """
+
+    tracks_utm = deepcopy(tracks_px)
+
+    # Transform pandas DataFrame to numpy array, add 1 dimension and apply OpenCV´s
+    # perspective transformation
+    tracks_px_np = tracks_px[[x_col, y_col]].to_numpy(dtype="float32")
+    tracks_px_np_tmp = np.array([tracks_px_np], dtype="float32")
+    tracks_utm_upshifted_np_disassembled_3d = cv2.perspectiveTransform(
+        tracks_px_np_tmp, homography
+    )
+    tracks_utm_upshifted_np_disassembled = np.squeeze(
+        tracks_utm_upshifted_np_disassembled_3d
+    )
+
+    # Concatenate the thousands digits truncated before transformation
+    tracks_utm_upshifted_np = np.add(
+        np.multiply(refpts_utm_upshifted_predecimal_pt1_1row, 1000),
+        tracks_utm_upshifted_np_disassembled,
+    )
+
+    # Shift back down both y and y world coordinates (same values as reference points
+    # were upshifted)
+    tracks_utm_np = np.subtract(tracks_utm_upshifted_np, upshift_utm)
+
+    # In trajectory DataFrame, overwrite pixel with utm coordinates (from numpy array)
+    tracks_utm[[lon_col, lat_col]] = tracks_utm_np
+
+    return tracks_utm
+
+
+# TODO: Type hint nested dict during refactoring
+def write_refpts(refpts: dict, refpts_file: Path) -> None:
+    """Writes corresponding reference points in both pixel and utm coordinates
+    to a json-like .otrfpts file
+
+    Args:
+        refpts (dict): Corresponding reference points in both pixel and utm coordinates
+        refpts_file (str or pathlib.Path): Path of the refpts file to be written
+    """
+    write_json(
+        dict_to_write=refpts,
+        file=refpts_file,
+        filetype=CONFIG["DEFAULT_FILETYPE"]["REFPTS"],
+        overwrite=True,
+    )
+
+
+# TODO: Type hint nested dict during refactoring
+def write_tracks(
+    tracks_utm_df: pd.DataFrame,
+    metadata_dict: dict,
+    utm_zone: int,
+    hemisphere: str,
+    tracks_file: Path,
+    filetype: str = "gpkg",
+    overwrite: bool = CONFIG[TRANSFORM][OVERWRITE],
+) -> None:
+    """Writes tracks as .gpkg and in specific epsg projection
+    according to UTM zone and hemisphere
+
+    Args:
+        tracks_utm_df (geopandas.GeoDataFrame): Trajectories in utm coordinates
+        config_dict (dict): Meta data dict
+        utm_zone (str): UTM zone.
+        hemisphere (str): Hemisphere where trajectories were recorded. "N" or "S".
+        tracks_file (str or pathlib.Path): Path to tracks file (in pixel coordinates)
+        filetype (str, optional): _description_. Defaults to "gpkg".
+    """
+
+    # TODO: Write metadata
+
+    if filetype == "gpkg":  # TODO: Extend guard with overwrite parameter
+        gpkg_file = tracks_file.with_suffix(".gpkg")
+        gpkg_file_already_exists = gpkg_file.is_file()
+        if overwrite or not gpkg_file_already_exists:
+            log.debug(f"Write {gpkg_file}")
+            # Get CRS UTM EPSG number
+            epsg = _get_epsg_from_utm_zone(utm_zone=utm_zone, hemisphere=hemisphere)
+            # Create, set crs and write geopandas.GeoDataFrame
+            gpd.GeoDataFrame(
+                tracks_utm_df,
+                geometry=gpd.points_from_xy(
+                    tracks_utm_df["lon_utm"], tracks_utm_df["lat_utm"]
+                ),
+            ).set_crs(f"epsg:{epsg}").to_file(filename=gpkg_file, driver="GPKG")
+            if gpkg_file_already_exists:
+                log.debug(f"{gpkg_file} overwritten")
+            else:
+                log.debug(f"{gpkg_file} written")
+        else:
+            log.debug(f"{gpkg_file} already exists. To overwrite, set overwrite=True")
+    # TODO: Export tracks as ottrk (json)

OTVision/version.py

@@ -0,0 +1,13 @@
+__version__ = "v0.5.3"
+
+
+def otdet_version() -> str:
+    return "1.3"
+
+
+def ottrack_version() -> str:
+    return "1.1"
+
+
+def otvision_version() -> str:
+    return __version__

OTVision/view/view.py

@@ -0,0 +1,90 @@
+"""
+OTVision main gui module
+"""
+
+# 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 tkinter as tk
+
+from OTVision.config import CONFIG, PAD
+from OTVision.helpers.machine import ON_LINUX, ON_WINDOWS
+from OTVision.view.view_convert import FrameConvert
+from OTVision.view.view_detect import FrameDetect
+from OTVision.view.view_helpers import FrameFileTree, FrameRunChained
+from OTVision.view.view_track import FrameTrack
+from OTVision.view.view_transform import FrameTransform
+
+FRAME_WIDTH = 50
+
+
+class WindowOTVision(tk.Tk):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.title("OTVision")
+        if ON_WINDOWS:
+            self.iconbitmap(CONFIG["GUI"]["OTC ICON"])
+        self.set_layout()
+        self.minsize(900, 620)
+        if ON_LINUX:
+            self.state("normal")
+        else:
+            self.state("zoomed")
+
+    def set_layout(self):
+        for col in range(3):
+            self.columnconfigure(index=col, weight=1)
+        self.rowconfigure(index=0, weight=1)  # Stretches frame_files only
+        # Treeview files
+        self.frame_files = FrameFileTree(master=self, text="Choose files")
+        self.frame_files.grid(**PAD, row=0, column=0, columnspan=4, sticky="nsew")
+        # Settings
+        # Convert
+        self.frame_convert = FrameConvert(master=self, text="Convert")
+        self.frame_convert.grid(**PAD, row=1, column=0, sticky="nsew")
+        # Detect
+        self.frame_detect = FrameDetect(master=self, text="Detect")
+        self.frame_detect.grid(**PAD, row=1, column=1, sticky="nsew")
+        # Track
+        self.frame_track = FrameTrack(master=self, text="Track")
+        self.frame_track.grid(**PAD, row=1, column=2, sticky="nsew")
+        # # Undistort # TODO
+        # self.frame_undistort = FrameUndistort(master=self, text="Undistort")
+        # self.frame_undistort.pack(**PAD, side="left", expand=True)
+        # # Transform # TODO
+        self.frame_transform = FrameTransform(master=self, text="Transform")
+        self.frame_transform.grid(**PAD, row=1, column=3, sticky="nsew")
+        # Run chained
+        self.frame_run_chained = FrameRunChained(master=self, text="Run chained")
+        self.frame_run_chained.grid(**PAD, row=2, column=0, columnspan=4, sticky="ew")
+
+    def toggle_frame_detect(self, event):
+        if self.checkbutton_convert_var.get():
+            self.frame_convert.configure(state="normal")
+        else:
+            self.frame_convert.configure(state="disabled")
+
+
+def main():
+    global app
+    app = WindowOTVision()
+    app.mainloop()
+
+
+if __name__ == "__main__":
+    main()

OTVision/view/view_convert.py

@@ -0,0 +1,128 @@
+"""
+OTVision gui module for convert.py
+"""
+
+# 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 tkinter as tk
+import tkinter.ttk as ttk
+
+from OTVision.config import CONFIG, PAD
+from OTVision.convert.convert import main as convert
+from OTVision.helpers.files import get_files, replace_filetype
+from OTVision.helpers.log import LOGGER_NAME
+from OTVision.view.view_helpers import FrameRun
+
+log = logging.getLogger(LOGGER_NAME)
+
+
+class FrameConvert(tk.LabelFrame):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.frame_options = FrameConvertOptions(master=self)
+        self.frame_options.pack(**PAD, fill="x", expand=1, anchor="n")
+        self.frame_run = FrameRunConversion(master=self)
+        self.frame_run.pack(**PAD, side="left", fill="both", expand=1, anchor="s")
+
+
+class FrameConvertOptions(tk.Frame):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # File type
+        self.label_filtype = tk.Label(master=self, text="Output file type")
+        self.label_filtype.grid(row=0, column=0, sticky="w")
+        self.combo_filtype = ttk.Combobox(
+            master=self,
+            values=[str.replace(".", "") for str in CONFIG["FILETYPES"]["VID"]],
+            width=5,
+        )
+        self.combo_filtype.grid(row=0, column=1, sticky="w")
+        self.combo_filtype.set(CONFIG["DEFAULT_FILETYPE"]["VID"].replace(".", ""))
+        # Frame rate from video
+        self.checkbutton_use_framerate_var = tk.BooleanVar()
+        self.checkbutton_use_framerate = tk.Checkbutton(
+            master=self,
+            text="Use frame rate from file name",
+            variable=self.checkbutton_use_framerate_var,
+        )
+        self.checkbutton_use_framerate.bind(
+            "<ButtonRelease-1>", self.toggle_entry_framerate
+        )
+        self.checkbutton_use_framerate.grid(row=1, column=0, columnspan=2, sticky="w")
+        self.checkbutton_use_framerate.select()
+        # Input frame rate
+        self.label_framerate = tk.Label(master=self, text="Input frame rate")
+        self.label_framerate.grid(row=2, column=0, sticky="w")
+        self.entry_framerate = tk.Entry(master=self, width=4)
+        self.entry_framerate.grid(row=2, column=1, sticky="w")
+        self.entry_framerate.insert(index=0, string=CONFIG["CONVERT"]["INPUT_FPS"])
+        self.entry_framerate.configure(state="disabled")
+        # Overwrite
+        self.checkbutton_overwrite_var = tk.BooleanVar()
+        self.checkbutton_overwrite = tk.Checkbutton(
+            master=self,
+            text="Overwrite existing videos",
+            variable=self.checkbutton_overwrite_var,
+        )
+        self.checkbutton_overwrite.grid(row=3, column=0, columnspan=2, sticky="w")
+        if CONFIG["CONVERT"]["OVERWRITE"]:
+            self.checkbutton_overwrite.select()
+
+    def toggle_entry_framerate(self, event):
+        if self.checkbutton_use_framerate_var.get():
+            self.entry_framerate.configure(state="normal")
+            self.entry_framerate.delete(0, "end")
+            self.entry_framerate.insert(0, CONFIG["CONVERT"]["FPS"])
+        else:
+            self.entry_framerate.configure(state="disabled")
+
+
+class FrameRunConversion(FrameRun):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.button_run.bind("<ButtonRelease-1>", self.run)
+        if CONFIG["CONVERT"]["RUN_CHAINED"]:
+            self.checkbutton_run_chained.select()
+
+    def run(self, event):
+        fps_from_filename = (
+            self.master.frame_options.checkbutton_use_framerate_var.get()
+        )
+        files = replace_filetype(
+            files=self.master.master.frame_files.get_tree_files(), new_filetype=".h264"
+        )
+        files = get_files(
+            paths=files,
+            filetypes=[".h264"],
+        )
+        output_filetype = f".{self.master.frame_options.combo_filtype.get()}"
+        input_fps = self.master.frame_options.entry_framerate.get()
+        output_fps = self.master.frame_options.entry_framerate.get()
+        overwrite = self.master.frame_options.checkbutton_use_framerate_var.get()
+        log.info("Call convert from GUI")
+        convert(
+            paths=files,
+            output_filetype=output_filetype,
+            input_fps=input_fps,
+            output_fps=output_fps,
+            fps_from_filename=fps_from_filename,
+            overwrite=overwrite,
+        )
+        self.master.master.frame_files.update_files_dict()