Add performance diagnostics and screenshot features

Introduces performance diagnostics, including histograms for image display, histogram update, stage move, and image acquisition times, parsed from log files. Adds a button to save a screenshot of the diagnostics popup.

Author: AdvancedImagingUTSW

docs/capture_gui.py

@@ -1,7 +1,7 @@
-from mss import mss
-from PIL import Image
 import tkinter as tk
 import os
+
+from navigate.tools.gui import capture_region, tk_window_bbox
 from navigate.view.splash_screen import SplashScreen
 from navigate.controller.controller import Controller
 from navigate.tools.main_functions import create_parser, evaluate_parser_input_arguments
@@ -59,23 +59,6 @@ def get_controller():
     return root, controller
 
 
-def capture_region(x, y, w, h, out_path):
-    with mss() as sct:
-        img = sct.grab(
-            {"left": int(x), "top": int(y), "width": int(w), "height": int(h)}
-        )
-        Image.frombytes("RGB", img.size, img.rgb).save(out_path)
-
-
-def tk_window_bbox(win, pad=0):
-    win.update_idletasks()
-    x = win.winfo_rootx() - pad
-    y = win.winfo_rooty() - pad
-    w = win.winfo_width() + 2 * pad
-    h = win.winfo_height() + 2 * pad
-    return x, y, w, h
-
-
 if __name__ == "__main__":
     root, controller = get_controller()
     current_directory = os.path.dirname(os.path.realpath(__file__))

pyproject.toml

@@ -40,7 +40,8 @@ dependencies = [
     'fsspec==2022.5.0; sys_platform == "darwin"',
     'h5py==3.7.0',
     'requests==2.28.1',
-    'psutil==6.0.0'
+    'psutil==6.0.0',
+    "mss"
     ]
 
 [project.scripts]
@@ -69,7 +70,6 @@ docs = [
     "pyyaml",
     "pydata_sphinx_theme==0.10.0rc2",
     "sphinx-toolbox",
-    "mss"
 ]
 
 robot = [

src/navigate/controller/controller.py

@@ -278,7 +278,8 @@ def __init__(
 
         #: StageController: Stage Sub-Controller.
         self.stage_controller = StageController(
-            self.view.settings.stage_control_tab, self,
+            self.view.settings.stage_control_tab,
+            self,
         )
 
         #: WaveformTabController: Waveform Display Sub-Controller.
@@ -726,7 +727,7 @@ def execute(self, command, *args):
             self.threads_pool.createThread(
                 resourceName="model",
                 target=self.update_stage_limits,
-                args=(microscope_name,)
+                args=(microscope_name,),
             )
 
         elif command == "move_stage_and_update_info":
@@ -1166,7 +1167,7 @@ def capture_image(self, command, mode, *args):
                 break
             # Receive the Image and log it.
             image_id = self.show_img_pipe.recv()
-            logger.info(f"Navigate Controller - Received Image: {image_id}")
+            logger.info(f"Received image from the controller: {image_id}")
 
             if image_id == "stop":
                 self.current_image_id = -1
@@ -1412,7 +1413,7 @@ def stop_stage(self):
 
     def update_stage_limits(self, microscope_name: str) -> None:
         """Update stage limits on the device side
-        
+
         Parameters
         ----------
         microscope_name : str

src/navigate/controller/sub_controllers/diagnostics_popup.py

@@ -34,6 +34,8 @@
 from typing import Optional
 from datetime import datetime
 import re
+from tkinter import filedialog
+from PIL import ImageGrab
 
 # Third Party Imports
 import numpy as np
@@ -89,6 +91,9 @@ def __init__(
             command=self.populate_plots,
         )
 
+        # Add trace to save a screenshot of the popup
+        self.view.buttons["save_image"].configure(command=self.capture_image)
+
         # Initialize plots (empty)
         self.initialize_plots()
 
@@ -105,6 +110,43 @@ def close_popup(self) -> None:
 
         logger.debug("Diagnostics popup closed and sub-controller deleted.")
 
+    def capture_image(self) -> None:
+
+        # Create default filename with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        default_filename = f"diagnostics_{timestamp}.png"
+
+        # Set default directory to user's home directory
+        default_dir = os.path.expanduser("~")
+
+        # Open file dialog
+        file_path = filedialog.asksaveasfilename(
+            initialdir=default_dir,
+            initialfile=default_filename,
+            defaultextension=".png",
+            filetypes=[("PNG files", "*.png"), ("All files", "*.*")],
+        )
+
+        # If user cancels, return without saving
+        if not file_path:
+            return
+
+        # Make sure that the save dialog has time to close before capturing the screenshot
+        self.view.popup.after_idle(lambda: self._take_screenshot(file_path))
+
+    def _take_screenshot(self, file_path):
+        # Get the window geometry
+        x = self.view.popup.winfo_rootx()
+        y = self.view.popup.winfo_rooty()
+        width = self.view.popup.winfo_width()
+        height = self.view.popup.winfo_height()
+
+        # Capture the screenshot
+        screenshot = ImageGrab.grab(bbox=(x, y, x + width, y + height))
+        screenshot.save(file_path)
+
+        logger.info(f"Diagnostics screenshot saved to: {file_path}")
+
     def initialize_plots(self):
         """Initialize empty plots with axes but no data."""
         # Y-axis labels for each plot
@@ -144,142 +186,94 @@ def populate_plots(self):
         model_log, controller_log = load_latest_log_file()
 
         # Plot the histogram of the display times from the controller log
-        self.plot_display_time_histogram(controller_log)
-
-        # Plot the duration of time necessary to transfer the data between processes.
-
-        #
-        # # Generate dummy data
-        # time_points = np.linspace(0, 60, 100)  # 60 seconds of data
-        #
-        # # Different data patterns for each plot
-        # data_sets = {
-        #     1: 10
-        #     + 5 * np.sin(np.linspace(0, 4 * np.pi, 100))
-        #     + np.random.normal(0, 1, 100),  # IPC latency
-        #     2: 30
-        #     + 5 * np.sin(np.linspace(0, 3 * np.pi, 100))
-        #     + np.random.normal(0, 2, 100),  # Display FPS
-        #     3: 25
-        #     + 10 * np.sin(np.linspace(0, 2 * np.pi, 100))
-        #     + np.random.normal(0, 3, 100),  # Saving rate
-        #     4: 15
-        #     + 7 * np.sin(np.linspace(0, 5 * np.pi, 100))
-        #     + np.random.normal(0, 1.5, 100),  # Histogram update
-        #     5: 50
-        #     + 20 * np.sin(np.linspace(0, 2.5 * np.pi, 100))
-        #     + np.random.normal(0, 5, 100),  # Processing time
-        #     6: np.cumsum(np.random.normal(0, 5, 100))
-        #     + 500,  # Memory usage (growing trend)
-        # }
-        #
-        # # Y-axis labels for each plot
-        # y_labels = {
-        #     1: "Latency (ms)",
-        #     2: "FPS",
-        #     3: "MB/s",
-        #     4: "Time (ms)",
-        #     5: "Time (ms)",
-        #     6: "Memory (MB)",
-        # }
-        #
-        # # Update each plot
-        # for i in range(2, 7):
-        #     # Get figure and clear it
-        #     fig = self.view.inputs[f"diagnostics_{i}"]
-        #     ax = fig.axes[0]
-        #     ax.clear()
-        #
-        #     # Plot the data
-        #     ax.plot(time_points, data_sets[i], linewidth=2)
-        #
-        #     # Add labels and grid
-        #     ax.set_xlabel("Time (s)")
-        #     ax.set_ylabel(y_labels[i])
-        #     ax.grid(True, linestyle="--", alpha=0.7)
-        #
-        #     # Add some stats
-        #     mean_val = np.mean(data_sets[i])
-        #     ax.text(
-        #         0.05,
-        #         0.95,
-        #         f"Mean: {mean_val:.2f}",
-        #         transform=ax.transAxes,
-        #         fontsize=9,
-        #         va="top",
-        #         bbox=dict(boxstyle="round", alpha=0.1),
-        #     )
-        #
-        #     # Draw the canvas
-        #     self.view.inputs[f"canvas_{i}"].draw()
-        #     self.view.inputs[f"canvas_{i}"].get_tk_widget().pack(
-        #         fill="both", expand=True
-        #     )
+        pattern = r"camera_view: Displaying image took (\d+\.\d+) seconds"
+        times = self.extract_times(controller_log, pattern)
+        self.plot_histogram(panel=1, times=times)
+
+        # Plot the histogram of the times necessary to populate the histogram.
+        pattern = r"histogram: Histogram populated in (\d+\.\d+) seconds"
+        times = self.extract_times(controller_log, pattern)
+        self.plot_histogram(panel=2, times=times)
+
+        # Plot the time to move the z and f stages during a z-stack.
+        pattern = (
+            r"common_features: Z- and F-position move duration: (\d+\.\d+) seconds"
+        )
+        times = self.extract_times(model_log, pattern)
+        self.plot_histogram(panel=3, times=times)
+
+        # Plot the time necessary to acquire a new image.
+        pattern = r"model: New image acquired in (\d+\.\d+) seconds"
+        times = self.extract_times(model_log, pattern)
+        self.plot_histogram(panel=4, times=times)
 
     @staticmethod
-    def extract_display_times(log_content):
+    def extract_times(log_content, pattern):
         """
         Extract image display times from controller log content.
 
         Parameters
         ----------
         log_content : list or None
             List of log lines from the controller log
+        pattern : str
+            Regular expression pattern to match display time entries
 
         Returns
         -------
-        list
-            A list of float values representing display times in seconds
+        times : list
+            A list of float values representing times in seconds
         """
 
         if not log_content:
-            return []
-
-        # Pattern to match display time entries
-        pattern = r"camera_view: Displaying image took (\d+\.\d+) seconds"
+            return None
 
         # Extract all matching times
-        display_times = []
+        times = []
         for line in log_content:
             match = re.search(pattern, line)
             if match:
-                display_times.append(float(match.group(1)))
+                times.append(float(match.group(1)))
 
-        return display_times
+        times = times if len(times) > 0 else None
+        return times
 
-    def plot_display_time_histogram(self, controller_log):
+    def plot_histogram(self, panel, times):
         """
         Create a histogram of image display times with statistics.
 
         Parameters
         ----------
-        controller_log : str
-            The content of the controller log file as a string or list of lines
+        panel : int
+            The panel number to plot the histogram on (1-6)
+        times : list
+            A list of times in seconds to plot
         """
-
-        fig = self.view.inputs[f"diagnostics_1"]
+        fig = self.view.inputs[f"diagnostics_{panel}"]
         ax = fig.axes[0]
         ax.clear()
 
-        display_times = self.extract_display_times(controller_log)
-
-        if not display_times:
+        if times is None:
             ax.text(
                 0.5,
                 0.5,
-                "No display time data available",
+                "No data available",
                 ha="center",
                 va="center",
                 transform=ax.transAxes,
             )
+            self.view.inputs[f"canvas_{panel}"].draw()
+            self.view.inputs[f"canvas_{panel}"].get_tk_widget().pack(
+                fill="both", expand=True
+            )
             return
 
         # Convert to milliseconds for better readability
-        display_times_ms = [t * 1000 for t in display_times]
+        times_ms = [t * 1000 for t in times]
 
         # Plot histogram
         _, _, _ = ax.hist(
-            display_times_ms,
+            times_ms,
             bins=20,
             alpha=0.7,
             color="skyblue",
@@ -288,8 +282,8 @@ def plot_display_time_histogram(self, controller_log):
         )
 
         # Calculate statistics
-        mean_val = np.mean(display_times_ms)
-        std_val = np.std(display_times_ms)
+        mean_val = np.mean(times_ms)
+        std_val = np.std(times_ms)
 
         # Add vertical lines for mean and std dev
         ax.axvline(
@@ -308,17 +302,13 @@ def plot_display_time_histogram(self, controller_log):
         )
         ax.axvline(mean_val - std_val, color="g", linestyle="dotted", linewidth=2)
 
-        # Add text with statistics
-        stats_text = f"Mean: {mean_val:.2f} ms\nStd Dev: {std_val:.2f} ms\nSamples: {len(display_times_ms)}"
-        ax.text(
-            0.05,
-            0.95,
-            stats_text,
-            transform=ax.transAxes,
-            fontsize=9,
-            va="top",
-            bbox=dict(boxstyle="round", alpha=0.5),
+        # Add text with statistics as a title
+        stats_text = (
+            f"Mean: {mean_val:.2f} ms."
+            f"Std Dev: {std_val:.2f} ms."
+            f"N: {len(times_ms)}"
         )
+        ax.set_title(stats_text, fontsize=9)
 
         # Update labels
         ax.set_xlabel("Time (ms)")
@@ -328,5 +318,7 @@ def plot_display_time_histogram(self, controller_log):
         ax.grid(True, linestyle="--", alpha=0.7)
 
         # Draw the canvas
-        self.view.inputs[f"canvas_1"].draw()
-        self.view.inputs[f"canvas_1"].get_tk_widget().pack(fill="both", expand=True)
+        self.view.inputs[f"canvas_{panel}"].draw()
+        self.view.inputs[f"canvas_{panel}"].get_tk_widget().pack(
+            fill="both", expand=True
+        )