fibsem 0.5.0__tar.gz → 0.5.1.dev0__tar.gz

{fibsem-0.5.0 → fibsem-0.5.1.dev0}/.claude/skills/linear/SKILL.md

@@ -22,7 +22,10 @@ Get the user's approval on the plan before proceeding.
 ## Step 3 — Implement
 After plan approval, implement the changes following the existing code patterns and conventions.
 
-## Step 4 — Commit
+## Step 4 — Test
+Before committing, ask the user to test the feature manually and confirm it works as expected. Wait for their confirmation before proceeding.
+
+## Step 5 — Commit
 Create a git commit with a message that:
 - Starts with the type tag matching the issue type: `[fix]`, `[feat]`, `[refactor]`, `[docs]`, etc.
 - Includes `[FIB-$ARGUMENTS]`
@@ -31,3 +34,6 @@ Create a git commit with a message that:
 Example: `[fix][FIB-$ARGUMENTS] correct milling stage drag-drop reorder`
 
 Do NOT include "Claude" or "Co-Authored-By" in the commit message (per project guidelines).
+
+## Step 6 — Mark In Review
+After the commit, update the Linear issue status to "In Review" using `mcp__linear-server__save_issue` with `state: "In Review"`.

{fibsem-0.5.0 → fibsem-0.5.1.dev0}/.gitignore

@@ -52,6 +52,7 @@ fibsem/config/*.yaml
 !fibsem/config/tescan-*.yaml
 !fibsem/config/sim-*.yaml
 !fibsem/config/sample-holder.yaml
+!fibsem/config/default-sample-holder.yaml
 
 **/wandb/*
 tests/notebook.ipynb
@@ -81,3 +82,5 @@ database_migration.md
 fibsem/ui/OFFLINE_ICONS.md
 fibsem/correlation/scaling_factor_lookup_table.csv
 fibsem/correlation/slice_scaling_factor_LUT.ipynb
+sashimi/*
+fibsem/applications/sashimi/log/*

{fibsem-0.5.0 → fibsem-0.5.1.dev0}/GETTING_STARTED.md

@@ -10,7 +10,8 @@ This walkthrough assumes you have installed the application, and configured your
 
 ### Running the Application
 
-Open Anaconda Prompt:
+Run the shortcut set up in [INSTALLATION.md](INSTALLATION.md#create-a-desktop-shortcut) or open Anaconda Prompt and run:
+
 ```bash
 conda activate fibsem
 fibsem-autolamella-ui

{fibsem-0.5.0 → fibsem-0.5.1.dev0}/INSTALLATION.md

@@ -8,8 +8,12 @@
 
 ### Python
 Python 3.9+ is required.
-The [Anaconda distribution](https://www.anaconda.com/distribution/)
-of python is recommended.
+We recommend installing Python via [Miniforge](https://conda-forge.org/download/),
+a minimal installer that uses the community-maintained
+[conda-forge](https://conda-forge.org/) channel by default. It provides the same
+`conda` (and `mamba`) commands as Anaconda/Miniconda while staying lightweight and
+avoiding the licensing terms that can apply to Anaconda's default channels for larger
+organizations.
 
 ## Setting up your python virtual environment
 It is also highly recommended to use virtual environments for development,
@@ -17,13 +21,16 @@ see [Managing Conda Environments](https://docs.conda.io/projects/conda/en/latest
 for more information.
 (Optionally, you could use `virtualenv` if you prefer.)
 
-Create a new virutal environment from the Anaconda Prompt terminal:
+Create a new virtual environment from your conda terminal (the Miniforge Prompt on
+Windows, or any terminal on macOS/Linux):
 ```
 cd fibsem
 conda env create -n fibsem python=3.11 pip
 conda activate fibsem
-pip install -e .
+python -m pip install -e ".[ui]"
 ```
+The `[ui]` extra installs the GUI dependencies (recommended). To install without the
+GUI, use `python -m pip install -e .` instead.
 
 ### Installation through Python virtualenv
 
@@ -40,8 +47,70 @@ fibsem\Scripts\activate.bat
 ```
 Once activated, move to the fibsem root directory and install fibsem like so
 ```
-pip install -e .
+python -m pip install -e ".[ui]"
 ```
+The `[ui]` extra installs the GUI dependencies (recommended). To install without the
+GUI, use `python -m pip install -e .` instead.
+
+### Installation with uv
+
+[uv](https://docs.astral.sh/uv/) is a fast, drop-in replacement for `pip`.
+
+First, install uv (see the [official install guide](https://docs.astral.sh/uv/getting-started/installation/)
+for all options):
+```
+# macOS / Linux
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+```
+# Windows (PowerShell)
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+Alternatively, install it into an existing environment with `pip install uv`.
+
+uv can create and manage the virtual environment itself, so you don't need conda or
+`virtualenv`. From the fibsem root directory, create and activate an environment:
+```
+# macOS / Linux
+uv venv
+source .venv/bin/activate
+```
+```
+# Windows (PowerShell)
+uv venv
+.venv\Scripts\activate
+```
+uv also works inside a conda or `virtualenv` environment created above, with nothing
+extra to set up — just activate that environment instead.
+
+Once your environment is active, install fibsem with the GUI dependencies (recommended):
+```
+uv pip install -e ".[ui]"
+```
+To install without the GUI dependencies:
+```
+uv pip install -e .
+```
+This resolves the same dependencies from `pyproject.toml` as `pip`, just faster.
+No lockfile or additional configuration is required.
+
+### Create a desktop shortcut
+1. Create a script file:
+    Activate the environment then run the following command to create the script:
+    - **Windows**
+
+        Create AutoLamella.bat
+        ```cmd
+        echo @echo off > AutoLamella.bat & where fibsem-autolamella-ui >> AutoLamella.bat
+        ```
+
+    - **Linux**
+
+      Create AutoLamella.sh
+      ```bash
+      printf '#!/bin/bash\n%s' $(which fibsem-autolamella-ui) > AutoLamella.sh
+      ```
+2. Create a shortcut to your script file and place it on your desktop.
 
 ## Installing Microscope Hardware APIs
 
@@ -51,13 +120,13 @@ control of compatible FEI microscope systems.
 This is a commercial product by Thermo Fisher FEI, please visit their website
 at https://www.thermofisher.com/au/en/home/electron-microscopy.html for information on pricing and installation.
 
-We use Autoscript version 4.6.+
+We use Autoscript version 4.7.+
 
 The version numbers of the python packages Autoscript installs were:
 * autoscript-core 5.12.0
-* autoscript-sdb-microscope-client 4.6.0
-* autoscript-sdb-microscope-client-tests 4.6.0
-* autoscript-toolkit 4.6.0
+* autoscript-sdb-microscope-client 4.7.0
+* autoscript-sdb-microscope-client-tests 4.7.0
+* autoscript-toolkit 4.7.0
 * thermoscientific-logging 5.12.0
 
 #### Add the autoscript python packages to your `site-packages`
@@ -93,10 +162,10 @@ You will need to copy:
 * autoscript_core-5.12.0.dist-info
 * autoscript_sdb_microscope_client
 * autoscript_sdb_microscope_client_tests
-* autoscript_sdb_microscope_client_tests-4.6.0.dist-info
-* autoscript_sdb_microscope_client-4.6.0.dist-info
+* autoscript_sdb_microscope_client_tests-4.7.0.dist-info
+* autoscript_sdb_microscope_client-4.7.0.dist-info
 * autoscript_toolkit
-* autoscript_toolkit-4.6.0.dist-info
+* autoscript_toolkit-4.7.0.dist-info
 * thermoscientific_logging
 * thermoscientific_logging-5.12.1.dist-info
 

{fibsem-0.5.0/fibsem.egg-info → fibsem-0.5.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fibsem
-Version: 0.5.0
+Version: 0.5.1.dev0
 Summary: a universal api for fibsem control
 Author-email: Patrick Cleeve <patrick@openfibsem.org>
 License: MIT License
@@ -42,7 +42,9 @@ Provides-Extra: ui
 Requires-Dist: napari>=0.4.17; python_version < "3.9" and extra == "ui"
 Requires-Dist: napari<=0.5.6,>=0.5.1; python_version >= "3.9" and extra == "ui"
 Requires-Dist: pyqt5>=5.15.9; extra == "ui"
+Requires-Dist: pyqt5-qt5==5.15.2; platform_system == "Windows" and extra == "ui"
 Requires-Dist: matplotlib_scalebar>=0.8.1; extra == "ui"
+Requires-Dist: qtawesome>=1.3.0; extra == "ui"
 Provides-Extra: odemis
 Requires-Dist: pylibtiff; extra == "odemis"
 Requires-Dist: shapely; extra == "odemis"

fibsem-0.5.1.dev0/docs/design/autofocus.md

@@ -0,0 +1,276 @@
+# Autofocus: Consolidation & Strategy Extension
+
+> **Status:** Part 1 (consolidation) implemented in [PR #107](https://github.com/fibsem-os/fibsem-os/pull/107) · Part 2 (strategy extension) proposed, not yet implemented.
+
+This document covers two related things:
+
+1. **Consolidation** — how the duplicated FIB-SEM and FM autofocus types/methods were merged into one canonical set, and the reusable recipe for doing the same to other auto-functions.
+2. **Strategy extension** — a simple, forward-looking design for making each focus pass pluggable (e.g. `sweep` vs `hill_climb`), which also finishes the consolidation by unifying the two remaining sweep engines.
+
+Consolidation comes first because the strategy extension builds directly on it.
+
+---
+
+## Part 1 — Consolidating FIB-SEM / FM autofocus
+
+### What existed before
+
+Autofocus was implemented twice, with parallel-but-incompatible types:
+
+| Concern | FIB-SEM (`autofunctions.autofocus`) | FM (`fm.structures` / `fm.calibration`) |
+|---|---|---|
+| Result | `AutoFocusResult` — iteration objects, `save`/`load`, plot | `AutoFocusResult` — parallel lists (`z_positions`, `scores`, `images`), recursive `iterations`, no `save`/`load` |
+| Settings | `AutoFocusSettings` — `passes: list[FocusSweepPass]` | `AutoFocusSettings` — fixed `coarse_*` / `fine_*` |
+| Method enum | `str` | `FocusMethod(Enum)` |
+| Run fn | `run_auto_focus` (multi-pass WD sweep) | `run_autofocus` + `run_coarse_fine_autofocus` (objective-z sweep) |
+| Strategy layer | — | `fm.strategy` package (ABC + generics + pydantic) wrapping the run fns with no real polymorphism |
+
+Two `AutoFocusResult` classes, two `AutoFocusSettings` classes, a duplicated `FocusMethod`, and a 460-line strategy package that added indirection without behaviour.
+
+### The consolidation recipe
+
+The pattern we applied — reusable for any duplicated FIB-SEM/FM auto-function (ACB, charge neutralisation, etc.):
+
+1. **Pick the canonical home.** Lower-level, hardware-agnostic code lives in `fibsem.autofunctions.*`. `fibsem.fm.*` may depend on `autofunctions`, never the reverse — so canonical types go in `autofunctions`.
+2. **Unify the data shape first.** The result/settings types must describe the *same data*, independent of hardware. Here: iterations store a raw `np.ndarray` (not `FibsemImage`), since that's all the focus metric needs; domain-only fields (`channel_name` for FM; `probe_resolution`/`probe_dwell_time`/`use_autocontrast` for FIB-SEM) coexist on one dataclass and are simply ignored by the domain that doesn't use them.
+3. **Re-export for source compatibility.** `fm.structures` re-exports `AutoFocusResult`, `AutoFocusSettings`, `FocusMethod`, `FocusSweepPass` from `autofunctions.autofocus`, so existing `from fibsem.fm.structures import ...` call sites keep working with no edits.
+4. **Provide a factory + legacy loader, not a shim.** `AutoFocusSettings.from_coarse_fine(...)` builds the common two-pass config; `from_dict` accepts both the new `passes` schema and the legacy `coarse_*`/`fine_*` and `n_steps` formats. This is the migration surface — old protocols on disk still load.
+5. **Delete the abstraction that wasn't paying rent.** The `fm.strategy` package was removed; `run_autofocus` / `run_coarse_fine_autofocus` are called directly.
+
+### Canonical types (today)
+
+```python
+class FocusMethod(str, Enum):           # str-Enum: serialises as its value, compares as str
+    LAPLACIAN = "laplacian"; SOBEL = "sobel"; VARIANCE = "variance"; TENENGRAD = "tenengrad"
+
+@dataclass
+class FocusSweepPass:
+    search_range: float = 5e-3          # total span (positions cover ±range/2)
+    step_size: float = 0.5e-3
+    enabled: bool = True
+    @property
+    def n_steps(self) -> int: ...       # derived: round(search_range / step_size)
+
+@dataclass
+class AutoFocusSettings:
+    method: FocusMethod = FocusMethod.TENENGRAD
+    passes: list = None                 # list[FocusSweepPass]; coarse → fine
+    probe_resolution: tuple = (768, 512)   # FIB-SEM only
+    probe_dwell_time: float = 0.5e-6       # FIB-SEM only
+    reduced_area: FibsemRectangle = None
+    use_autocontrast: bool = True          # FIB-SEM only
+    channel_name: Optional[str] = None     # FM only
+
+@dataclass
+class AutoFocusIteration:
+    working_distance: float; focus_score: float; pass_index: int; image: np.ndarray
+
+@dataclass
+class AutoFocusResult:
+    image: np.ndarray; working_distance: float; initial_working_distance: float
+    focus_score: float; iterations: list[AutoFocusIteration]
+    settings: AutoFocusSettings = None; method: Optional[str] = None
+```
+
+### What still isn't consolidated
+
+The **two sweep executors remain duplicated**:
+
+- FIB-SEM `_run_sweep` moves *working distance* (`microscope.set_working_distance`), acquires via `microscope.acquire_image`, scores `probe.filtered_data`.
+- FM `run_autofocus` / `run_coarse_fine_autofocus` move the *objective* (`objective.move_absolute`), acquire via `fm.acquire_image`, crop to ROI, score via `calculate_focus_quality`.
+
+The control flow (sweep positions, argmax, move-to-best, pass tagging, cancellation) is the same in both; only the move + acquire + score primitives differ. Part 2 closes this gap.
+
+One piece of that duplication is already factored out: converting a `FocusSweepPass`
+into a relative sweep is centralised in **`ZParameters.from_focus_pass(pass)`**
+(used by both `run_coarse_fine_autofocus` and the tileset autofocus in
+`fm/acquisition.py`). It lives on `ZParameters` because the conversion targets an
+fm-level type — `autofunctions` can't import it. Note that once the Part 2 driver
+lands, the per-pass path stops going through `ZParameters` at all (the driver
+visits positions directly via `move`); `from_focus_pass` is the interim dedup and
+remains useful for callers that still want a `ZParameters` (e.g. building a z-stack
+from a pass).
+
+---
+
+## Part 2 — Per-pass focus strategy
+
+### Goal
+
+Let each pass choose *how* it searches, not just its range/step. Default stays a full grid sweep; opt into alternatives like an iterative hill-climb:
+
+```python
+FocusSweepPass(search_range=100e-6, step_size=10e-6, strategy=FocusStrategy.HILL_CLIMB)
+```
+
+This must **not** reintroduce the deleted strategy-class layer. A strategy is only the question *"which position do I visit next?"* — independent of how a position is measured.
+
+### Design
+
+Add a per-pass enum (serialises and maps onto existing params):
+
+```python
+class FocusStrategy(str, Enum):
+    SWEEP = "sweep"
+    HILL_CLIMB = "hill_climb"
+
+@dataclass
+class FocusSweepPass:
+    search_range: float = 5e-3
+    step_size: float = 0.5e-3
+    enabled: bool = True
+    strategy: FocusStrategy = FocusStrategy.SWEEP   # NEW
+```
+
+Pull the hardware mechanics into **two callbacks** each executor supplies, and make the strategy a tiny function driving them:
+
+```python
+def _run_pass(p, center, move, measure):
+    """move(pos): position the WD / objective.
+       measure(pos) -> AutoFocusIteration at pos (records into the shared list, returns it).
+       Returns the best iteration; leaves the hardware parked at it."""
+    def evaluate(pos):
+        move(pos)
+        return measure(pos)
+
+    climb = _hill_climb if p.strategy is FocusStrategy.HILL_CLIMB else _sweep
+    best = climb(p, center, evaluate)
+    move(best.working_distance)          # driver guarantees the final park position
+    return best
+
+def _sweep(p, center, evaluate):
+    half = p.search_range / 2
+    its = [evaluate(z) for z in np.linspace(center - half, center + half, p.n_steps + 1)]
+    return max(its, key=lambda it: it.focus_score)
+
+def _hill_climb(p, center, evaluate):
+    half, step = p.search_range / 2, p.step_size
+    best = evaluate(center)
+    direction = max((+1, -1), key=lambda d: evaluate(center + d * step).focus_score)
+    pos = center + direction * step
+    while abs(pos - center) <= half:     # bounded by search_range
+        it = evaluate(pos)
+        if it.focus_score <= best.focus_score:
+            break                        # greedy stop on first non-improvement
+        best, pos = it, pos + direction * step
+    return best
+```
+
+`move` is the primitive that differs between domains — and it's the *only* hardware difference, so factoring it out is what lets one driver serve both:
+
+```python
+# FIB-SEM
+move = lambda wd: microscope.set_working_distance(wd, beam_type)
+def measure(wd):
+    probe = microscope.acquire_image(image_settings=probe_settings)
+    score = float(np.mean(focus_fn(probe.filtered_data.astype(np.float32))))
+    it = AutoFocusIteration(working_distance=wd, focus_score=score,
+                            pass_index=pass_index, image=probe.data)
+    iterations.append(it)
+    return it
+
+# FM — same shape, two lines differ:
+move = lambda z: microscope.objective.move_absolute(z)
+def measure(z):
+    img = microscope.acquire_image()
+    data = img.crop(roi) if roi is not None else img.data
+    score = calculate_focus_quality(data, method=method)
+    it = AutoFocusIteration(working_distance=z, focus_score=score,
+                            pass_index=pass_index, image=data)
+    iterations.append(it)
+    return it
+```
+
+### Cancellation
+
+Both run functions today poll `stop_event` before each position and restore the
+initial position on cancel. The driver keeps that behaviour without threading a
+flag through every strategy: **`measure` owns the check and raises**, the driver
+lets it propagate, and the run function catches it once.
+
+```python
+class AutofocusCancelled(Exception):
+    pass
+
+def measure(pos):                       # inside each executor's closure
+    if stop_event is not None and stop_event.is_set():
+        raise AutofocusCancelled
+    ...                                 # acquire + score + record
+
+# run_auto_focus / run_coarse_fine_autofocus:
+initial = read_current_position()
+try:
+    best = _run_pass(p, center, move, measure)
+except AutofocusCancelled:
+    move(initial)                       # restore, then return None / partial result
+    return None
+```
+
+This keeps strategies oblivious to cancellation (they just call `evaluate`),
+puts the one check at the single I/O point, and centralises restore-on-cancel in
+the run function — which also fixes the current duplication where each path
+re-implements the poll + restore.
+
+### Why this is the sweet spot
+
+- **Finishes the consolidation.** Both `_run_sweep` (FIB-SEM) and the per-pass body of `run_coarse_fine_autofocus` (FM) collapse to "build `move`/`measure`, call `_run_pass`". The extension *removes* the duplication from Part 1 rather than adding code.
+- **No class hierarchy.** Strategies are pure functions over an `evaluate` callback; adding one is a function plus an enum value.
+- **Driver owns the final move-to-best**, so callers can't forget it (both current paths do this manually — easy to get wrong).
+- **No wasted acquisition** — `measure` runs once per visited position; the end-of-pass park is a pure `move`.
+- **`measure(pos)` takes the commanded position** so the recorded `working_distance` is the requested value, not a re-read of (possibly drifted) hardware state.
+
+### Caveats (bake into defaults)
+
+- **Hill-climb assumes a unimodal curve.** Noise or a local dip triggers the greedy stop early. Natural config: **coarse = `SWEEP` (global), fine = `HILL_CLIMB` (fast local refinement)** — exactly the two-pass shape we already have.
+- **Eval count is bounded** by `search_range / step_size` either way, so hill-climb never costs more than a sweep and usually far less.
+- Always evaluating `center` first guarantees the result is no worse than "stay put."
+
+### Testing
+
+Strategies never touch hardware, so they unit-test against a synthetic score curve with fake `move`/`measure` closures (e.g. a Gaussian peaked at a known WD) — no microscope, no Qt. Assert hill-climb converges within `step_size` of the peak and visits ≤ `n_steps + 1` positions.
+
+### UI (optional, later)
+
+A small `QComboBox` as an extra control in each `_PassRowWidget` (the row infra already exists). Until then, default `SWEEP` keeps current behaviour and the field is editable only via the protocol/dict.
+
+### Serialisation
+
+`strategy` is a `(str, Enum)` field on `FocusSweepPass`, so `dataclasses.asdict` serialises it directly; `_sweep_pass_from_dict` reads it with a `SWEEP` default for backward compatibility.
+
+---
+
+## Alternatives considered
+
+| Decision | Chosen | Rejected | Why |
+|---|---|---|---|
+| Strategy granularity | **Per-pass** (`FocusSweepPass.strategy`) | Per-run (`AutoFocusSettings.strategy`) | Per-pass lets coarse stay a global sweep while fine refines via hill-climb — the common case. A per-run flag couldn't express that mix. |
+| Strategy mechanism | **Plain functions over an `evaluate` callback** | Reinstate a strategy class hierarchy (the deleted `fm.strategy` ABC + generics + pydantic) | That layer added 460 lines and indirection with no real polymorphism. A function + enum value is the whole cost of a new strategy. |
+| Iteration image type | **`np.ndarray`** | `FibsemImage` | The focus metric only needs the pixel array; carrying full metadata coupled the canonical type to FIB-SEM imaging and bloated `save`. |
+| FM source compatibility | **Re-export canonical types from `fm.structures`** | Edit every `from fibsem.fm.structures import ...` call site | Re-export is a one-line change per type and keeps the migration reviewable; call sites stay untouched. |
+| Cancellation plumbing | **`measure` raises; run fn catches** | Thread a `stop_event` / return-sentinel through every strategy | Keeps strategies pure and puts the single check at the single I/O point. |
+
+## Known gaps / open questions
+
+- **Tileset acquisition ignores the coarse pass.** `fm/acquisition.py` builds one `ZParameters` from the *last enabled pass* and reuses it for **all** modes (`ONCE`, `EACH_ROW`, `EACH_TILE`), so a configured coarse pass never runs during tiling — contradicting the code's own "coarse only initially" comment. Intended follow-up: `ONCE` → `run_coarse_fine_autofocus` (full passes); per-row/per-tile → fine pass only. Deferred deliberately (behaviour change).
+- **`AutofocusWidget` channel sync.** `set_autofocus_settings` / `update_channels` emit `settings_changed` inconsistently and don't reconcile a `channel_name` that is `None` or no longer in the channel list (combo and model can disagree). Low impact; needs a channel to be removed/renamed mid-session.
+- **Two focus-quality entry points.** FIB-SEM scores via `get_focus_measure_function(...)` on `filtered_data`; FM via `calculate_focus_quality(...)`. The driver unifies the *sweep*, but the scoring call still differs per domain — fine for now, but a candidate for a single `score(image, method)` once the driver lands.
+- **Future strategies the framework enables** (each is one function + enum value): golden-section search, parabolic-fit refinement around the running best, adaptive step (halve `step_size` near the peak).
+
+## Non-goals
+
+- New focus *metrics* (the `FocusMethod` set is unchanged).
+- Changing acquisition cadence or the autofocus *scheduling* modes (`AutoFocusMode`).
+- A general optimiser framework — strategies are deliberately small, 1-D, bounded searches over working distance.
+
+---
+
+## Scope summary
+
+| Change | Files | Effort |
+|---|---|---|
+| `FocusStrategy` enum + `FocusSweepPass.strategy` + serialisation | `autofunctions/autofocus.py` | Small |
+| `_run_pass` + `_sweep`/`_hill_climb` driver | `autofunctions/autofocus.py` | Small |
+| FIB-SEM `run_auto_focus` → use driver | `autofunctions/autofocus.py` | Small |
+| FM `run_coarse_fine_autofocus` → use driver | `fm/calibration/__init__.py` | Small |
+| Strategy unit tests | `tests/...` | Small |
+| Per-pass strategy combo (optional) | `ui/fm/widgets/autofocus_widget.py` | Medium |

fibsem-0.5.1.dev0/docs/design/task-scheduling.md

@@ -0,0 +1,88 @@
+# Task Scheduling for AutoLamella Workflows
+
+## What Exists Today
+
+Tasks can be scheduled to start at a specific date/time rather than running
+immediately.
+
+- **Data model** — `AutoLamellaTaskDescription.scheduled_at: Optional[datetime]`
+  (`fibsem/applications/autolamella/structures.py`), serialized as ISO strings in
+  `to_dict`/`from_dict`. `AutoLamellaWorkflowConfig.get_scheduled_at(task_name)`
+  looks it up by name.
+- **Editor UI** — the task editor dialog (`WorkflowTaskEditorWidget`,
+  `fibsem/ui/widgets/workflow_task_editor_widget.py`) has a *Properties* panel with a
+  "Schedule start time" checkbox + a `QDateTimeEdit` (12-hour AM/PM, up/down step
+  arrows, no calendar popup). The picker is bounded to **now → now + 2 days**
+  (`_MAX_SCHEDULE_DAYS_AHEAD`); a live hint shows how far ahead the time is
+  ("Starts 8h 30m from now …") and warns when a step is blocked by a bound.
+- **Run-time wait** — `TaskManager._wait_until_scheduled(...)`
+  (`fibsem/applications/autolamella/workflows/tasks/manager.py`) blocks before the
+  task's `InProgress` status is emitted, in an interruptible loop
+  (`while not self.is_stopped`). It emits a ~15s countdown to the **bottom status bar**
+  via `update_status_ui(..., status_bar=msg)` → `workflow_update_signal` →
+  `AutoLamellaMainUI._on_workflow_update`.
+- **Cancel during wait** — the Stop button is shown as soon as the workflow starts
+  (`set_workflow_running()` in `_on_run_workflow_clicked`), so a scheduled-but-not-yet-
+  started run is cancellable. Stop sets the manager's `_stop_event`, which the wait loop
+  checks.
+
+## Deferred: "Resume Workflow Now" button
+
+A status-bar button to skip the scheduled wait and start the task immediately, **without**
+cancelling the run and **without** changing the saved `scheduled_at`. Discussed and
+intentionally deferred — the need is real but infrequent, and the workaround (Stop → edit
+task → uncheck schedule → Apply → Run) exists. Add it when an operator actually wants it.
+
+### Why a new event (not reuse Stop)
+
+`_stop_event` cancels the run (the outer `while not self.is_stopped` loop exits, no task
+runs). "Resume Now" must end the wait *and then run the task*, so it needs its own
+event — on skip, `is_stopped` stays False and `_run_queue` falls through to run the task.
+
+### Implementation sketch (~25 lines, no new threads)
+
+1. **`manager.py` — `TaskManager`**
+   - Add `self._skip_wait_event = threading.Event()` in `__init__`; add `skip_wait()` →
+     `self._skip_wait_event.set()` (mirrors `stop()`).
+   - In `_wait_until_scheduled`: clear the event on entry; change the loop guard to
+     `while not self.is_stopped and not self._skip_wait_event.is_set():`. The existing
+     `if self.is_stopped: break` in `_run_queue` is unchanged — on skip it falls through
+     and runs the task. Clearing on entry scopes the skip to the *current* wait, so a
+     later scheduled task still waits (see decision 1).
+2. **`workflows/ui.py`** — add a `waiting: bool = False` flag to `update_status_ui`,
+   included in the emitted dict; the manager passes `waiting=True` on its countdown emits.
+3. **`AutoLamellaUI.py`** — add `skip_scheduled_wait()` mirroring `stop_task_workflow`:
+   guard on `is_workflow_running` / `_task_manager is not None`, then
+   `self._task_manager.skip_wait()`.
+4. **`AutoLamellaMainUI.py`**
+   - In `_create_status_bar`: create `self.resume_now_btn = QPushButton("Resume Workflow Now")`,
+     hidden by default, `addPermanentWidget` next to `stop_workflow_btn`, connect to a
+     handler that calls `self.autolamella_ui.skip_scheduled_wait()`.
+   - In `_on_workflow_update`: `self.resume_now_btn.setVisible(bool(info.get("waiting")))`;
+     hide it once a real task `status` dict arrives (task started).
+   - Hide it in `hide_workflow_running()` and `_on_workflow_finished()`. Do NOT show it in
+     `set_workflow_running()` (that fires at run start, before any wait).
+
+   Alternative to the `waiting` flag: a dedicated `scheduled_wait_signal(bool)` on
+   `AutoLamellaUI` — cleaner separation, slightly more plumbing. The flag-on-existing-signal
+   matches how the countdown message is already routed.
+
+### Decisions to settle before building
+
+1. **Scope** — skip only the current wait (recommended; clear the event each wait) vs. skip
+   all remaining scheduled waits this run (don't clear).
+2. **Confirmation** — Stop has a Yes/No dialog; Resume Now is non-destructive, so likely one
+   click, no dialog.
+3. **Persistence** — must NOT clear `task.scheduled_at`; the schedule stays in the protocol
+   for next time.
+4. **Styling/label** — `SECONDARY_BUTTON_STYLESHEET` vs `PRIMARY`; "Resume Workflow Now" vs
+   "Start Now".
+
+### Testing
+
+- **Unit (manager, headless)** — start a wait far in the future on a worker thread, call
+  `skip_wait()` from the main thread, assert the wait returns promptly and `is_stopped` is
+  False (task proceeds). Assert a fresh wait re-arms (current-wait scope).
+- **Manual UI** — schedule a task ~10 min out, Run → "Resume Workflow Now" appears beside
+  Stop with the countdown → click it → task starts immediately, button disappears, run
+  continues. Confirm Stop still cancels during the wait and `scheduled_at` is unchanged.

{fibsem-0.5.0 → fibsem-0.5.1.dev0}/example/slice_and_view.py

@@ -6,6 +6,7 @@ from pprint import pprint
 
 import fibsem
 from fibsem import acquire, milling, utils, alignment
+from fibsem.alignment import AlignmentSubsystem
 from fibsem.structures import BeamType, ImageSettings, FibsemRectangleSettings
 import numpy as np
 
@@ -57,10 +58,15 @@ def main():
         eb_image = acquire.new_image(microscope, settings.image)
 
 
-        # align
+        # align to the previous slice (stage movement)
         if ref_eb is not None:
-            alignment.align_using_reference_images(microscope, ref_eb, eb_image)
-            ref_eb = eb_image
+            alignment.multi_step_alignment_v2(
+                microscope=microscope,
+                ref_image=ref_eb,
+                steps=3,
+                subsystem=AlignmentSubsystem.STAGE,
+            )
+        ref_eb = eb_image
 
     
         # update patterns

{fibsem-0.5.0 → fibsem-0.5.1.dev0}/fibsem/acquire.py

@@ -4,7 +4,8 @@ import copy
 import os
 from typing import Optional, Tuple
 
-from fibsem.imaging import autogamma
+from fibsem.autofunctions import gamma as autogamma
+from fibsem.autofunctions.acb import run_auto_contrast_brightness
 from fibsem.microscope import FibsemMicroscope
 from fibsem.structures import (
     BeamType,
@@ -39,8 +40,9 @@ def new_image(
     # run autocontrast
     if settings.autocontrast:
         microscope.autocontrast(
-            beam_type=settings.beam_type, reduced_area=settings.reduced_area
-        )
+                beam_type=settings.beam_type,
+                reduced_area=settings.reduced_area
+            )
 
     # acquire the image
     image = microscope.acquire_image(
@@ -291,6 +293,9 @@ def acquire_focus_stacked_image(
         image = acquire_image(microscope, image_settings)
         images.append(image)
 
+    # restore full-frame scanning mode
+    microscope.set_full_frame_scanning_mode(image_settings.beam_type)
+
     # stack images vertically
     arr = np.vstack([img.data for img in images])