brkraw-viewer 0.2.5__py3-none-any.whl

brkraw_viewer/frames/__init__.py

@@ -0,0 +1,2 @@
+"""Reusable UI frames for BrkRaw Viewer."""
+

brkraw_viewer/frames/params_panel.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import tkinter as tk
+from tkinter import ttk
+from typing import Any, Dict, Iterable, Optional
+
+
+class ParamsPanel(ttk.Frame):
+    def __init__(self, parent: tk.Widget) -> None:
+        super().__init__(parent)
+        self.columnconfigure(0, weight=1)
+        self.rowconfigure(1, weight=1)
+
+        self._search_var = tk.StringVar(value="")
+
+        search_bar = ttk.Frame(self)
+        search_bar.grid(row=0, column=0, sticky="ew", pady=(0, 6))
+        search_bar.columnconfigure(1, weight=1)
+
+        ttk.Label(search_bar, text="Search").grid(row=0, column=0, sticky="w")
+        entry = ttk.Entry(search_bar, textvariable=self._search_var)
+        entry.grid(row=0, column=1, sticky="ew", padx=(6, 0))
+        entry.bind("<Return>", self._on_search)
+        ttk.Button(search_bar, text="Go", command=self._on_search).grid(row=0, column=2, padx=(6, 0))
+
+        self._listbox = tk.Listbox(self, exportselection=False, height=10)
+        self._listbox.grid(row=1, column=0, sticky="nsew")
+        self._listbox.bind("<<ListboxSelect>>", self._on_select)
+
+        self._text = tk.Text(self, wrap="word", height=12)
+        self._text.grid(row=2, column=0, sticky="nsew", pady=(6, 0))
+        self._text.configure(state=tk.DISABLED)
+
+        self._params: Dict[str, Dict[str, Any]] = {}
+        self._param_keys: list[str] = []
+
+    def set_params(self, params: Dict[str, Dict[str, Any]]) -> None:
+        self._params = params
+        self._param_keys = sorted(params.keys())
+        self._refresh_list(self._param_keys)
+        self._set_text("Select a parameter file to view contents.")
+
+    def clear(self) -> None:
+        self._params = {}
+        self._param_keys = []
+        self._refresh_list([])
+        self._set_text("No parameter data.")
+
+    def _refresh_list(self, items: Iterable[str]) -> None:
+        self._listbox.delete(0, tk.END)
+        for item in items:
+            self._listbox.insert(tk.END, item)
+
+    def _set_text(self, text: str) -> None:
+        self._text.configure(state=tk.NORMAL)
+        self._text.delete("1.0", tk.END)
+        self._text.insert(tk.END, text)
+        self._text.configure(state=tk.DISABLED)
+
+    def _on_search(self, *_: object) -> None:
+        query = self._search_var.get().strip().lower()
+        if not query:
+            self._refresh_list(self._param_keys)
+            return
+        filtered = [key for key in self._param_keys if query in key.lower()]
+        self._refresh_list(filtered)
+
+    def _on_select(self, *_: object) -> None:
+        selection = self._listbox.curselection()
+        if not selection:
+            return
+        key = self._listbox.get(int(selection[0]))
+        data = self._params.get(key)
+        if not data:
+            self._set_text("No data.")
+            return
+        lines = [f"[{key}]"]
+        for k in sorted(data.keys()):
+            lines.append(f"{k} = {data[k]}")
+        self._set_text("\n".join(lines))

brkraw_viewer/frames/viewer_canvas.py

@@ -0,0 +1,340 @@
+from __future__ import annotations
+
+import tkinter as tk
+from tkinter import ttk
+from typing import Callable, Dict, Optional, Tuple
+
+import numpy as np
+from PIL import Image, ImageTk
+
+
+ClickCallback = Callable[[str, int, int], None]
+ZoomCallback = Callable[[int], None]
+
+
+class OrthogonalCanvas(ttk.Frame):
+    def __init__(self, parent: tk.Widget) -> None:
+        super().__init__(parent)
+        self.columnconfigure(0, weight=1)
+        self.columnconfigure(1, weight=1)
+        self.columnconfigure(2, weight=1)
+        self.rowconfigure(0, weight=1)
+
+        self._canvas_xz = tk.Canvas(self, background="#111111", highlightthickness=0)
+        self._canvas_xy = tk.Canvas(self, background="#111111", highlightthickness=0)
+        self._canvas_zy = tk.Canvas(self, background="#111111", highlightthickness=0)
+
+        self._canvas_xz.grid(row=0, column=0, sticky="nsew", padx=(0, 4))
+        self._canvas_xy.grid(row=0, column=1, sticky="nsew", padx=(0, 4))
+        self._canvas_zy.grid(row=0, column=2, sticky="nsew")
+
+        self._canvas_map = {"xz": self._canvas_xz, "xy": self._canvas_xy, "zy": self._canvas_zy}
+        self._canvas_image_id: Dict[str, Optional[int]] = {"zy": None, "xy": None, "xz": None}
+        self._canvas_text_id: Dict[str, Optional[int]] = {"zy": None, "xy": None, "xz": None}
+        self._tk_images: Dict[str, Optional[ImageTk.PhotoImage]] = {"zy": None, "xy": None, "xz": None}
+        self._markers: Dict[str, list[int]] = {"zy": [], "xy": [], "xz": []}
+        self._boxes: Dict[str, list[int]] = {"zy": [], "xy": [], "xz": []}
+        self._click_callback: Optional[ClickCallback] = None
+        self._zoom_callback: Optional[ZoomCallback] = None
+
+        self._last_views: Optional[Dict[str, Tuple[np.ndarray, Tuple[float, float]]]] = None
+        self._last_titles: Optional[Dict[str, str]] = None
+        self._last_crosshair: Optional[Dict[str, Tuple[int, int]]] = None
+        self._last_show_crosshair: bool = False
+        self._last_message: Optional[str] = None
+        self._last_is_error = False
+        self._render_state: Dict[str, Tuple[int, int, int, int, int, int]] = {}
+
+        for key, canvas in self._canvas_map.items():
+            canvas.bind("<Configure>", self._on_resize)
+            canvas.bind("<Button-1>", lambda event, view=key: self._on_click(view, event))
+            canvas.bind("<MouseWheel>", self._on_mousewheel)
+            canvas.bind("<Button-4>", self._on_mousewheel)
+            canvas.bind("<Button-5>", self._on_mousewheel)
+
+    def set_click_callback(self, callback: Optional[ClickCallback]) -> None:
+        self._click_callback = callback
+
+    def set_zoom_callback(self, callback: Optional[ZoomCallback]) -> None:
+        self._zoom_callback = callback
+
+    def clear_markers(self) -> None:
+        for key, canvas in self._canvas_map.items():
+            for marker_id in self._markers[key]:
+                try:
+                    canvas.delete(marker_id)
+                except Exception:
+                    pass
+            self._markers[key] = []
+
+    def clear_boxes(self) -> None:
+        for key, canvas in self._canvas_map.items():
+            for box_id in self._boxes[key]:
+                try:
+                    canvas.delete(box_id)
+                except Exception:
+                    pass
+            self._boxes[key] = []
+
+    def add_marker(self, view: str, row: int, col: int, color: str) -> None:
+        state = self._render_state.get(view)
+        if state is None:
+            return
+        img_h, img_w, offset_x, offset_y, target_w, target_h = state
+        if img_h <= 0 or img_w <= 0:
+            return
+        display_row = img_h - 1 - row
+        x = offset_x + (col + 0.5) * target_w / img_w
+        y = offset_y + (display_row + 0.5) * target_h / img_h
+        r = 4
+        canvas = self._canvas_map[view]
+        marker_id = canvas.create_oval(x - r, y - r, x + r, y + r, outline=color, width=2)
+        self._markers[view].append(marker_id)
+
+    def add_box(self, view: str, row0: int, col0: int, row1: int, col1: int, *, color: str, width: int = 2) -> None:
+        state = self._render_state.get(view)
+        if state is None:
+            return
+        img_h, img_w, offset_x, offset_y, target_w, target_h = state
+        if img_h <= 0 or img_w <= 0:
+            return
+        r0 = max(0, min(int(row0), img_h - 1))
+        r1 = max(0, min(int(row1), img_h - 1))
+        c0 = max(0, min(int(col0), img_w - 1))
+        c1 = max(0, min(int(col1), img_w - 1))
+        row_min, row_max = sorted((r0, r1))
+        col_min, col_max = sorted((c0, c1))
+        disp_row_min = img_h - 1 - row_max
+        disp_row_max = img_h - 1 - row_min
+        x0 = offset_x + col_min * target_w / img_w
+        x1 = offset_x + (col_max + 1) * target_w / img_w
+        y0 = offset_y + disp_row_min * target_h / img_h
+        y1 = offset_y + (disp_row_max + 1) * target_h / img_h
+        canvas = self._canvas_map[view]
+        box_id = canvas.create_rectangle(x0, y0, x1, y1, outline=color, width=width)
+        self._boxes[view].append(box_id)
+
+    def render_views(
+        self,
+        views: Dict[str, Tuple[np.ndarray, Tuple[float, float]]],
+        titles: Dict[str, str],
+        *,
+        crosshair: Optional[Dict[str, Tuple[int, int]]] = None,
+        show_crosshair: bool = False,
+    ) -> None:
+        self._last_views = views
+        self._last_titles = titles
+        self._last_crosshair = crosshair
+        self._last_show_crosshair = bool(show_crosshair)
+        self._last_message = None
+        self._last_is_error = False
+        self._render_all_views()
+
+    def show_message(self, message: str, *, is_error: bool = False) -> None:
+        self._last_views = None
+        self._last_titles = None
+        self._last_message = message
+        self._last_is_error = is_error
+        for canvas in self._canvas_map.values():
+            self._render_message(canvas, message, is_error=is_error)
+
+    def show_message_on(self, view: str, message: str, *, is_error: bool = False) -> None:
+        self._last_views = None
+        self._last_titles = None
+        self._last_message = message
+        self._last_is_error = is_error
+        for key, canvas in self._canvas_map.items():
+            if key == view:
+                self._render_message(canvas, message, is_error=is_error)
+            else:
+                canvas.delete("all")
+
+    def _render_message(self, canvas: tk.Canvas, message: str, *, is_error: bool) -> None:
+        canvas.delete("all")
+        width = max(canvas.winfo_width(), 1)
+        height = max(canvas.winfo_height(), 1)
+        if is_error:
+            canvas.create_line(10, 10, width - 10, height - 10, fill="#cc3333", width=3)
+            canvas.create_line(10, height - 10, width - 10, 10, fill="#cc3333", width=3)
+            color = "#cc3333"
+        else:
+            color = "#dddddd"
+        canvas.create_text(
+            10,
+            10,
+            anchor="nw",
+            fill=color,
+            text=message,
+            font=("TkDefaultFont", 10, "bold"),
+        )
+
+    def _render_canvas(
+        self,
+        canvas: tk.Canvas,
+        key: str,
+        img: np.ndarray,
+        res: Tuple[float, float],
+        title: str,
+        *,
+        shared_scale: Optional[float] = None,
+    ) -> None:
+        canvas.delete("all")
+        self._markers[key] = []
+        self._boxes[key] = []
+        img = np.asarray(img)
+        if np.iscomplexobj(img):
+            img = np.abs(img)
+        else:
+            try:
+                img = img.astype(float, copy=False)
+            except Exception:
+                img = img.astype(np.float32, copy=False)
+        vmin, vmax = np.nanpercentile(img, (1, 99))
+        if np.isclose(vmin, vmax):
+            vmax = vmin + 1.0
+        img_norm = np.clip((img - vmin) / (vmax - vmin), 0.0, 1.0)
+        img_uint8 = (img_norm * 255).astype(np.uint8)
+        img_display = np.flipud(img_uint8)
+
+        pil_img = Image.fromarray(img_display, mode="L")
+        canvas_w = max(canvas.winfo_width(), 1)
+        canvas_h = max(canvas.winfo_height(), 1)
+        width_mm = float(img.shape[1]) * res[0]
+        height_mm = float(img.shape[0]) * res[1]
+        if shared_scale is not None and width_mm > 0 and height_mm > 0:
+            target_w = max(int(round(width_mm * shared_scale)), 1)
+            target_h = max(int(round(height_mm * shared_scale)), 1)
+            target_w = min(target_w, canvas_w)
+            target_h = min(target_h, canvas_h)
+        else:
+            if width_mm > 0 and height_mm > 0:
+                aspect = width_mm / height_mm
+            else:
+                aspect = pil_img.width / max(pil_img.height, 1)
+            canvas_aspect = canvas_w / max(canvas_h, 1)
+            if canvas_aspect >= aspect:
+                target_h = canvas_h
+                target_w = max(int(target_h * aspect), 1)
+            else:
+                target_w = canvas_w
+                target_h = max(int(target_w / aspect), 1)
+
+        resampling = getattr(Image, "Resampling", Image)
+        resample = getattr(resampling, "NEAREST")
+        pil_img = pil_img.resize((target_w, target_h), resample)
+
+        self._tk_images[key] = ImageTk.PhotoImage(pil_img)
+        x = (canvas_w - target_w) // 2
+        y = (canvas_h - target_h) // 2
+        self._render_state[key] = (img.shape[0], img.shape[1], x, y, target_w, target_h)
+        self._canvas_image_id[key] = canvas.create_image(
+            x,
+            y,
+            anchor="nw",
+            image=self._tk_images[key],
+        )
+
+        self._canvas_text_id[key] = canvas.create_text(
+            10,
+            10,
+            anchor="nw",
+            fill="#dddddd",
+            text=title,
+            font=("TkDefaultFont", 10, "bold"),
+        )
+
+        if self._last_show_crosshair and self._last_crosshair is not None:
+            rc = self._last_crosshair.get(key)
+            if rc is not None:
+                self._draw_crosshair(key=key, row=int(rc[0]), col=int(rc[1]))
+
+    def _draw_crosshair(self, *, key: str, row: int, col: int) -> None:
+        state = self._render_state.get(key)
+        if state is None:
+            return
+        img_h, img_w, offset_x, offset_y, target_w, target_h = state
+        if img_h <= 0 or img_w <= 0 or target_w <= 0 or target_h <= 0:
+            return
+        if row < 0 or col < 0 or row >= img_h or col >= img_w:
+            return
+
+        display_row = img_h - 1 - row
+        x = offset_x + (col + 0.5) * target_w / img_w
+        y = offset_y + (display_row + 0.5) * target_h / img_h
+        x0, x1 = offset_x, offset_x + target_w
+        y0, y1 = offset_y, offset_y + target_h
+
+        dash = (2, 4)
+        color = "#ffffff"
+        width = 1
+        canvas = self._canvas_map[key]
+        canvas.create_line(x0, y, x1, y, fill=color, width=width, dash=dash)
+        canvas.create_line(x, y0, x, y1, fill=color, width=width, dash=dash)
+
+    def _on_resize(self, *_: object) -> None:
+        if self._last_message is not None:
+            for canvas in self._canvas_map.values():
+                self._render_message(canvas, self._last_message, is_error=self._last_is_error)
+            return
+        if self._last_views and self._last_titles:
+            self._render_all_views()
+
+    def _render_all_views(self) -> None:
+        if not self._last_views or not self._last_titles:
+            return
+
+        scales = []
+        for key, canvas in self._canvas_map.items():
+            img, res = self._last_views[key]
+            canvas_w = max(canvas.winfo_width(), 1)
+            canvas_h = max(canvas.winfo_height(), 1)
+            width_mm = float(img.shape[1]) * float(res[0])
+            height_mm = float(img.shape[0]) * float(res[1])
+            if width_mm <= 0 or height_mm <= 0:
+                continue
+            scales.append(min(canvas_w / width_mm, canvas_h / height_mm))
+        shared_scale = min(scales) if scales else None
+
+        for key, canvas in self._canvas_map.items():
+            img, res = self._last_views[key]
+            title = self._last_titles.get(key, "")
+            self._render_canvas(canvas, key, img, res, title, shared_scale=shared_scale)
+
+    def _on_click(self, view: str, event: tk.Event) -> None:
+        if self._click_callback is None:
+            return
+        state = self._render_state.get(view)
+        if state is None:
+            return
+        img_h, img_w, offset_x, offset_y, target_w, target_h = state
+        if img_h <= 0 or img_w <= 0:
+            return
+        x = event.x - offset_x
+        y = event.y - offset_y
+        if x < 0 or y < 0 or x > target_w or y > target_h:
+            return
+        col = int(x * img_w / max(target_w, 1))
+        display_row = int(y * img_h / max(target_h, 1))
+        row = img_h - 1 - display_row
+        self._click_callback(view, row, col)
+
+    def _on_mousewheel(self, event: tk.Event) -> Optional[str]:
+        if self._zoom_callback is None:
+            return None
+        direction = 0
+        delta = getattr(event, "delta", 0)
+        if isinstance(delta, int) and delta != 0:
+            direction = 1 if delta > 0 else -1
+        else:
+            num = getattr(event, "num", None)
+            if num == 4:
+                direction = 1
+            elif num == 5:
+                direction = -1
+        if direction != 0:
+            try:
+                self._zoom_callback(direction)
+            except Exception:
+                pass
+            return "break"
+        return None

brkraw_viewer/frames/viewer_config.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+import logging
+
+from brkraw.core import config as config_core
+from brkraw.core.config import resolve_root
+
+logger = logging.getLogger("brkraw.viewer")
+
+
+def _default_registry_columns() -> List[Dict[str, Any]]:
+    return [
+        {"key": "basename", "title": "Name", "width": 180},
+        {"key": "Study.ID", "title": "Study ID", "width": 120},
+        {"key": "Study.Date", "title": "Study Date", "width": 120},
+        {"key": "Study.Number", "title": "Study Number", "width": 120},
+        {"key": "Study.Operator", "title": "Study Operator", "width": 140},
+        {"key": "num_scans", "title": "Scans", "width": 70},
+        {"key": "path", "title": "Path", "width": 360},
+    ]
+
+
+def default_viewer_config() -> Dict[str, Any]:
+    return {
+        "cache": {
+            "enabled": False,
+            "max_items": 10,
+        },
+        "registry": {
+            "path": "viewer/registry.jsonl",
+            "columns": _default_registry_columns(),
+        },
+    }
+
+
+def _deep_merge(base: Dict[str, Any], updates: Dict[str, Any]) -> Dict[str, Any]:
+    merged = dict(base)
+    for key, value in updates.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = _deep_merge(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def _load_config(root: Optional[Path]) -> Dict[str, Any]:
+    data = config_core.load_config(root=root)
+    if data is None:
+        data = config_core.default_config()
+    if not isinstance(data, dict):
+        raise ValueError("config.yaml must contain a YAML mapping at the top level.")
+    return data
+
+
+def load_viewer_config(root: Optional[Path] = None) -> Dict[str, Any]:
+    config = _load_config(root)
+    viewer = config.get("viewer", {})
+    if not isinstance(viewer, dict):
+        viewer = {}
+    return _deep_merge(default_viewer_config(), viewer)
+
+
+def ensure_viewer_config(root: Optional[Path] = None) -> Dict[str, Any]:
+    config = _load_config(root)
+    viewer = config.get("viewer", {})
+    if not isinstance(viewer, dict):
+        viewer = {}
+    merged = _deep_merge(default_viewer_config(), viewer)
+    config["viewer"] = merged
+    config_core.write_config(config, root=root)
+    return merged
+
+
+def save_viewer_config(viewer: Dict[str, Any], root: Optional[Path] = None) -> None:
+    config = _load_config(root)
+    config["viewer"] = viewer
+    config_core.write_config(config, root=root)
+
+
+def registry_path(root: Optional[Path] = None) -> Path:
+    viewer = load_viewer_config(root)
+    registry = viewer.get("registry", {})
+    rel = registry.get("path", "viewer/registry.jsonl")
+    if isinstance(rel, str):
+        rel_path = Path(rel)
+    else:
+        rel_path = Path("viewer/registry.jsonl")
+    if rel_path.is_absolute():
+        return rel_path
+    return resolve_root(root) / rel_path
+
+
+def registry_columns(root: Optional[Path] = None) -> List[Dict[str, Any]]:
+    viewer = load_viewer_config(root)
+    registry = viewer.get("registry", {})
+    columns = registry.get("columns", [])
+    if isinstance(columns, list):
+        return [col for col in columns if isinstance(col, dict)]
+    return _default_registry_columns()

brkraw_viewer/plugin.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+from typing import List
+
+from brkraw.core import config as config_core
+from brkraw.core import formatter
+
+from .apps.viewer import launch
+from .registry import registry_status, register_paths, unregister_paths, resolve_entry_value
+from .frames.viewer_config import ensure_viewer_config, registry_columns, registry_path
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:  # type: ignore[name-defined]
+    parser = subparsers.add_parser(
+        "viewer",
+        help="Launch the BrkRaw scan viewer GUI.",
+    )
+    parser.add_argument(
+        "path",
+        nargs="*",
+        help="Path to the Bruker study root directory.",
+    )
+    parser.add_argument("--scan", type=int, default=None, help="Initial scan id.")
+    parser.add_argument("--reco", type=int, default=None, help="Initial reco id.")
+    parser.add_argument(
+        "--info-spec",
+        default=None,
+        help="Optional scan info spec YAML path (use instead of the default mapping).",
+    )
+    parser.set_defaults(func=_run_viewer)
+
+
+def _run_viewer(args: argparse.Namespace) -> int:
+    commands = {"init", "register", "unregister", "list"}
+    paths: List[str] = list(args.path or [])
+    if paths and paths[0] in commands:
+        command = paths.pop(0)
+        if command == "init":
+            return _cmd_init()
+        if command == "register":
+            return _cmd_register(paths)
+        if command == "unregister":
+            return _cmd_unregister(paths)
+        if command == "list":
+            return _cmd_list()
+        return 2
+    if len(paths) > 1:
+        print("Error: too many paths provided for viewer launch.", flush=True)
+        return 2
+    path = paths[0] if paths else None
+    return launch(
+        path=path,
+        scan_id=args.scan,
+        reco_id=args.reco,
+        info_spec=args.info_spec,
+    )
+
+
+def _cmd_init() -> int:
+    ensure_viewer_config()
+    reg_path = registry_path()
+    reg_path.parent.mkdir(parents=True, exist_ok=True)
+    if not reg_path.exists():
+        reg_path.write_text("", encoding="utf-8")
+    print(f"Viewer registry initialized: {reg_path}")
+    return 0
+
+
+def _cmd_register(paths: List[str]) -> int:
+    if not paths:
+        print("Error: missing path to register.")
+        return 2
+    targets = [Path(p) for p in paths]
+    try:
+        entries = register_paths(targets)
+    except Exception as exc:
+        print(f"Error: failed to register dataset(s): {exc}")
+        return 2
+    print(f"Registered {len(entries)} dataset(s).")
+    return 0
+
+
+def _cmd_unregister(paths: List[str]) -> int:
+    if not paths:
+        print("Error: missing path to unregister.")
+        return 2
+    targets = [Path(p) for p in paths]
+    removed = unregister_paths(targets)
+    print(f"Removed {removed} dataset(s).")
+    return 0
+
+
+def _cmd_list() -> int:
+    logger = logging.getLogger("brkraw.viewer")
+    rows = registry_status()
+    width = config_core.output_width(root=None)
+    columns = [dict(col) for col in registry_columns()]
+    if not any(col.get("key") == "missing" for col in columns):
+        columns.append({"key": "missing", "title": "Missing", "width": 80})
+    visible = [col for col in columns if not col.get("hidden")]
+    keys = [col["key"] for col in visible]
+    formatted_rows = []
+    for entry in rows:
+        row: dict[str, object] = {}
+        for col in visible:
+            key = col["key"]
+            value = resolve_entry_value(entry, key)
+            if key == "missing" and entry.get("missing"):
+                row[key] = {"value": value, "color": "red"}
+            else:
+                row[key] = value
+        formatted_rows.append(row)
+    table = formatter.format_table(
+        "Viewer Registry",
+        tuple(keys),
+        formatted_rows,
+        width=width,
+        title_color="cyan",
+        col_widths=formatter.compute_column_widths(tuple(keys), formatted_rows),
+    )
+    logger.info("%s", table)
+    return 0