vars-localize 0.1.0__py3-none-any.whl

vars_localize/__main__.py

@@ -0,0 +1,34 @@
+"""
+Main entry point for the VARS Localize application.
+"""
+
+import argparse
+import sys
+
+from PyQt6.QtWidgets import QApplication
+
+from vars_localize.ui.AppWindow import AppWindow
+from vars_localize.util.endpoints import DEFAULT_M3_URL
+
+
+def main():
+    """
+    Main entry point for the VARS Localize application.
+    """
+    parser = argparse.ArgumentParser(description="VARS Localize")
+    parser.add_argument(
+        "-u", "--url", type=str, default=DEFAULT_M3_URL, help="URL of M3 server"
+    )
+    args = parser.parse_args()
+
+    app = QApplication(sys.argv)
+
+    window = AppWindow(args.url)
+    window.show()
+
+    exit_code = app.exec()
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()

vars_localize/assets/__init__.py

@@ -0,0 +1,28 @@
+"""
+Helpers for dealing with assets.
+"""
+
+from pathlib import Path
+from typing import Union
+
+
+ASSETS_DIR = Path(__file__).parent.resolve()
+
+
+def get_asset_path(rel_path: Union[str, Path]) -> Path:
+    """
+    Get the absolute path to an asset.
+
+    Args:
+        rel_path (Union[str, Path]): The relative path to the asset.
+
+    Returns:
+        Path: The absolute path to the asset.
+
+    Raises:
+        ValueError: If rel_path is an absolute path.
+    """
+    rel_path = Path(rel_path)
+    if rel_path.is_absolute():
+        raise ValueError("rel_path must be a relative path.")
+    return ASSETS_DIR / rel_path

vars_localize/ui/AppWindow.py

@@ -0,0 +1,276 @@
+"""
+Main application window.
+"""
+
+from datetime import datetime
+
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QCloseEvent, QIcon, QAction
+from PyQt6.QtWidgets import QMainWindow, QWidget, QHBoxLayout, QMessageBox, QInputDialog
+
+from vars_localize.ui.EntryTree import EntryTreeItem
+from vars_localize.ui.LoginDialog import LoginDialog
+from vars_localize.ui.DisplayPanel import DisplayPanel
+from vars_localize.ui.SearchPanel import SearchPanel
+from vars_localize.util.m3 import (
+    check_connection,
+    get_all_users,
+    get_annotations_by_video_refernce,
+    get_imaged_moments_by_image_reference,
+)
+from vars_localize.util.utils import log, split_comma_list
+
+
+class AppWindow(QMainWindow):
+    def __init__(self, m3_url: str, parent=None):
+        super(AppWindow, self).__init__(parent)
+        self._m3_url = m3_url.rstrip("/")
+
+        self.setWindowTitle("VARS Localize")
+
+        log(f"Checking connection to M3 at {self._m3_url}...")
+        if not check_connection(self._m3_url):
+            log(
+                "You are not connected to M3. Check your internet connection and/or VPN.",
+                level=2,
+            )
+            QMessageBox.critical(
+                self,
+                "No connection to M3",
+                "You are not connected to M3. Check your internet connection and/or VPN.",
+            )
+            exit(1)
+        log("Connected.")
+
+        self.observer = None
+        self.observer_role = None
+        self.admin_mode = False
+
+        login_ok = self.login()
+        if not login_ok:
+            log("You must log in to use this tool.", level=2)
+            exit(1)
+
+        self.central_container = QWidget()
+        self.central_container.setLayout(QHBoxLayout())
+
+        self.search_panel = SearchPanel(parent=self)
+        self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, self.search_panel)
+
+        self.display_panel = DisplayPanel(parent=self)
+        self.central_container.layout().addWidget(self.display_panel)
+
+        self.setCentralWidget(self.central_container)
+
+        # Add admin menu if available to user
+        if self.observer_role in ("Maint", "Admin"):
+            self.add_admin_menu()
+
+        self.add_search_menu()
+        self.add_video_menu()
+
+        self.display_panel.image_view.observer = self.observer
+        self.display_panel.image_view.select_next = self.search_panel.select_next
+        self.display_panel.image_view.select_prev = self.search_panel.select_prev
+
+        self.search_panel.observer = self.observer
+
+    def load_entry(self, current: EntryTreeItem, previous: EntryTreeItem):
+        """
+        Load the current entry into the display panel
+        :param current: Current selected entry
+        :param previous: Previously selected entry
+        :return: None
+        """
+        if current and current.metadata:
+            self.display_panel.load_entry(current)
+
+    def login(self):
+        """
+        Prompt for observer login
+        :return: None
+        """
+        login_dialog = LoginDialog(parent=self)
+        login_dialog._login_form._username_line_edit.setFocus()
+        ok = login_dialog.exec()
+
+        if ok:
+            # Get the username/password from the dialog
+            username, password = login_dialog.credentials
+
+            # Set up the M3 configuration, returning False if login fails
+            if not self.configure_m3(username, password):
+                return False
+
+            all_valid_users = get_all_users()
+            users_dict = {
+                user_data["username"]: user_data for user_data in all_valid_users
+            }
+
+            # Set the observer and role
+            self.observer = username
+            self.observer_role = users_dict[username]["role"]
+        else:  # Login cancel, return failure
+            return False
+
+        return True  # Return success
+
+    def configure_m3(self, username, password) -> bool:
+        """
+        Configure endpoints and set up Annosaurus auth
+        """
+        from vars_localize.util.endpoints import configure as configure_endpoints
+        from vars_localize.util.m3 import configure_anno_session
+
+        try:
+            configure_endpoints(self._m3_url, username, password)
+        except Exception as e:
+            log("Login failed.", level=2)
+            log(e, level=2)
+            return False
+
+        configure_anno_session()
+
+        return True
+
+    def add_admin_menu(self):
+        """
+        Add the admin menu for observation modification/deletion
+        """
+        main_menu = self.menuBar()
+        options_menu = main_menu.addMenu("&Options")
+
+        admin_mode_action = QAction("Admin Mode", options_menu, checkable=True)
+
+        def set_admin_mode(val):
+            if val:
+                QMessageBox.warning(
+                    self,
+                    "Entering Admin Mode",
+                    "WARNING: You are now entering administrator mode. This mode allows modification and deletion of observations within VARS.",
+                )
+            self.admin_mode = val
+
+        admin_mode_action.toggled.connect(set_admin_mode)
+        options_menu.addAction(admin_mode_action)
+
+    def add_search_menu(self):
+        """
+        Add the Go menu for non-concept searches
+        """
+        main_menu = self.menuBar()
+        search_menu = main_menu.addMenu("&Search")
+
+        def search_imaged_moment():
+            imaged_moment_uuid_list, ok = QInputDialog.getText(
+                self,
+                "Imaged Moment UUID Search",
+                "Imaged Moment UUID (or comma-separated list)",
+            )
+            if ok:
+                imaged_moment_uuids = split_comma_list(imaged_moment_uuid_list)
+                imaged_moment_uuids = list(
+                    set(imaged_moment_uuids)
+                )  # Ensure no duplicates
+
+                # Set the UUIDs and load the first page
+                self.search_panel.set_uuids(imaged_moment_uuids)
+                self.search_panel.load_page()
+
+        search_imaged_moment_action = QAction("Imaged Moment UUID", search_menu)
+        search_imaged_moment_action.triggered.connect(search_imaged_moment)
+        search_menu.addAction(search_imaged_moment_action)
+
+        def search_image_reference():
+            image_reference_uuid_list, ok = QInputDialog.getText(
+                self,
+                "Image Reference UUID Search",
+                "Image Reference UUID (or comma-separated list)",
+            )
+            if ok:
+                all_image_reference_uuids = split_comma_list(image_reference_uuid_list)
+                imaged_moment_uuids = []
+                for image_reference_uuid in all_image_reference_uuids:
+                    res = get_imaged_moments_by_image_reference(image_reference_uuid)
+                    if res:
+                        imaged_moment_uuids.extend(
+                            [item["imaged_moment_uuid"] for item in res]
+                        )
+                imaged_moment_uuids = list(
+                    set(imaged_moment_uuids)
+                )  # Ensure no duplicates
+
+                # Set the UUIDs and load the first page
+                self.search_panel.set_uuids(imaged_moment_uuids)
+                self.search_panel.load_page()
+
+        search_image_reference_action = QAction("Image Reference UUID", search_menu)
+        search_image_reference_action.triggered.connect(search_image_reference)
+        search_menu.addAction(search_image_reference_action)
+
+        def search_video_reference():
+            video_reference_uuid, ok = QInputDialog.getText(
+                self, "Video Reference UUID Search", "Video Reference UUID"
+            )
+            if ok:
+                res = get_annotations_by_video_refernce(video_reference_uuid)
+                if res:
+                    timestamp_uuid_tuples = set()
+                    for item in res:
+                        timestamp = datetime.now()
+                        if "recorded_timestamp" in item:
+                            try:
+                                timestamp = datetime.strptime(
+                                    item["recorded_timestamp"], "%Y-%m-%dT%H:%M:%S.%fZ"
+                                )
+                            except ValueError:
+                                timestamp = datetime.strptime(
+                                    item["recorded_timestamp"], "%Y-%m-%dT%H:%M:%SZ"
+                                )
+
+                        timestamp_uuid_tuples.add(
+                            (timestamp, item["imaged_moment_uuid"])
+                        )
+
+                    # Sort by timestamp, then UUID
+                    timestamp_uuid_tuples = sorted(timestamp_uuid_tuples)
+                    imaged_moment_uuids = [item[1] for item in timestamp_uuid_tuples]
+
+                    # Set the UUIDs and load the first page
+                    self.search_panel.set_uuids(imaged_moment_uuids)
+                    self.search_panel.load_page()
+                else:
+                    # No results, warning dialog
+                    QMessageBox.warning(
+                        self,
+                        "No Results",
+                        "No results found for video reference UUID: {}".format(
+                            video_reference_uuid
+                        ),
+                    )
+
+        search_video_reference_action = QAction("Video Reference UUID", search_menu)
+        search_video_reference_action.triggered.connect(search_video_reference)
+        search_menu.addAction(search_video_reference_action)
+
+    def add_video_menu(self):
+        """
+        Add the Video menu for video-level operations
+        """
+        main_menu = self.menuBar()
+        video_menu = main_menu.addMenu("&Video")
+
+        def open_video():
+            self.search_panel.open_video()
+
+        open_video_action = QAction("Open Video", video_menu)
+        open_video_action.triggered.connect(open_video)
+        video_menu.addAction(open_video_action)
+
+    def closeEvent(self, a0: QCloseEvent) -> None:
+        """
+        Detect window close and tear down components
+        :param a0: Close event
+        :return: None
+        """
+        self.deleteLater()

vars_localize/ui/BoundingBox.py

@@ -0,0 +1,243 @@
+"""
+Bounding box data structure and manager helper class.
+"""
+
+import typing
+
+from PyQt6.QtCore import Qt, QRectF, QPoint, QSizeF, QRect, QPointF
+from PyQt6.QtGui import QColor, QPainter, QPen, QFont
+from PyQt6.QtWidgets import QGraphicsItem, QStyleOptionGraphicsItem, QWidget
+
+from vars_localize.util import m3, utils
+
+
+class SourceBoundingBox(QRect):
+    """Bounding box VARS source data structure"""
+
+    def __init__(
+        self,
+        box_json,
+        label,
+        observer=None,
+        observation_uuid=None,
+        association_uuid=None,
+        part=None,
+    ):
+        super(SourceBoundingBox, self).__init__(
+            box_json["x"], box_json["y"], box_json["width"], box_json["height"]
+        )
+        self.image_reference_uuid = box_json.get("image_reference_uuid", None)
+        self.observation_uuid = observation_uuid
+        self.association_uuid = association_uuid
+        self.part = part
+        self.label = label
+        self.observer = observer
+
+    def set_label(self, label):
+        if label in m3.get_all_concepts():
+            self.label = label
+
+    def get_json(self):
+        d = {
+            "x": self.x(),
+            "y": self.y(),
+            "width": self.width(),
+            "height": self.height(),
+            "generator": "vars-localize",
+            "image_reference_uuid": self.image_reference_uuid,
+        }
+
+        if self.observer is not None:
+            d["observer"] = self.observer
+
+        return d
+
+
+class GraphicsBoundingBox(QGraphicsItem):
+    """Graphical bounding box representation"""
+
+    def __init__(self, source: SourceBoundingBox, editable: bool = True):
+        super(GraphicsBoundingBox, self).__init__()
+
+        self.source = source
+        self.editable = editable
+
+        self.width = 0
+        self.height = 0
+        self.label = None
+        self.highlighted = False
+        self.color = QColor(0, 0, 0)
+
+    def set_box(self, x, y, w, h):
+        """
+        Update box position and dimensions
+        :param x: x position
+        :param y: y position
+        :param w: Width
+        :param h: Height
+        :return: None
+        """
+        self.prepareGeometryChange()
+        self.setPos(x, y)
+        self.width = w
+        self.height = h
+
+    def set_label(self, label):
+        """
+        Set the label of the bounding box
+        :param label: Bounding box label
+        :return: None
+        """
+        self.label = label
+        if self.editable:
+            self.color.setHsv(*utils.n_split_hash(label, 1), 255, 255)
+        else:
+            # If not editable, set color to gray with 50% opacity
+            self.color.setHsv(0, 0, 128, alpha=128)
+
+    def set_highlighted(self, highlighted: bool):
+        """
+        Set the highlight status of the bounding box
+        :param highlighted: Highlight on or off
+        :return: None
+        """
+        self.highlighted = highlighted
+
+    def area(self):
+        """
+        Compute the area of the box
+        :return: Box area
+        """
+        return self.width * self.height
+
+    def boundingRect(self) -> QRectF:
+        """
+        Give the bounding rectangle of the graphics item
+        :return: Bounding rectangle of box (not including label)
+        """
+        return QRectF(QPointF(0, 0), QSizeF(self.width, self.height))
+
+    def contains(self, pt: QPoint):
+        """
+        Check if the given point lies within the bounding box
+        :param pt: Point to check
+        :return: True if point within box, else False
+        """
+        return (
+            self.x() <= pt.x() <= self.x() + self.width
+            and self.y() <= pt.y() <= self.y() + self.height
+        )
+
+    def paint(
+        self,
+        painter: QPainter,
+        option: QStyleOptionGraphicsItem,
+        widget: typing.Optional[QWidget] = ...,
+    ) -> None:
+        """
+        Paint the item within the scene
+        :param painter: Painter object
+        :param option: Style object
+        :param widget: Optional widget
+        :return:
+        """
+        pen = QPen(self.color.lighter(), 4 if self.highlighted else 2)
+        painter.setPen(pen)
+        painter.drawRect(0, 0, int(self.width), int(self.height))
+
+        painter.setFont(QFont("Helvetica", 12, QFont.Weight.Bold))
+        draw_text = self.label if self.label else "No label"
+        if self.source.part is not None and self.source.part != "self":
+            draw_text += " " + self.source.part
+        painter.drawText(
+            0,
+            int(self.height),
+            int(self.width),
+            20,
+            Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextDontClip,
+            draw_text,
+        )
+
+
+class BoundingBoxManager:
+    """Manages a list of graphical bounding box objects"""
+
+    def __init__(self, bounding_boxes: list = None):
+        if bounding_boxes:
+            self.bounding_boxes = bounding_boxes
+        else:
+            self.bounding_boxes = []
+
+        self.box_click_callback = None
+        self.box_right_click_callback = None
+
+    def make_box(self, x, y, w, h, label, src, editable: bool = True):
+        """
+        Create a box and add it to the manager
+        :param x: x position
+        :param y: y position
+        :param w: Width
+        :param h: Height
+        :param label: Bounding box label
+        :param src: Source bounding box
+        :param editable: Whether the box is editable
+        :return: Graphical bounding box item
+        """
+        box = GraphicsBoundingBox(src, editable=editable)
+        box.set_box(x, y, w, h)
+        box.set_label(label)
+        self.bounding_boxes.append(box)
+        return box
+
+    def set_box_click_callback(self, func):
+        """
+        Set the callback function for when the box is clicked
+        :param func: Callback function
+        :return: None
+        """
+        self.box_click_callback = func
+
+    def set_box_right_click_callback(self, func):
+        """
+        Set the callback function for when the box is clicked
+        :param func: Callback function
+        :return: None
+        """
+        self.box_right_click_callback = func
+
+    def check_box_click(self, pt: QPoint, right_click: bool):
+        """
+        Check managed boxes for point containment, process callbacks
+        :param pt: Point to process
+        :return: None
+        """
+        selected_box = None
+        for box in self.bounding_boxes:
+            if box.contains(pt) and box.editable:
+                if not selected_box or box.area() < selected_box.area():
+                    selected_box = box
+        if self.box_click_callback:
+            if selected_box:
+                if right_click:
+                    self.box_right_click_callback(selected_box)
+                else:
+                    self.box_click_callback(selected_box)
+
+    def get_box_hovered(self, pt: QPoint):
+        """
+        Check managed boxes for point containment, return hovered box if any
+        :param pt: Point to process
+        :return: Hovered box, if any
+        """
+        hovered_box = None
+        for box in self.bounding_boxes:
+            if box.contains(pt) and box.editable:
+                if not hovered_box or box.area() < hovered_box.area():
+                    hovered_box = box
+        return hovered_box
+
+    def boxes(self):
+        return self.bounding_boxes
+
+    def clear(self):
+        self.bounding_boxes.clear()

vars_localize/ui/ConceptEntry.py

@@ -0,0 +1,33 @@
+"""
+Custom QListWidgetItem for displaying concept information.
+"""
+
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QFont
+from PyQt6.QtWidgets import QListWidgetItem
+
+
+class ConceptEntry(QListWidgetItem):
+    def __init__(self, data=None, parent=None):
+        super(ConceptEntry, self).__init__(parent)
+
+        self.setFont(QFont("Courier New"))
+        self.setTextAlignment(Qt.AlignmentFlag.AlignHCenter)
+
+        self.ann_data = data
+        if data:
+            self.update_message()
+
+    def set_ann_data(self, data):
+        self.ann_data = data
+
+    def get_data(self):
+        return self.ann_data
+
+    def update_message(self):
+        """
+        Set message based on annotation data
+        :return: None
+        """
+        str_rep = "{0}: {1}".format(self.ann_data["concept"], self.ann_data["timecode"])
+        self.setText(str_rep)

vars_localize/ui/ConceptSearchbar.py

@@ -0,0 +1,29 @@
+"""
+Custom QLineEdit widget for searching concepts.
+"""
+
+from PyQt6.QtCore import Qt, pyqtSignal
+from PyQt6.QtWidgets import QLineEdit, QCompleter
+
+from vars_localize.util import m3
+
+
+class ConceptSearchbar(QLineEdit):
+    conceptSelected = pyqtSignal()
+
+    def __init__(self, parent=None):
+        super(ConceptSearchbar, self).__init__(parent)
+
+        self.setPlaceholderText("Search for concept")
+
+        self.concept_completer = QCompleter(m3.get_all_concepts())
+        self.concept_completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
+        self.setCompleter(self.concept_completer)
+
+    def set_callback(self, func):
+        """
+        Set callback on completer activation (concept selected)
+        :param func: Activation callback
+        :return: None
+        """
+        self.concept_completer.activated.connect(func)

vars_localize/ui/DisplayPanel.py

@@ -0,0 +1,28 @@
+"""
+Container widget used do display images + localizations and process input.
+"""
+
+from PyQt6.QtWidgets import QWidget, QVBoxLayout
+
+from vars_localize.ui.ImageView import ImageView
+from vars_localize.ui.EntryTree import EntryTreeItem
+
+
+class DisplayPanel(QWidget):
+    def __init__(self, parent=None):
+        super(DisplayPanel, self).__init__(parent)
+
+        self.setLayout(QVBoxLayout())
+
+        self.image_view = ImageView(parent=self)
+
+        self.layout().addWidget(self.image_view, stretch=1)
+
+    def load_entry(self, entry: EntryTreeItem):
+        """
+        Load an entry into the image view, redraw
+        :param entry: Concept entry
+        :return: None
+        """
+        self.image_view.set_entry(entry)
+        self.image_view.redraw()