Merge pull request #848 from OpenTrafficCam/bug/10404-no-orthophoto-video-to-laod-when-loading-fusion-track-files

bug/10404-no-orthophoto-video-to-laod-when-loading-fusion-track-files

Author: briemla

.pre-commit-config.yaml

@@ -39,6 +39,7 @@ repos:
       - id: mypy
         entry: mypy OTAnalytics tests --config-file=pyproject.toml
         additional_dependencies:
+          - affine==3.0.1
           - av==13.0.0
           - black==25.1.0
           - customtkinter==5.2.2
@@ -66,6 +67,7 @@ repos:
           - pytest-playwright==0.7.1
           - pytest-timeout==2.4.0
           - pytest==8.3.4
+          - rasterio==1.5.1
           - starlette==0.49.1
           - testcontainers==4.13.1
           - twine==6.2.0

CONTEXT.md

@@ -54,3 +54,18 @@ one opens a file chooser, the S3 one asks for a Load Window and downloads. This
 is the seam that makes the Transfer Mode interchangeable.
 _Avoid_: file loader, importer (both suggest they also parse, which they do not —
 they only obtain paths).
+
+### Placing Tracks in the world
+
+**Geo-only Track File**:
+A Track file whose positions are given only in geo coordinates, with no image
+coordinates and no Video. OTFusion produces these, because it fuses several
+cameras into one world view rather than into any single camera's image.
+_Avoid_: fusion video, bird's-eye-view file (there is no video or rendered image).
+
+**Orthophoto**:
+A georeferenced aerial image of a site, shown as the background for Tracks that
+have no Video. Its own georeference is what relates a point on the image to a
+point in the world.
+_Avoid_: map, GeoTIFF (a file format, not the concept), bird's-eye view (the image
+OTFusion used to render, which no longer exists).

OTAnalytics/adapter_ui/dummy_viewmodel.py

@@ -94,6 +94,7 @@
     WeatherType,
 )
 from OTAnalytics.application.project_location import UnsupportedProjectLocation
+from OTAnalytics.application.state import CurrentOrthophoto
 from OTAnalytics.application.use_cases.config import ConfigValidationError
 from OTAnalytics.application.use_cases.config_has_changed import NoExistingConfigFound
 from OTAnalytics.application.use_cases.cut_tracks_with_sections import CutTracksDto
@@ -137,6 +138,7 @@
 from OTAnalytics.domain.files import DifferentDrivesException
 from OTAnalytics.domain.filter import FilterElement
 from OTAnalytics.domain.flow import Flow, FlowId, FlowListObserver
+from OTAnalytics.domain.orthophoto import Orthophoto, OrthophotoError
 from OTAnalytics.domain.section import (
     COORDINATES,
     ID,
@@ -148,6 +150,9 @@
     SectionRepositoryEvent,
 )
 from OTAnalytics.domain.track import TrackImage
+from OTAnalytics.domain.track_dataset.track_dataset import (
+    IncompatibleGeoreferenceMetadataError,
+)
 from OTAnalytics.domain.track_repository import TrackListObserver, TrackRepositoryEvent
 from OTAnalytics.domain.types import EventType
 from OTAnalytics.domain.video import Video, VideoListObserver
@@ -340,8 +345,10 @@ def __init__(
         update_section_coordinates: UpdateSectionCoordinates,
         provide_track_files: ProvideTrackFiles,
         provide_video_files: ProvideVideoFiles,
+        current_orthophoto: CurrentOrthophoto,
     ) -> None:
         self._application = application
+        self._current_orthophoto = current_orthophoto
         self._ui_factory = ui_factory
         self._provide_track_files = provide_track_files
         self._provide_video_files = provide_video_files
@@ -382,6 +389,10 @@ def notify_videos(self, videos: list[Video]) -> None:
         self.treeview_videos.update_items()
         self._update_enabled_buttons()
 
+    def notify_orthophoto(self, _: Orthophoto | None) -> None:
+        """Re-enable the buttons that wait for a background to draw on."""
+        self._update_enabled_buttons()
+
     def notify_files(self) -> None:
         self.treeview_files.update_items()
         self._update_enabled_buttons()
@@ -432,12 +443,11 @@ def _update_enabled_video_buttons(self) -> None:
 
     def _update_enabled_section_buttons(self) -> None:
         action_running = self._application.action_state.action_running.get()
-        videos_exist = len(self._application.get_all_videos()) > 0
         selected_section_ids = self.get_selected_section_ids()
         single_section_selected = len(selected_section_ids) == 1
         any_section_selected = len(selected_section_ids) > 0
 
-        add_section_enabled = (not action_running) and videos_exist
+        add_section_enabled = (not action_running) and self._background_exists()
         single_section_enabled = add_section_enabled and single_section_selected
         multiple_sections_enabled = add_section_enabled and any_section_selected
 
@@ -469,10 +479,14 @@ def _update_enabled_flow_buttons(self) -> None:
 
     def _update_enabled_video_control_buttons(self) -> None:
         action_running = self._application.action_state.action_running.get()
-        videos_exist = len(self._application.get_all_videos()) > 0
-        general_activated = not action_running and videos_exist
+        general_activated = not action_running and self._background_exists()
         self.frame_video_control.set_enabled_general_buttons(general_activated)
 
+    def _background_exists(self) -> bool:
+        """Whether a Video or an Orthophoto is there to draw Sections on."""
+        videos_exist = len(self._application.get_all_videos()) > 0
+        return videos_exist or self._current_orthophoto.get() is not None
+
     def _on_section_changed(self, section: SectionId) -> None:
         self._refresh_sections_in_ui()
 
@@ -586,7 +600,13 @@ async def add_video(self) -> None:
         if not video_files:
             return
         logger().info(f"Video files to load: {video_files}")
-        self._application.add_videos(files=video_files)
+        try:
+            self._application.add_videos(files=video_files)
+        except OrthophotoError as cause:
+            logger().warning(str(cause))
+            self._ui_factory.info_box(
+                message=str(cause), initial_position=self._get_window_position()
+            )
 
     def remove_videos(self) -> None:
         self._application.remove_videos()
@@ -900,7 +920,13 @@ async def load_tracks(self) -> None:
         if not track_files:
             return
         logger().info(f"Tracks files to load: {track_files}")
-        await self._application.add_tracks_of_files_async(track_files=track_files)
+        try:
+            await self._application.add_tracks_of_files_async(track_files=track_files)
+        except (OrthophotoError, IncompatibleGeoreferenceMetadataError) as cause:
+            logger().warning(str(cause))
+            self._ui_factory.info_box(
+                message=str(cause), initial_position=self._get_window_position()
+            )
 
     async def load_configuration(self) -> None:  # sourcery skip: avoid-builtin-shadow
         # INFO: Current behavior: Overwrites existing sections

OTAnalytics/adapter_ui/local_file_providers.py

@@ -4,12 +4,20 @@
 
 from OTAnalytics.adapter_ui.ui_factory import UiFactory
 from OTAnalytics.application.config import SUPPORTED_VIDEO_FILE_TYPES
+from OTAnalytics.application.orthophoto import ProvideOrthophoto
 from OTAnalytics.application.use_cases.provide_input_files import (
     ProvideTrackFiles,
     ProvideVideoFiles,
 )
 
 ALL_FILE_ENDINGS = "All File Endings"
+ORTHOPHOTO_EXTENSIONS = [".tif", ".tiff"]
+ORTHOPHOTO_FILE_TYPES = [
+    (f"orthophoto ({extension})", f"*{extension}")
+    for extension in ORTHOPHOTO_EXTENSIONS
+]
+ORTHOPHOTO_DEFAULT_EXTENSION = ORTHOPHOTO_EXTENSIONS[0]
+NO_FILE_CHOSEN = ""
 
 
 class LocalTrackFileProvider(ProvideTrackFiles):
@@ -43,15 +51,39 @@ async def provide(self) -> list[Path]:
         return await self._ui_factory.askopenfilenames(
             title="Load video files",
             filetypes=[("video file", SUPPORTED_VIDEO_FILE_TYPES)],
-            extension_options=_video_extension_options(),
+            extension_options=_extension_options(SUPPORTED_VIDEO_FILE_TYPES),
         )
 
 
-def _video_extension_options() -> dict[str, list[str] | None]:
-    """One entry offering every supported type, then one per type."""
-    options: dict[str, list[str] | None] = {
-        ALL_FILE_ENDINGS: list(SUPPORTED_VIDEO_FILE_TYPES)
-    }
-    for extension in SUPPORTED_VIDEO_FILE_TYPES:
+class LocalOrthophotoProvider(ProvideOrthophoto):
+    """Asks the user for the Orthophoto of Geo-only Track Files being loaded.
+
+    Args:
+        ui_factory (UiFactory): builds the file chooser for the active front-end.
+    """
+
+    def __init__(self, ui_factory: UiFactory) -> None:
+        self._ui_factory = ui_factory
+
+    async def provide(self) -> Path | None:
+        chosen = await self._ui_factory.askopenfilename(
+            title="Choose the orthophoto for these track files",
+            filetypes=ORTHOPHOTO_FILE_TYPES,
+            defaultextension=ORTHOPHOTO_DEFAULT_EXTENSION,
+            extension_options=_extension_options(ORTHOPHOTO_EXTENSIONS),
+        )
+        if chosen == NO_FILE_CHOSEN:
+            return None
+        return Path(chosen)
+
+
+def _extension_options(extensions: list[str]) -> dict[str, list[str] | None]:
+    """One entry offering every given extension, then one per extension.
+
+    Without these options the file picker falls back to its otflow/otconfig filter
+    and hides every other file.
+    """
+    options: dict[str, list[str] | None] = {ALL_FILE_ENDINGS: list(extensions)}
+    for extension in extensions:
         options[extension] = [extension]
     return options

OTAnalytics/adapter_ui/ui_factory.py

@@ -36,6 +36,7 @@ async def askopenfilename(
         title: str,
         filetypes: list[tuple[str, str]],
         defaultextension: str,
+        extension_options: dict[str, list[str] | None] | None = None,
     ) -> str:
         raise NotImplementedError
 

OTAnalytics/application/application.py

@@ -9,6 +9,7 @@
 )
 from OTAnalytics.application.datastore import Datastore
 from OTAnalytics.application.key_prefix import S3KeyPrefix
+from OTAnalytics.application.orthophoto import AddVideoFiles
 from OTAnalytics.application.project import SvzMetadata
 from OTAnalytics.application.state import (
     ActionState,
@@ -160,6 +161,7 @@ def __init__(
         get_current_remark: GetCurrentRemark,
         update_count_plots: CountPlotsUpdater,
         current_key_prefix: CurrentKeyPrefix,
+        add_video_files: AddVideoFiles,
     ) -> None:
         self._datastore: Datastore = datastore
         self.track_state: TrackState = track_state
@@ -208,6 +210,7 @@ def __init__(
         self._get_current_remark = get_current_remark
         self._update_count_plots = update_count_plots
         self._current_key_prefix = current_key_prefix
+        self._add_video_files = add_video_files
 
     def connect_observers(self) -> None:
         """
@@ -245,7 +248,15 @@ def get_section_for(self, section_id: SectionId) -> Optional[Section]:
         return self._datastore.get_section_for(section_id)
 
     def add_videos(self, files: list[Path]) -> None:
-        self._datastore.load_video_files(files)
+        """Load video files into the project.
+
+        Args:
+            files (list[Path]): the video files.
+
+        Raises:
+            MixedTrackFiles: if the project shows an Orthophoto.
+        """
+        self._add_video_files.add(files)
 
     def remove_videos(self) -> None:
         """