Merge pull request #476 from OpenTrafficCam/task/4441-clean-up-otanal…

…ytics-gui

task/4441-clean-up-otanalytics-gui

OTAnalytics/adapter_ui/view_model.py

@@ -344,6 +344,14 @@ def next_frame(self) -> None:
     def previous_frame(self) -> None:
         pass
 
+    @abstractmethod
+    def next_second(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def previous_second(self) -> None:
+        raise NotImplementedError
+
     @abstractmethod
     def update_skip_time(self, seconds: int, frames: int) -> None:
         raise NotImplementedError

OTAnalytics/application/application.py

@@ -17,10 +17,7 @@
     TrackViewState,
     VideosMetadata,
 )
-from OTAnalytics.application.ui.frame_control import (
-    SwitchToNextFrame,
-    SwitchToPreviousFrame,
-)
+from OTAnalytics.application.ui.frame_control import SwitchToNext, SwitchToPrevious
 from OTAnalytics.application.use_cases.config import SaveOtconfig
 from OTAnalytics.application.use_cases.create_events import (
     CreateEvents,
@@ -102,8 +99,8 @@ def __init__(
         start_new_project: StartNewProject,
         project_updater: ProjectUpdater,
         load_track_files: LoadTrackFiles,
-        previous_frame: SwitchToPreviousFrame,
-        next_frame: SwitchToNextFrame,
+        previous_frame: SwitchToPrevious,
+        next_frame: SwitchToNext,
     ) -> None:
         self._datastore: Datastore = datastore
         self.track_state: TrackState = track_state
@@ -135,8 +132,8 @@ def __init__(
         self._track_repository_size = TrackRepositorySize(
             self._datastore._track_repository
         )
-        self._previous_frame = previous_frame
-        self._next_frame = next_frame
+        self._switch_previous = previous_frame
+        self._switch_next = next_frame
 
     def connect_observers(self) -> None:
         """
@@ -458,10 +455,16 @@ def get_current_track_offset(self) -> Optional[RelativeOffsetCoordinate]:
         return self.track_view_state.track_offset.get()
 
     def next_frame(self) -> None:
-        self._next_frame.set_next_frame()
+        self._switch_next.switch_frame()
 
     def previous_frame(self) -> None:
-        self._previous_frame.set_previous_frame()
+        self._switch_previous.switch_frame()
+
+    def next_second(self) -> None:
+        self._switch_next.switch_second()
+
+    def previous_second(self) -> None:
+        self._switch_previous.switch_second()
 
     def update_date_range_tracks_filter(self, date_range: DateRange) -> None:
         """Update the date range of the track filter.

OTAnalytics/application/plotting.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from datetime import datetime, timedelta
 from math import floor
 from typing import Any, Callable, Generic, Iterable, Optional, Sequence, TypeVar
@@ -51,6 +52,20 @@ def reset(self) -> None:
         raise NotImplementedError
 
 
+@dataclass(frozen=True)
+class LayerGroup:
+    name: str
+    layers: Sequence[Layer]
+
+    def register(self, observer: Callable[[bool], None]) -> None:
+        for layer in self.layers:
+            layer.register(observer)
+
+    def reset(self) -> None:
+        for layer in self.layers:
+            layer.reset()
+
+
 class PlottingLayer(Plotter, Layer):
     def __init__(self, name: str, other: Plotter, enabled: bool) -> None:
         self._name = name

OTAnalytics/application/state.py

@@ -187,7 +187,7 @@ def __init__(self) -> None:
         self.selected_videos: ObservableProperty[list[Video]] = ObservableProperty[
             list[Video]
         ](default=[])
-        self.skip_time = ObservableProperty[SkipTime](SkipTime(1, 0))
+        self.skip_time = ObservableProperty[SkipTime](SkipTime(1, 1))
 
     def reset(self) -> None:
         """Reset to default settings."""
@@ -251,9 +251,9 @@ class SectionState(SectionListObserver):
     """
 
     def __init__(self, get_sections_by_id: GetSectionsById) -> None:
-        self.selected_sections: ObservableProperty[
-            list[SectionId]
-        ] = ObservableProperty[list]([])
+        self.selected_sections: ObservableProperty[list[SectionId]] = (
+            ObservableProperty[list]([])
+        )
         self._get_sections_by_id = get_sections_by_id
 
     def notify_sections(self, section_event: SectionRepositoryEvent) -> None:
@@ -471,18 +471,18 @@ def __init__(
         self._track_repository = track_repository
         self._include_classes = include_classes
         self._exclude_classes = exclude_classes
-        self._first_detection_occurrence: ObservableOptionalProperty[
-            datetime
-        ] = ObservableOptionalProperty[datetime]()
-        self._last_detection_occurrence: ObservableOptionalProperty[
-            datetime
-        ] = ObservableOptionalProperty[datetime]()
+        self._first_detection_occurrence: ObservableOptionalProperty[datetime] = (
+            ObservableOptionalProperty[datetime]()
+        )
+        self._last_detection_occurrence: ObservableOptionalProperty[datetime] = (
+            ObservableOptionalProperty[datetime]()
+        )
         self._classifications: ObservableProperty[frozenset[str]] = ObservableProperty[
             frozenset
         ](frozenset())
-        self._detection_classifications: ObservableProperty[
-            frozenset[str]
-        ] = ObservableProperty[frozenset](frozenset([]))
+        self._detection_classifications: ObservableProperty[frozenset[str]] = (
+            ObservableProperty[frozenset](frozenset([]))
+        )
 
     @property
     def first_detection_occurrence(self) -> Optional[datetime]:

OTAnalytics/application/ui/frame_control.py

@@ -1,15 +1,25 @@
+from abc import ABC, abstractmethod
 from datetime import timedelta
 
 from OTAnalytics.application.state import TrackViewState, VideosMetadata
 from OTAnalytics.domain.date import DateRange
 
 
-class SwitchToNextFrame:
+class SwitchTo(ABC):
     def __init__(self, state: TrackViewState, videos_metadata: VideosMetadata) -> None:
         self._state = state
         self._videos_metadata = videos_metadata
 
-    def set_next_frame(self) -> None:
+    def switch_second(self) -> None:
+        skip_time = self._state.skip_time.get()
+        current_skip = timedelta(seconds=skip_time.seconds)
+        self._switch_time(current_skip)
+
+    def switch_frame(self) -> None:
+        if current_skip := self._get_current_skip_frames():
+            self._switch_time(current_skip)
+
+    def _get_current_skip_frames(self) -> timedelta | None:
         if filter_element := self._state.filter_element.get():
             current_date_range = filter_element.date_range
             if current_date_range.start_date and current_date_range.end_date:
@@ -20,38 +30,43 @@ def set_next_frame(self) -> None:
                     skip_time = self._state.skip_time.get()
                     subseconds = min(skip_time.frames, fps) / fps
                     milliseconds = subseconds * 1000
-                    current_skip = timedelta(
-                        seconds=skip_time.seconds, milliseconds=milliseconds
-                    )
-                    next_start = current_date_range.start_date + current_skip
-                    next_end = current_date_range.end_date + current_skip
-                    next_date_range = DateRange(next_start, next_end)
-                    self._state.filter_element.set(
-                        filter_element.derive_date(next_date_range)
-                    )
-
-
-class SwitchToPreviousFrame:
+                    current_skip = timedelta(milliseconds=milliseconds)
+                    return current_skip
+        return None
+
+    @abstractmethod
+    def _switch_time(self, current_skip: timedelta) -> None:
+        raise NotImplementedError
+
+
+class SwitchToNext(SwitchTo):
+
     def __init__(self, state: TrackViewState, videos_metadata: VideosMetadata) -> None:
-        self._state = state
-        self._videos_metadata = videos_metadata
+        super().__init__(state, videos_metadata)
 
-    def set_previous_frame(self) -> None:
+    def _switch_time(self, current_skip: timedelta) -> None:
         if filter_element := self._state.filter_element.get():
             current_date_range = filter_element.date_range
             if current_date_range.start_date and current_date_range.end_date:
-                if metadata := self._videos_metadata.get_metadata_for(
-                    current_date_range.end_date
-                ):
-                    fps = metadata.fps
-                    skip_time = self._state.skip_time.get()
-                    subseconds = min(skip_time.frames, fps) / fps
-                    current_skip = timedelta(seconds=skip_time.seconds) + timedelta(
-                        seconds=subseconds
-                    )
-                    next_start = current_date_range.start_date - current_skip
-                    next_end = current_date_range.end_date - current_skip
-                    next_date_range = DateRange(next_start, next_end)
-                    self._state.filter_element.set(
-                        filter_element.derive_date(next_date_range)
-                    )
+                next_start = current_date_range.start_date + current_skip
+                next_end = current_date_range.end_date + current_skip
+                next_date_range = DateRange(next_start, next_end)
+                self._state.filter_element.set(
+                    filter_element.derive_date(next_date_range)
+                )
+
+
+class SwitchToPrevious(SwitchTo):
+    def __init__(self, state: TrackViewState, videos_metadata: VideosMetadata) -> None:
+        super().__init__(state, videos_metadata)
+
+    def _switch_time(self, current_skip: timedelta) -> None:
+        if filter_element := self._state.filter_element.get():
+            current_date_range = filter_element.date_range
+            if current_date_range.start_date and current_date_range.end_date:
+                next_start = current_date_range.start_date - current_skip
+                next_end = current_date_range.end_date - current_skip
+                next_date_range = DateRange(next_start, next_end)
+                self._state.filter_element.set(
+                    filter_element.derive_date(next_date_range)
+                )

OTAnalytics/plugin_ui/customtkinter_gui/custom_containers.py

@@ -1,4 +1,5 @@
-from typing import Any
+import tkinter
+from typing import Any, Protocol
 
 from customtkinter import CTkFrame, CTkScrollableFrame, CTkTabview
 
@@ -38,7 +39,7 @@ def __init__(
         self,
         **kwargs: Any,
     ) -> None:
-        super().__init__(border_width=0, **kwargs)
+        super().__init__(border_width=0, height=10, **kwargs)
         self.set_fg_color_as_segmented_button_color()
         self._configure_grid()
 
@@ -85,6 +86,34 @@ def _configure_grid(self) -> None:
         self.grid_columnconfigure(0, weight=1)
 
 
+class FrameFactory(Protocol):
+    def __call__(self, **kwargs: Any) -> CTkFrame:
+        raise NotImplementedError
+
+
+class SingleFrameTabview(CustomCTkTabview):
+    def __init__(
+        self,
+        frame_factory: FrameFactory,
+        title: str,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._frame_factory = frame_factory
+        self._title = title
+        self._get_widgets()
+        self._place_widgets()
+        self.disable_segmented_button()
+
+    def _get_widgets(self) -> None:
+        self.add(self._title)
+        self.frame = self._frame_factory(master=self.tab(self._title))
+
+    def _place_widgets(self) -> None:
+        self.frame.pack(fill=tkinter.BOTH, expand=True)
+        self.set(self._title)
+
+
 class CTkEmbeddedTabview(CTkTabview):
     def __init__(
         self,

OTAnalytics/plugin_ui/customtkinter_gui/dummy_viewmodel.py

@@ -1362,6 +1362,12 @@ def next_frame(self) -> None:
     def previous_frame(self) -> None:
         self._application.previous_frame()
 
+    def next_second(self) -> None:
+        self._application.next_second()
+
+    def previous_second(self) -> None:
+        self._application.previous_second()
+
     def validate_date(self, date: str) -> bool:
         return any(
             [validate_date(date, date_format) for date_format in SUPPORTED_FORMATS]
@@ -1498,9 +1504,9 @@ def export_counts(self) -> None:
                     "There is no flow configurated.\n"
                     "Please create a flow."
                 ),
-                initial_position=self._window.get_position()
-                if self._window
-                else (0, 0),
+                initial_position=(
+                    self._window.get_position() if self._window else (0, 0)
+                ),
             )
             return
         export_formats: dict = {

OTAnalytics/plugin_ui/customtkinter_gui/frame_bbox_offset.py

@@ -33,7 +33,6 @@ def _get_widgets(self) -> None:
         self.label_y_value = CTkLabel(master=self, width=20)
         self.slider_x = CTkSlider(
             master=self,
-            width=110,
             from_=0,
             to=1,
             number_of_steps=1 / SLIDER_RESOLUTION,
@@ -42,7 +41,6 @@ def _get_widgets(self) -> None:
         self.slider_x.bind("<ButtonRelease-1>", self._on_slider_release)
         self.slider_y = CTkSlider(
             master=self,
-            width=110,
             from_=0,
             to=1,
             number_of_steps=10,

OTAnalytics/plugin_ui/customtkinter_gui/frame_filter.py

@@ -69,7 +69,6 @@ def __init__(self, viewmodel: ViewModel, **kwargs: Any) -> None:
         self._introduce_to_viewmodel()
 
     def _get_widgets(self) -> None:
-        self.label = CTkLabel(master=self, text="Visualization Filters")
         self.filter_by_date_button = FilterTracksByDateFilterButton(
             master=self,
             name="Filter By Date",
@@ -91,15 +90,14 @@ def _get_widgets(self) -> None:
         )
 
     def _place_widgets(self) -> None:
-        self.label.grid(row=0, column=0, padx=PADX, pady=PADY, sticky=STICKY_WEST)
         self.filter_by_date_button.grid(
-            row=1, column=0, padx=(PADX, 0), pady=PADY, sticky=STICKY
+            row=0, column=0, padx=(PADX, 0), pady=PADY, sticky=STICKY
         )
         self.date_range_switcher.grid(
-            row=1, column=1, padx=(0, PADX), pady=PADY, sticky=STICKY
+            row=0, column=1, padx=(0, PADX), pady=PADY, sticky=STICKY
         )
         self.filter_by_classification_button.grid(
-            row=1, column=2, padx=PADX, pady=PADY, sticky=STICKY
+            row=0, column=2, padx=PADX, pady=PADY, sticky=STICKY
         )
 
     def reset(self) -> None: