Safely save frames and images (#148)

* Allow server cameras to be streamable by removing precaution checks

* Unify interface, naming between get_microscope/camera(_class)

* Remove unused _init_attr_dict/get_attrs from microscope client/server

* Do not force server-side attributes to be callable, use them first: these 3 lines took ~3h

* EAFP: Allow camera to call functions whether they are registered or not

* EAFP: Allow camera to call unregistered functions - fixes server cameras

* Remove unnecessary print debug statement

* Add **streamable** description to `config.md` documentation

* Encapsulate FastADT paths in separate prop/method

* Add new TrackingArtist to be used with plotting multi-runs

* Working multi-tracking FastADT frame! Still needs polish

* Change `ClickEvent` to dataclass, implement `ClickEvent.xy`

* Optimize clicking logic in FastADT experiment

* Streamline the `calibrate_beamshift_live` function

* Streamline `CalibBeamShift.plot`

* Improvements to `CalibBeamShift` readability (WIP)

* Add option to calibrate beamshift with vsp

* Fix errors, add beam center

* Switch calibration output format from pickle to yaml

* Allow delay during calibrate beamshift

* Add necessary reflections to fix plotting

* Final tweaks

* Make the yaml produced by CalibBeamShift human-readable

* Update src/instamatic/calibrate/calibrate_beamshift.py

Co-authored-by: Stef Smeets <stefsmeets@users.noreply.github.com>

* Update src/instamatic/calibrate/calibrate_beamshift.py

Co-authored-by: Stef Smeets <stefsmeets@users.noreply.github.com>

* Minor post-review type-hint improvements + ruff

* Add `instamatic.utils.iterating` with `sawtooth` iterating function

* Make the `click_dispatcher:ClickEvent.xy` a property

* Rephrase `VideoStreamProcessor.temporary` using `blocked` context

* Fix the bug where canceling FastADT did not remove its elements

* Fix the bug where colors of crystal tracking repeated after 10

* Remove debug message

* Attempt to generalize collecting, revert as needed

* Fix: rotation speed for negative target pace is negative, rounds to 0

* Rename tracking "mode" to "algo"; if continuous, track w/ movie

* Generalize FastADT run collection (+fix resulting bugs)

* Revert change: use stills for continuous tracking

* Minor fixes and code quality improvements

* Clean, remove unused code

* Fix tracking failing for beam not in the center at alignment

* Fix Run.__str__, clean up code, method, call order

* Log all behavior in two separate message windows.

* Fix ignore msg1,2 variables in headless FastADT experiment

* Update in tests `tracking_mode` -> `tracking_algo`

* Add estimated time required dialog in FastADT message 2

* Display which experiment is being collected in multi-expt

* Display which experiment is being collected in multi-expt

* Trace variables only after everything was defined to avoid Exceptions

* Fix: leaving input empty even temporarily caused exception

* Fix: do not define ExperimentalFastADT.q to receive it from parent

* Fix: Add LiveVideoStream, FakeVideoStream to camera init to fix instamatic.camera script

* Fix: properly defined VideoStreamFrame.app as "advertised"

* Move `get_frame/image` from jobs to VideoStreanFrame: to fix it/avoid crashes

* Prevent repeated calls to alpha_wobble from crashing GUI

* Overwriting prevention mechanism was not needed

* Do not overwrite `self.wobble_stop_event` if not putting in queue

* FastADT: Save tracking images to tracking/ directory

* Remove development imports from videostream_processor.py

---------

Co-authored-by: Stef Smeets <stefsmeets@users.noreply.github.com>

Author: Baharis

src/instamatic/camera/__init__.py

@@ -1,4 +1,4 @@
 from __future__ import annotations
 
 from .camera import get_camera, get_camera_class
-from .videostream import VideoStream
+from .videostream import FakeVideoStream, LiveVideoStream, VideoStream

src/instamatic/experiments/fast_adt/experiment.py

@@ -15,6 +15,7 @@
 import numpy as np
 import pandas as pd
 from matplotlib import pyplot as plt
+from PIL.Image import Image
 from typing_extensions import Self
 
 from instamatic import config
@@ -392,7 +393,8 @@ def determine_pathing_manually(self) -> None:
 
         self.ctrl.restore('FastADT_track')
         Thread(target=self.collect_run, args=(run,), daemon=True).start()
-        tracking_images = deque(maxlen=len(run))
+        tracking_frames = deque(maxlen=len(run))
+        tracking_images: list[Optional[Image]] = [None] * len(run)
         tracking_in_progress = True
         while tracking_in_progress:
             while (step := self.steps.get()) is not None:
@@ -404,15 +406,18 @@ def determine_pathing_manually(self) -> None:
                 click_beamshift_xy = self.beamshift.pixelcoord_to_beamshift(click_beampixel_yx)
                 cols = ['beampixel_x', 'beampixel_y', 'beamshift_x', 'beamshift_y']
                 run.table.loc[step.Index, cols] = *click.xy, *click_beamshift_xy
-                tracking_images.append(step.image)
+                tracking_frames.append(step.image)
             if 'image' not in run.table:
-                run.table['image'] = tracking_images
+                run.table['image'] = tracking_frames
             self.runs.pathing.append(deepcopy(run))
 
             self.msg1('Displaying tracking. Click LEFT mouse button to start the experiment,')
             self.msg2('MIDDLE to track another point, or RIGHT to cancel the experiment.')
             for step in sawtooth(self.runs.tracking.steps):
                 with self.displayed_pathing(step=step):
+                    image = self.videostream_processor.image
+                    image.info['_annotated_runs'] = len(self.runs.pathing)
+                    tracking_images[step.Index] = image
                     with self.click_listener:
                         click = self.click_listener.get_click(timeout=0.5)
                     if click is None:
@@ -428,6 +433,16 @@ def determine_pathing_manually(self) -> None:
                             self.steps.put(new_step)
                     break
 
+        drc = self.path / 'tracking'
+        drc.mkdir(parents=True, exist_ok=True)
+        with self.ctrl.cam.blocked():
+            for step, image in zip(run.steps, tracking_images):
+                i = f'image{step.Index:02d}_al{step.alpha:+03.0f}.png'.replace('+', '0')
+                if image is None or image.info['_annotated_runs'] < len(self.runs.pathing):
+                    with self.displayed_pathing(step=step):
+                        image = self.videostream_processor.image
+                self.videostream_processor.vsf.save_image(image=image, path=drc / i)
+
     def collect_run(self, run: Run) -> None:
         """Collect `run.steps` and place them in `self.steps` Queue."""
         with self.ctrl.beam.unblanked(delay=0.2):

src/instamatic/gui/ctrl_frame.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import queue
 import threading
+from threading import Event
 from tkinter import *
 from tkinter.ttk import *
+from typing import Dict
 
 from instamatic import config
 from instamatic.utils.spinbox import Spinbox
@@ -282,19 +285,21 @@ def get_stage(self, event=None):
 
     def toggle_alpha_wobbler(self):
         if self.var_alpha_wobbler_on.get():
-            self.wobble_stop_event = threading.Event()
-            self.q.put(
-                (
-                    'ctrl',
-                    {
-                        'task': 'stage.alpha_wobbler',
-                        'delta': self.var_alpha_wobbler.get(),
-                        'event': self.wobble_stop_event,
-                    },
-                )
-            )
-        else:  # wobbler off
-            self.wobble_stop_event.set()
+            wobble_stop_event = threading.Event()
+            wobbler_task_keywords = {
+                'task': 'stage.alpha_wobbler',
+                'delta': self.var_alpha_wobbler.get(),
+                'event': wobble_stop_event,
+            }
+            try:
+                self.q.put(('ctrl', wobbler_task_keywords), block=False)
+            except queue.Full:
+                pass
+            else:
+                self.wobble_stop_event = wobble_stop_event
+        else:
+            if self.wobble_stop_event:
+                self.wobble_stop_event.set()
 
     def stage_stop(self):
         self.q.put(('ctrl', {'task': 'stage.stop'}))

src/instamatic/gui/fast_adt_frame.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-import threading
 from functools import wraps
-from queue import Queue
 from tkinter import *
 from tkinter.ttk import *
 from typing import Any, Callable, Optional
@@ -91,7 +89,6 @@ def __init__(self, parent):
         super().__init__(parent, text='Experiment with a priori tracking options')
         self.parent = parent
         self.var = ExperimentalFastADTVariables(on_change=self.update_widget)
-        self.q: Optional[Queue] = None
         self.busy: bool = False
         self.ctrl = controller.get_instance()
 
@@ -241,7 +238,10 @@ def update_widget(self, *_, busy: Optional[bool] = None, **__) -> None:
         self.tracking_step.config(state=tracking_state)
         self.tracking_time.config(state=tracking_state)
 
-        tracking_time, diffraction_time = self.estimate_times()
+        try:
+            tracking_time, diffraction_time = self.estimate_times()
+        except ZeroDivisionError:
+            return
         tt = '{:.0f}:{:02.0f}'.format(*divmod(tracking_time, 60))
         dt = '{:.0f}:{:02.0f}'.format(*divmod(diffraction_time, 60))
         if tracking_time:  # don't display tracking time or per-attempts if zero

src/instamatic/gui/gui.py

@@ -131,20 +131,20 @@ class MainFrame:
 
     def __init__(self, root, cam, modules: list = []):
         super().__init__()
+
+        self.root = root
+        self.app = AppLoader()
+
         # the stream window is a special case, because it needs access
-        # to the cam module
+        # to the cam module and the AppLoader itself
         if cam:
             from .videostream_frame import module as stream_module
 
-            stream_module.set_kwargs(stream=cam)
+            stream_module.set_kwargs(stream=cam, app=self.app)
             modules.insert(0, stream_module)
 
-        self.root = root
-
         self.module_frame = Frame(root)
         self.module_frame.pack(side='top', fill='both', expand=True)
-
-        self.app = AppLoader()
         self.app.load(modules, self.module_frame)
 
         self.root.wm_title(instamatic.__long_title__)

src/instamatic/gui/jobs.py

@@ -7,12 +7,6 @@
 from __future__ import annotations
 
 import time
-from datetime import datetime
-
-import PIL.Image
-
-from instamatic.formats import read_tiff, write_tiff
-from instamatic.processing.flatfield import apply_flatfield_correction
 
 
 def microscope_control(controller, **kwargs):
@@ -34,37 +28,6 @@ def collect_flatfield(controller, **kwargs):
     flatfield.collect_flatfield(controller.ctrl, confirm=False, drc=drc, **kwargs)
 
 
-def save_frame(controller, **kwargs):
-    frame = kwargs.get('frame')
-
-    module_io = controller.app.get_module('io')
-
-    drc = module_io.get_experiment_directory()
-    drc.mkdir(exist_ok=True, parents=True)
-
-    timestamp = datetime.now().strftime('%H-%M-%S.%f')[:-3]  # cut last 3 digits for ms res.
-    outfile = drc / f'frame_{timestamp}.tiff'
-
-    try:
-        flatfield, h = read_tiff(module_io.get_flatfield())
-        frame = apply_flatfield_correction(frame, flatfield)
-    except BaseException:
-        frame = frame
-        h = {}
-
-    write_tiff(outfile, frame, header=h)
-    print('Wrote file:', outfile)
-
-
-def save_image(controller, image: PIL.Image.Image, **_):
-    drc = controller.app.get_module('io').get_experiment_directory()
-    drc.mkdir(exist_ok=True, parents=True)
-    timestamp = datetime.now().strftime('%H-%M-%S.%f')[:-3]  # cut last 3 digits for ms res.
-    out_path = drc / f'image_{timestamp}.png'
-    image.save(out_path, format='PNG')
-    print('Wrote file:', out_path)
-
-
 def toggle_difffocus(controller, **kwargs):
     toggle = kwargs['toggle']
 
@@ -95,8 +58,6 @@ def relax_beam(controller, **kwargs):
 JOBS = {
     'ctrl': microscope_control,
     'flatfield': collect_flatfield,
-    'save_frame': save_frame,
-    'save_image': save_image,
     'toggle_difffocus': toggle_difffocus,
     'relax_beam': relax_beam,
 }

src/instamatic/gui/videostream_frame.py

@@ -2,18 +2,23 @@
 
 import threading
 import time
+from datetime import datetime
+from pathlib import Path
 from tkinter import *
 from tkinter import Label as TkLabel
 from tkinter.ttk import *
-from typing import Union
+from typing import Optional, Union
 
 import numpy as np
 from PIL import Image, ImageTk
 from PIL.Image import Resampling
 
+from instamatic._typing import AnyPath
+from instamatic.formats import read_tiff, write_tiff
 from instamatic.gui.base_module import BaseModule, HasQMixin
 from instamatic.gui.click_dispatcher import ClickDispatcher
 from instamatic.gui.videostream_processor import VideoStreamProcessor
+from instamatic.processing import apply_flatfield_correction
 from instamatic.utils.spinbox import Spinbox
 
 
@@ -221,13 +226,33 @@ def update_display_range(self, name, index, mode):
         except BaseException:
             pass
 
-    def save_frame(self):
+    def save_frame(self, frame: Optional[np.ndarray] = None, path: Optional[AnyPath] = None):
         """Save currently shown raw frame from the stream to a file in cwd."""
-        self.q.put(('save_frame', {'frame': self.frame}))
+        frame = frame if frame is not None else self.processor.frame
+        path = path or Path(self._saving_path_template().format('frame', 'tiff'))
+        try:
+            flatfield, _ = read_tiff(self.app.get_module('io').get_flatfield())
+            frame = apply_flatfield_correction(frame, flatfield)
+        except BaseException:
+            frame = frame
+        write_tiff(path, frame)
+        print('Wrote frame:', path)
 
-    def save_image(self):
+    def save_image(self, image: Optional[Image.Image] = None, path: Optional[AnyPath] = None):
         """Save currently shown, modified, & scaled image to a file in cwd."""
-        self.q.put(('save_image', {'image': self.processor.image}))
+        image = image if image is not None else self.processor.image
+        path = path or Path(self._saving_path_template().format('image', 'png'))
+        image.save(path, format='PNG')
+        print('Wrote image:', path)
+
+    def _saving_path_template(self) -> str:
+        try:
+            drc = self.app.get_module('io').get_experiment_directory()
+            drc.mkdir(exist_ok=True, parents=True)
+        except (AttributeError, FileExistsError, PermissionError):
+            drc = Path.cwd()
+        timestamp = datetime.now().strftime('%H-%M-%S_%f')[:-3]
+        return str(drc / f'{{}}_{timestamp}.{{}}')
 
     def close(self):
         self.stream.close()

src/instamatic/gui/videostream_processor.py

@@ -8,7 +8,6 @@
 from typing import Any, Iterator, Literal, Optional, Protocol, Union
 
 import numpy as np
-import PIL.Image
 from matplotlib.figure import Figure
 from PIL import Image, ImageDraw