Perception Benchmark Live Viewer
-
+
Connecting...
- 
+
`;
// Also get embryoId and groundTruth from stored data if not provided
embryoId = embryoId || imgData.embryoId;
@@ -628,10 +630,13 @@ async def broadcast(message: Dict):
// Update header
document.querySelector('.trace-section h2').innerHTML =
- `Reasoning Trace - T${timepoint} `;
+ `Reasoning Trace - T${timepoint} `;
if (traceSteps.length === 0) {
- list.innerHTML = 'THREE-VIEW (XY | YZ / XZ)
-
+
+ THREE-VIEW (XY | YZ / XZ)
+
No trace recorded for T' + timepoint + '
';
+ list.innerHTML = 'No trace recorded for T'
+ + timepoint + '
';
return;
}
@@ -685,12 +690,16 @@ async def broadcast(message: Dict):
'verified' : '';
html += `
-
+
`;
}
@@ -749,10 +758,14 @@ async def websocket_endpoint(websocket: WebSocket):
connected_clients.append(websocket)
# Send current state
- await websocket.send_text(json.dumps({
- "type": "status",
- "status": benchmark_state["status"],
- }))
+ await websocket.send_text(
+ json.dumps(
+ {
+ "type": "status",
+ "status": benchmark_state["status"],
+ }
+ )
+ )
try:
while True:
@@ -789,8 +802,8 @@ def __init__(
embryo_id: str,
enable_verification: bool = True,
start_timepoint: int = 0,
- max_timepoints: Optional[int] = None,
- trace_dir: Optional[Path] = None,
+ max_timepoints: int | None = None,
+ trace_dir: Path | None = None,
):
self.testset = testset
self.embryo_id = embryo_id
@@ -798,7 +811,7 @@ def __init__(
self.start_timepoint = start_timepoint
self.max_timepoints = max_timepoints
- self.predictions: List[Dict] = []
+ self.predictions: list[dict] = []
self.correct_count = 0
self.adjacent_count = 0
self.verified_count = 0
@@ -808,7 +821,7 @@ def __init__(
self.trace_dir = trace_dir or Path("benchmarks/results/traces")
self.run_dir = self.trace_dir / f"{self.run_id}_{embryo_id}"
self.run_dir.mkdir(parents=True, exist_ok=True)
- self.traces: Dict[int, List[Dict]] = {} # timepoint -> trace steps
+ self.traces: dict[int, list[dict]] = {} # timepoint -> trace steps
logger.info(f"Trace persistence enabled: {self.run_dir}")
@@ -861,23 +874,23 @@ async def run(self):
benchmark_state["current_timepoint"] = test_case.timepoint
# Send image(s)
- await broadcast({
- "type": "image",
- "embryo_id": self.embryo_id,
- "timepoint": test_case.timepoint,
- "ground_truth": test_case.ground_truth_stage,
- "image": test_case.image_b64, # Combined for backward compat
- "top_image": test_case.top_image_b64,
- "side_image": test_case.side_image_b64,
- })
+ await broadcast(
+ {
+ "type": "image",
+ "embryo_id": self.embryo_id,
+ "timepoint": test_case.timepoint,
+ "ground_truth": test_case.ground_truth_stage,
+ "image": test_case.image_b64, # Combined for backward compat
+ "top_image": test_case.top_image_b64,
+ "side_image": test_case.side_image_b64,
+ }
+ )
# Clear trace for new prediction
await broadcast({"type": "clear_trace"})
# Run perception with trace streaming
- result = await self._run_perception_with_streaming(
- engine, session, test_case
- )
+ result = await self._run_perception_with_streaming(engine, session, test_case)
# Check accuracy
is_correct = result.stage == test_case.ground_truth_stage
@@ -915,23 +928,29 @@ async def run(self):
await broadcast(pred_msg)
# Save trace for this timepoint
- self._save_timepoint_trace(test_case.timepoint, result, test_case, is_correct, is_adjacent)
+ self._save_timepoint_trace(
+ test_case.timepoint, result, test_case, is_correct, is_adjacent
+ )
# Send updated stats
total = len(self.predictions)
- await broadcast({
- "type": "stats",
- "accuracy": self.correct_count / total if total > 0 else None,
- "adjacent": self.adjacent_count / total if total > 0 else None,
- "total": total,
- "verified": self.verified_count,
- })
+ await broadcast(
+ {
+ "type": "stats",
+ "accuracy": self.correct_count / total if total > 0 else None,
+ "adjacent": self.adjacent_count / total if total > 0 else None,
+ "total": total,
+ "verified": self.verified_count,
+ }
+ )
# Add observation to session with simulated timestamp
# Typical diSPIM acquisition interval is ~4 minutes per timepoint
- simulated_timestamp = datetime.now() - timedelta(
- minutes=(self.max_timepoints or 100) * 4
- ) + timedelta(minutes=test_case.timepoint * 4)
+ simulated_timestamp = (
+ datetime.now()
+ - timedelta(minutes=(self.max_timepoints or 100) * 4)
+ + timedelta(minutes=test_case.timepoint * 4)
+ )
session.add_observation(
timepoint=test_case.timepoint,
@@ -953,7 +972,6 @@ async def run(self):
async def _run_perception_with_streaming(self, engine, session, test_case):
"""Run perception and stream trace steps."""
- from gently.harness.perception.session import ReasoningStep
# We need to hook into the reasoning trace
# For now, run perception and stream the trace after
@@ -985,7 +1003,9 @@ async def _run_perception_with_streaming(self, engine, session, test_case):
return result
- def _save_timepoint_trace(self, timepoint: int, result, test_case, is_correct: bool, is_adjacent: bool):
+ def _save_timepoint_trace(
+ self, timepoint: int, result, test_case, is_correct: bool, is_adjacent: bool
+ ):
"""Save trace for a single timepoint to disk."""
trace_data = {
"timepoint": timepoint,
@@ -1035,7 +1055,7 @@ async def run_benchmark_background(
embryo_id: str,
enable_verification: bool,
start_timepoint: int = 0,
- max_timepoints: Optional[int] = None,
+ max_timepoints: int | None = None,
):
"""Run benchmark in background after server starts."""
print("[DEBUG] run_benchmark_background starting", flush=True)
@@ -1049,7 +1069,10 @@ async def run_benchmark_background(
# Load data
ground_truth = GroundTruth.from_json(ground_truth_path)
- print(f"[DEBUG] Loaded ground truth: {len(ground_truth.transitions)} embryos", flush=True)
+ print(
+ f"[DEBUG] Loaded ground truth: {len(ground_truth.transitions)} embryos",
+ flush=True,
+ )
testset = OfflineTestset(
session_path=session_path,
ground_truth=ground_truth,
@@ -1071,6 +1094,7 @@ async def run_benchmark_background(
except Exception as e:
print(f"[DEBUG] ERROR in run_benchmark_background: {e}", flush=True)
import traceback
+
traceback.print_exc()
@@ -1142,9 +1166,9 @@ def main():
trace_dir = Path("benchmarks/results/traces")
run_id = datetime.now().strftime("%Y%m%d_%H%M%S")
- print(f"\n{'='*60}")
+ print(f"\n{'=' * 60}")
print("Perception Benchmark Live Viewer")
- print(f"{'='*60}")
+ print(f"{'=' * 60}")
print(f"Session: {session_path}")
print(f"Embryo: {args.embryo}")
print(f"Start timepoint: T{args.start_timepoint}")
@@ -1152,7 +1176,7 @@ def main():
print(f"Verification: {'disabled' if args.no_verification else 'enabled'}")
print(f"Traces: {trace_dir / f'{run_id}_{args.embryo}'}")
print(f"URL: http://localhost:{args.port}")
- print(f"{'='*60}\n")
+ print(f"{'=' * 60}\n")
# Open browser
if not args.no_browser:
@@ -1162,14 +1186,16 @@ def main():
@app.on_event("startup")
async def startup_event():
print("[DEBUG] Startup event fired", flush=True)
- asyncio.create_task(run_benchmark_background(
- session_path=session_path,
- ground_truth_path=gt_path,
- embryo_id=args.embryo,
- enable_verification=not args.no_verification,
- start_timepoint=args.start_timepoint,
- max_timepoints=args.max_timepoints,
- ))
+ asyncio.create_task(
+ run_benchmark_background(
+ session_path=session_path,
+ ground_truth_path=gt_path,
+ embryo_id=args.embryo,
+ enable_verification=not args.no_verification,
+ start_timepoint=args.start_timepoint,
+ max_timepoints=args.max_timepoints,
+ )
+ )
print("[DEBUG] Background task created", flush=True)
# Run server
diff --git a/benchmarks/perception/metrics.py b/benchmarks/perception/metrics.py
index f69c054f..f0578ea1 100644
--- a/benchmarks/perception/metrics.py
+++ b/benchmarks/perception/metrics.py
@@ -6,14 +6,23 @@
from collections import defaultdict
from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
if TYPE_CHECKING:
from .runner import BenchmarkReport
# Stage order for metrics
-STAGE_ORDER = ["early", "bean", "comma", "1.5fold", "2fold", "pretzel", "hatching", "hatched"]
+STAGE_ORDER = [
+ "early",
+ "bean",
+ "comma",
+ "1.5fold",
+ "2fold",
+ "pretzel",
+ "hatching",
+ "hatched",
+]
@dataclass
@@ -25,30 +34,30 @@ class PerceptionMetrics:
adjacent_accuracy: float = 0.0 # Within 1 stage
# Per-stage accuracy
- stage_accuracy: Dict[str, float] = field(default_factory=dict)
- stage_counts: Dict[str, int] = field(default_factory=dict)
+ stage_accuracy: dict[str, float] = field(default_factory=dict)
+ stage_counts: dict[str, int] = field(default_factory=dict)
# Confusion matrix: confusion[gt_stage][pred_stage] = count
- confusion_matrix: Dict[str, Dict[str, int]] = field(default_factory=dict)
+ confusion_matrix: dict[str, dict[str, int]] = field(default_factory=dict)
# Confidence calibration
mean_confidence: float = 0.0
confidence_when_correct: float = 0.0
confidence_when_wrong: float = 0.0
- calibration_bins: List[Tuple[float, float, int]] = field(default_factory=list)
+ calibration_bins: list[tuple[float, float, int]] = field(default_factory=list)
# (confidence_bin_center, accuracy_in_bin, count)
expected_calibration_error: float = 0.0 # ECE
# Temporal metrics
backward_transitions: int = 0 # Errors where stage went backward
- stage_transition_delay: Dict[str, float] = field(default_factory=dict)
+ stage_transition_delay: dict[str, float] = field(default_factory=dict)
# How many timepoints after GT transition until prediction caught up
# Tool usage
total_tool_calls: int = 0
tool_call_rate: float = 0.0 # Avg tool calls per prediction
- tool_use_by_stage: Dict[str, float] = field(default_factory=dict)
+ tool_use_by_stage: dict[str, float] = field(default_factory=dict)
# When tools were used vs not
accuracy_with_tools: float = 0.0
@@ -59,7 +68,7 @@ class PerceptionMetrics:
transitional_rate: float = 0.0
transitional_accuracy: float = 0.0 # Accuracy when marked transitional
- def to_dict(self) -> Dict[str, Any]:
+ def to_dict(self) -> dict[str, Any]:
return {
"accuracy": self.accuracy,
"adjacent_accuracy": self.adjacent_accuracy,
@@ -102,8 +111,7 @@ def compute_metrics(report: "BenchmarkReport") -> PerceptionMetrics:
# Collect all predictions
all_preds = [
- p for r in report.embryo_results for p in r.predictions
- if p.ground_truth_stage is not None
+ p for r in report.embryo_results for p in r.predictions if p.ground_truth_stage is not None
]
if not all_preds:
@@ -134,9 +142,7 @@ def compute_metrics(report: "BenchmarkReport") -> PerceptionMetrics:
for p in all_preds:
confusion[p.ground_truth_stage][p.predicted_stage] += 1
- metrics.confusion_matrix = {
- gt: dict(preds) for gt, preds in confusion.items()
- }
+ metrics.confusion_matrix = {gt: dict(preds) for gt, preds in confusion.items()}
# Confidence statistics
confidences = [p.confidence for p in all_preds]
@@ -156,10 +162,7 @@ def compute_metrics(report: "BenchmarkReport") -> PerceptionMetrics:
bin_high = (i + 1) / num_bins
bin_center = (bin_low + bin_high) / 2
- bin_preds = [
- p for p in all_preds
- if bin_low <= p.confidence < bin_high
- ]
+ bin_preds = [p for p in all_preds if bin_low <= p.confidence < bin_high]
if bin_preds:
bin_accuracy = sum(1 for p in bin_preds if p.is_correct) / len(bin_preds)
@@ -207,7 +210,9 @@ def compute_metrics(report: "BenchmarkReport") -> PerceptionMetrics:
if with_tools:
metrics.accuracy_with_tools = sum(1 for p in with_tools if p.is_correct) / len(with_tools)
if without_tools:
- metrics.accuracy_without_tools = sum(1 for p in without_tools if p.is_correct) / len(without_tools)
+ metrics.accuracy_without_tools = sum(1 for p in without_tools if p.is_correct) / len(
+ without_tools
+ )
# Transitional observations
transitional_preds = [p for p in all_preds if p.is_transitional]
@@ -215,16 +220,16 @@ def compute_metrics(report: "BenchmarkReport") -> PerceptionMetrics:
metrics.transitional_rate = len(transitional_preds) / len(all_preds)
if transitional_preds:
- metrics.transitional_accuracy = sum(
- 1 for p in transitional_preds if p.is_correct
- ) / len(transitional_preds)
+ metrics.transitional_accuracy = sum(1 for p in transitional_preds if p.is_correct) / len(
+ transitional_preds
+ )
return metrics
def format_confusion_matrix(
- confusion: Dict[str, Dict[str, int]],
- stages: Optional[List[str]] = None,
+ confusion: dict[str, dict[str, int]],
+ stages: list[str] | None = None,
) -> str:
"""Format confusion matrix as ASCII table."""
if stages is None:
@@ -278,34 +283,38 @@ def format_metrics_summary(metrics: PerceptionMetrics) -> str:
count = metrics.stage_counts[stage]
lines.append(f" {stage:>10}: {acc:.1%} (n={count})")
- lines.extend([
- "",
- "CONFIDENCE CALIBRATION",
- f" Mean confidence: {metrics.mean_confidence:.2f}",
- f" Confidence (correct): {metrics.confidence_when_correct:.2f}",
- f" Confidence (wrong): {metrics.confidence_when_wrong:.2f}",
- f" Expected Cal. Error: {metrics.expected_calibration_error:.3f}",
- "",
- "TOOL USAGE",
- f" Total tool calls: {metrics.total_tool_calls}",
- f" Avg calls per pred: {metrics.tool_call_rate:.2f}",
- f" Accuracy with tools: {metrics.accuracy_with_tools:.1%}",
- f" Accuracy without tools: {metrics.accuracy_without_tools:.1%}",
- "",
- "TEMPORAL",
- f" Backward transitions: {metrics.backward_transitions}",
- "",
- "TRANSITIONAL OBSERVATIONS",
- f" Count: {metrics.transitional_count}",
- f" Rate: {metrics.transitional_rate:.1%}",
- f" Accuracy: {metrics.transitional_accuracy:.1%}",
- ])
+ lines.extend(
+ [
+ "",
+ "CONFIDENCE CALIBRATION",
+ f" Mean confidence: {metrics.mean_confidence:.2f}",
+ f" Confidence (correct): {metrics.confidence_when_correct:.2f}",
+ f" Confidence (wrong): {metrics.confidence_when_wrong:.2f}",
+ f" Expected Cal. Error: {metrics.expected_calibration_error:.3f}",
+ "",
+ "TOOL USAGE",
+ f" Total tool calls: {metrics.total_tool_calls}",
+ f" Avg calls per pred: {metrics.tool_call_rate:.2f}",
+ f" Accuracy with tools: {metrics.accuracy_with_tools:.1%}",
+ f" Accuracy without tools: {metrics.accuracy_without_tools:.1%}",
+ "",
+ "TEMPORAL",
+ f" Backward transitions: {metrics.backward_transitions}",
+ "",
+ "TRANSITIONAL OBSERVATIONS",
+ f" Count: {metrics.transitional_count}",
+ f" Rate: {metrics.transitional_rate:.1%}",
+ f" Accuracy: {metrics.transitional_accuracy:.1%}",
+ ]
+ )
if metrics.confusion_matrix:
- lines.extend([
- "",
- "CONFUSION MATRIX",
- format_confusion_matrix(metrics.confusion_matrix),
- ])
+ lines.extend(
+ [
+ "",
+ "CONFUSION MATRIX",
+ format_confusion_matrix(metrics.confusion_matrix),
+ ]
+ )
return "\n".join(lines)
diff --git a/benchmarks/perception/runner.py b/benchmarks/perception/runner.py
index 33d93fe3..70ac32fd 100644
--- a/benchmarks/perception/runner.py
+++ b/benchmarks/perception/runner.py
@@ -12,11 +12,11 @@
from dataclasses import dataclass, field
from datetime import datetime
from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
from .ground_truth import GroundTruth
-from .testset import OfflineTestset, TestCase
from .metrics import PerceptionMetrics, compute_metrics
+from .testset import OfflineTestset
logger = logging.getLogger(__name__)
@@ -39,20 +39,20 @@ class BenchmarkConfig:
# Test settings
start_timepoint: int = 0
- max_timepoints_per_embryo: Optional[int] = None
- embryo_ids: Optional[List[str]] = None # None = all
+ max_timepoints_per_embryo: int | None = None
+ embryo_ids: list[str] | None = None # None = all
# Ablation toggles
include_temporal_context: bool = True
include_previous_observations: bool = True
# Custom system prompt override
- system_prompt_override: Optional[str] = None
+ system_prompt_override: str | None = None
# Metadata
description: str = ""
- def to_dict(self) -> Dict[str, Any]:
+ def to_dict(self) -> dict[str, Any]:
return {
"model": self.model,
"temperature": self.temperature,
@@ -78,20 +78,20 @@ class PredictionResult:
timepoint: int
predicted_stage: str
- ground_truth_stage: Optional[str]
+ ground_truth_stage: str | None
confidence: float
is_transitional: bool
- transition_between: Optional[List[str]]
+ transition_between: list[str] | None
reasoning: str
- reasoning_trace: Optional[Dict[str, Any]] # Serialized ReasoningTrace
+ reasoning_trace: dict[str, Any] | None # Serialized ReasoningTrace
tool_calls: int
- tools_used: List[str]
+ tools_used: list[str]
# Multi-phase verification fields
verification_triggered: bool = False
phase_count: int = 1
- verification_result: Optional[Dict[str, Any]] = None
- candidate_stages: Optional[List[Dict[str, Any]]] = None
+ verification_result: dict[str, Any] | None = None
+ candidate_stages: list[dict[str, Any]] | None = None
@property
def is_correct(self) -> bool:
@@ -113,7 +113,7 @@ def is_adjacent_correct(self) -> bool:
except ValueError:
return False
- def to_dict(self) -> Dict[str, Any]:
+ def to_dict(self) -> dict[str, Any]:
return {
"timepoint": self.timepoint,
"predicted_stage": self.predicted_stage,
@@ -139,9 +139,9 @@ class EmbryoResult:
"""Results for a single embryo run."""
embryo_id: str
- predictions: List[PredictionResult] = field(default_factory=list)
+ predictions: list[PredictionResult] = field(default_factory=list)
duration_seconds: float = 0.0
- error: Optional[str] = None
+ error: str | None = None
@property
def accuracy(self) -> float:
@@ -159,7 +159,7 @@ def adjacent_accuracy(self) -> float:
correct = sum(1 for p in self.predictions if p.is_adjacent_correct)
return correct / len(self.predictions)
- def to_dict(self) -> Dict[str, Any]:
+ def to_dict(self) -> dict[str, Any]:
return {
"embryo_id": self.embryo_id,
"predictions": [p.to_dict() for p in self.predictions],
@@ -175,11 +175,11 @@ class BenchmarkReport:
"""Complete benchmark report."""
config: BenchmarkConfig
- embryo_results: List[EmbryoResult] = field(default_factory=list)
- metrics: Optional[PerceptionMetrics] = None
+ embryo_results: list[EmbryoResult] = field(default_factory=list)
+ metrics: PerceptionMetrics | None = None
started_at: datetime = field(default_factory=datetime.now)
- completed_at: Optional[datetime] = None
- session_id: Optional[str] = None
+ completed_at: datetime | None = None
+ session_id: str | None = None
@property
def total_predictions(self) -> int:
@@ -192,7 +192,7 @@ def overall_accuracy(self) -> float:
return 0.0
return sum(1 for p in all_preds if p.is_correct) / len(all_preds)
- def to_dict(self) -> Dict[str, Any]:
+ def to_dict(self) -> dict[str, Any]:
return {
"config": self.config.to_dict(),
"embryo_results": [r.to_dict() for r in self.embryo_results],
@@ -222,7 +222,7 @@ def __init__(
self,
testset: OfflineTestset,
config: BenchmarkConfig,
- engine: Optional[Any] = None, # PerceptionEngine
+ engine: Any | None = None, # PerceptionEngine
):
"""
Parameters
@@ -246,7 +246,6 @@ async def _get_engine(self):
# Lazy import to avoid circular dependencies
import anthropic
from gently.harness.perception.engine import PerceptionEngine
- from gently.harness.perception.example_store import ExampleStore
client = anthropic.Anthropic()
@@ -465,7 +464,8 @@ async def main():
help="Description for this benchmark run",
)
parser.add_argument(
- "-v", "--verbose",
+ "-v",
+ "--verbose",
action="store_true",
help="Verbose logging",
)
@@ -481,6 +481,7 @@ async def main():
# The perception engine reads stage definitions etc. from the active
# organism module, which is normally loaded by launch_gently.py.
from gently.organisms import load_organism
+
load_organism("celegans")
# Find session path
diff --git a/benchmarks/perception/testset.py b/benchmarks/perception/testset.py
index 658cc011..075eccdb 100644
--- a/benchmarks/perception/testset.py
+++ b/benchmarks/perception/testset.py
@@ -6,10 +6,10 @@
import base64
import io
+from collections.abc import Iterator
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
-from typing import Iterator, List, Optional, Tuple, Dict
import numpy as np
@@ -26,10 +26,12 @@ def _ensure_dependencies():
if tifffile is None:
import tifffile as _tifffile
+
tifffile = _tifffile
if PIL_Image is None:
from PIL import Image as _Image
+
PIL_Image = _Image
@@ -40,23 +42,25 @@ class TestCase:
embryo_id: str
timepoint: int
image_b64: str # Combined view (for backward compatibility)
- top_image_b64: Optional[str] # TOP view only
- side_image_b64: Optional[str] # SIDE view only
- volume: Optional[np.ndarray]
- ground_truth_stage: Optional[str]
- acquired_at: Optional[datetime] = None
+ top_image_b64: str | None # TOP view only
+ side_image_b64: str | None # SIDE view only
+ volume: np.ndarray | None
+ ground_truth_stage: str | None
+ acquired_at: datetime | None = None
def _discover_volumes(
- session_dir: Path, embryo_id: Optional[str] = None
-) -> Dict[str, List[Tuple[datetime, Path]]]:
+ session_dir: Path, embryo_id: str | None = None
+) -> dict[str, list[tuple[datetime, Path]]]:
"""Discover volume files (with parsed acquisition timestamps) in a session directory."""
if not session_dir.exists():
return {}
tif_files = (
- list(session_dir.glob("*.tif")) + list(session_dir.glob("*.tiff"))
- + list(session_dir.glob("**/*.tif")) + list(session_dir.glob("**/*.tiff"))
+ list(session_dir.glob("*.tif"))
+ + list(session_dir.glob("*.tiff"))
+ + list(session_dir.glob("**/*.tif"))
+ + list(session_dir.glob("**/*.tiff"))
)
# Deduplicate (flat + recursive may overlap)
tif_files = list({f.resolve(): f for f in tif_files}.values())
@@ -89,6 +93,7 @@ def _discover_volumes(
def _load_volume(path: Path) -> np.ndarray:
"""Load a volume from TIFF file."""
from gently.core.imaging import load_volume
+
return load_volume(path)
@@ -122,9 +127,9 @@ def _create_three_view_image(volume: np.ndarray, max_dim: int = 1500) -> str:
_ensure_dependencies()
from gently.core.imaging import (
- projection_three_view,
- compute_crop_bounds,
apply_crop_bounds,
+ compute_crop_bounds,
+ projection_three_view,
)
# Auto-crop to embryo region
@@ -150,7 +155,7 @@ def _create_three_view_image(volume: np.ndarray, max_dim: int = 1500) -> str:
return base64.b64encode(buffer.getvalue()).decode("utf-8")
-def _create_separate_view_images(volume: np.ndarray, max_dim: int = 1000) -> Tuple[str, str]:
+def _create_separate_view_images(volume: np.ndarray, max_dim: int = 1000) -> tuple[str, str]:
"""Create separate TOP and SIDE view images from volume, return base64 tuple.
Parameters
@@ -244,7 +249,7 @@ def __init__(
self._embryo_volumes = _discover_volumes(self.session_path)
@property
- def embryo_ids(self) -> List[str]:
+ def embryo_ids(self) -> list[str]:
"""Get list of embryo IDs with both volumes and ground truth."""
gt_embryos = set(self.ground_truth.embryo_ids)
vol_embryos = set(self._embryo_volumes.keys())
@@ -258,7 +263,7 @@ def iter_embryo(
self,
embryo_id: str,
start_timepoint: int = 0,
- end_timepoint: Optional[int] = None,
+ end_timepoint: int | None = None,
) -> Iterator[TestCase]:
"""
Iterate through timepoints for an embryo sequentially.
@@ -318,7 +323,7 @@ def iter_embryo(
acquired_at=acquired_at,
)
- def iter_all(self) -> Iterator[Tuple[str, Iterator[TestCase]]]:
+ def iter_all(self) -> Iterator[tuple[str, Iterator[TestCase]]]:
"""
Iterate through all embryos in the testset.
diff --git a/benchmarks/perception/trace_viewer.py b/benchmarks/perception/trace_viewer.py
index 5a3ced2d..69ea5fa6 100644
--- a/benchmarks/perception/trace_viewer.py
+++ b/benchmarks/perception/trace_viewer.py
@@ -7,12 +7,9 @@
import argparse
import json
import sys
-from datetime import datetime
from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from .metrics import format_metrics_summary, PerceptionMetrics
+from .metrics import PerceptionMetrics, format_metrics_summary
HTML_TEMPLATE = """
@@ -293,16 +290,16 @@
"""
-def generate_embryo_section(embryo_id: str, predictions: List[Dict]) -> str:
+def generate_embryo_section(embryo_id: str, predictions: list[dict]) -> str:
"""Generate HTML for one embryo's predictions."""
rows = [
'
",
]
for i, pred in enumerate(predictions):
@@ -320,15 +317,15 @@ def generate_embryo_section(embryo_id: str, predictions: List[Dict]) -> str:
row_id = f"{embryo_id}-{timepoint}"
rows.append(f'T${pred.timepoint}
- ${pred.predicted}
- ${pred.ground_truth}
+ ${pred.predicted}
+ ${pred.ground_truth}
${(pred.confidence * 100).toFixed(0)}%
- ${pred.phase_count > 1 ? pred.phase_count + '-phase' : ''}${verifiedBadge}
+ ${pred.phase_count > 1
+ ? pred.phase_count + '-phase' : ''}${verifiedBadge}
',
- '
',
+ "Timepoint
',
- 'Predicted
',
- 'Ground Truth
',
- 'Confidence
',
- 'Details
',
- 'Timepoint
",
+ "Predicted
",
+ "Ground Truth
",
+ "Confidence
",
+ "Details
",
+ "')
- rows.append(f'
""")
+ rows.append("")
# Reasoning trace (hidden by default)
trace_html = format_reasoning_trace(pred.get("reasoning_trace"))
- rows.append(f'''T{timepoint}
')
+ rows.append(f"T{timepoint}
")
rows.append(f'{pred_stage}
')
rows.append(f'{gt_stage}
')
- rows.append(f'''
+ rows.append(f"""
""")
# Details column with expand button
tool_calls = pred.get("tool_calls", 0)
@@ -351,31 +348,31 @@ def generate_embryo_section(embryo_id: str, predictions: List[Dict]) -> str:
if phase_count > 1:
badges += f'{phase_count}-phase'
- rows.append(f'''
{confidence:.0%}
-
''')
+
+ rows.append(f"""
')
+
{details_str}
{badges}
-
''')
- rows.append('
+ rows.append(f"""
""")
- return f'''
+ return f"""
Reasoning: {reasoning}
{trace_html}
-
''')
+ {embryo_id}
{"".join(rows)}
Tool Call: {tool_name}
Input: {json.dumps(tool_input, indent=2)}
- ''')
+ """)
elif step_type == "tool_result":
summary = step.get("tool_result_summary", content)
- html_parts.append(f'''
+ html_parts.append(f"""
Input: {json.dumps(tool_input, indent=2)}
Tool Result: {summary}
- ''')
+ """)
elif step_type == "final_decision":
- html_parts.append(f'''
+ html_parts.append(f"""
Final Decision:
{content[:500]}...
- ''')
+ """)
elif step_type == "verification_requested":
- html_parts.append(f'''
+ html_parts.append(f"""
{content[:500]}...
Verification Requested:
{content}
- ''')
+ """)
elif step_type == "verification_subagent":
tool_input = step.get("tool_input", {})
summary = step.get("tool_result_summary", content)
- html_parts.append(f'''
+ html_parts.append(f"""
{content}
- Subagent: {tool_input.get("stage_a", "?")} vs {tool_input.get("stage_b", "?")}
+ Subagent: {tool_input.get("stage_a", "?")} vs + {tool_input.get("stage_b", "?")}
Result: {summary}
- ''')
+ """)
elif step_type == "verification_result":
- html_parts.append(f'''
+ html_parts.append(f"""
+ Subagent: {tool_input.get("stage_a", "?")} vs + {tool_input.get("stage_b", "?")}
Result: {summary}
Verification Result:
{content}
- ''')
+ """)
return "".join(html_parts)
-def generate_confusion_matrix_html(confusion: Dict[str, Dict[str, int]]) -> str:
+def generate_confusion_matrix_html(confusion: dict[str, dict[str, int]]) -> str:
"""Generate HTML table for confusion matrix."""
- stages = ["early", "bean", "comma", "1.5fold", "2fold", "pretzel", "hatching", "hatched"]
+ stages = [
+ "early",
+ "bean",
+ "comma",
+ "1.5fold",
+ "2fold",
+ "pretzel",
+ "hatching",
+ "hatched",
+ ]
# Filter to stages present in data
present = set()
@@ -478,7 +485,7 @@ def generate_confusion_matrix_html(confusion: Dict[str, Dict[str, int]]) -> str:
return "".join(rows)
-def generate_html_report(report_data: Dict) -> str:
+def generate_html_report(report_data: dict) -> str:
"""Generate complete HTML report from benchmark data."""
# Extract summary metrics
metrics = report_data.get("metrics", {})
@@ -493,9 +500,7 @@ def generate_html_report(report_data: Dict) -> str:
# Generate embryo sections
embryo_sections = []
for er in embryo_results:
- embryo_sections.append(
- generate_embryo_section(er["embryo_id"], er["predictions"])
- )
+ embryo_sections.append(generate_embryo_section(er["embryo_id"], er["predictions"]))
# Generate confusion matrix
confusion = metrics.get("confusion_matrix", {})
@@ -569,8 +574,7 @@ def main():
# Filter embryo if specified
if args.embryo:
report_data["embryo_results"] = [
- er for er in report_data.get("embryo_results", [])
- if er["embryo_id"] == args.embryo
+ er for er in report_data.get("embryo_results", []) if er["embryo_id"] == args.embryo
]
# Generate HTML
diff --git a/benchmarks/runner.py b/benchmarks/runner.py
index 4d6d847a..7dd31236 100644
--- a/benchmarks/runner.py
+++ b/benchmarks/runner.py
@@ -13,8 +13,6 @@
import json
import logging
import sys
-from datetime import datetime
-from pathlib import Path
logging.basicConfig(level=logging.INFO, format="%(message)s")
logger = logging.getLogger(__name__)
@@ -66,7 +64,6 @@ async def run_agent_benchmark(args):
def compare_reports(args):
"""Compare two benchmark reports"""
- from .agent.evaluator import BenchmarkReport, compare_reports as _compare
with open(args.before) as f:
before_data = json.load(f)
@@ -101,7 +98,10 @@ def compare_reports(args):
delta_str = f"+{fmt.format(delta)}" if delta > 0 else fmt.format(delta)
status = "improved" if delta > 0 else ("regressed" if delta < 0 else "unchanged")
- logger.info(f" {name}: {fmt.format(before_val)} -> {fmt.format(after_val)} ({delta_str}) [{status}]")
+ logger.info(
+ f" {name}: {fmt.format(before_val)} -> {fmt.format(after_val)}"
+ f" ({delta_str}) [{status}]"
+ )
# Token comparison
before_tokens = before_data.get("tokens", {})
@@ -111,7 +111,7 @@ def compare_reports(args):
after_total = after_tokens.get("total_input", 0) + after_tokens.get("total_output", 0)
token_delta = after_total - before_total
- logger.info(f"\nTokens:")
+ logger.info("\nTokens:")
logger.info(f" Total: {before_total:,} -> {after_total:,} ({token_delta:+,})")
return 0
diff --git a/config/config.yml b/config/config.yml
index e59e9f6d..9c05c274 100644
--- a/config/config.yml
+++ b/config/config.yml
@@ -1,4 +1,38 @@
organism: "celegans"
hardware: "dispim"
mmconfig: "MMConfig_tracking_screening.cfg"
-mmdirectory: "C:/Program Files/Micro-Manager-1.4"
\ No newline at end of file
+mmdirectory: "C:/Program Files/Micro-Manager-1.4"
+
+# SwitchBot Bot — physical button-pusher mounted on the diSPIM room light
+# switch. Talks BLE direct (no SwitchBot Hub / cloud). Plans address it by
+# name, e.g. `bps.mv(room_light, 'on')`. Remove this block to skip
+# registration; the device layer is tolerant of either state.
+switchbot:
+ name: room_light
+ address: "EC:6F:04:06:5B:23"
+ timeout: 20.0
+
+# ACUITYnano Precision Thermal Controller (Peltier/TEC, 0.0–99.9 °C). When this
+# block is present the device layer registers a `temperature` device and the
+# Devices tab shows a setpoint control; plans can also block on it via
+# `bps.mv(temperature, 20.0)`. Remove/comment the block to skip registration.
+#
+# backend: mqtt talks to the controller over the vendor's MQTT bridge
+# (acuitynano_precision_thermalizer_api). With no broker/port/user/password
+# keys it uses the vendor package's embedded HiveMQ Cloud defaults — set them
+# here only to point at a different broker. The vendor package must be
+# installed on the device-layer machine (not on PyPI).
+temperature:
+ name: temperature
+ backend: serial # serial | mqtt | mock — USB serial is the working
+ # link on this machine (MQTT cloud is firewalled)
+ com_port: "COM8"
+ baud_rate: 115200
+ stabilize_timeout: 600 # seconds to wait for "[ SYSTEM LOCKED ]" on a blocking set
+ feedback_peltier: false # true = control off the peltier sensor instead of water
+ # MQTT alternative (vendor HiveMQ Cloud defaults; needs outbound TLS :8883):
+ # backend: mqtt
+ # broker: "your-broker.example.com" # optional — overrides the embedded default
+ # port: 8883
+ # user: "username"
+ # password: "secret"
\ No newline at end of file
diff --git a/diagnostics/benchmark_gentlystore_fps.py b/diagnostics/benchmark_gentlystore_fps.py
index 43187b9e..3e8188a7 100644
--- a/diagnostics/benchmark_gentlystore_fps.py
+++ b/diagnostics/benchmark_gentlystore_fps.py
@@ -22,23 +22,22 @@
import argparse
import shutil
import statistics
+
+# Add gently to path
+import sys
import tempfile
import time
from dataclasses import dataclass, field
from datetime import datetime
from pathlib import Path
-from typing import List, Optional
import numpy as np
-# Add gently to path
-import sys
GENTLY_ROOT = Path(__file__).resolve().parent.parent
if str(GENTLY_ROOT) not in sys.path:
sys.path.insert(0, str(GENTLY_ROOT))
-from gently.core.file_store import FileStore
-
+from gently.core.file_store import FileStore # noqa: E402
# ---------------------------------------------------------------------------
# Default parameters -- typical diSPIM volume dimensions
@@ -60,9 +59,9 @@ class BenchmarkResult:
approach: str
num_slices: int
volume_shape: tuple
- timings: List[float] = field(default_factory=list)
- sizes_mb: List[float] = field(default_factory=list)
- errors: List[str] = field(default_factory=list)
+ timings: list[float] = field(default_factory=list)
+ sizes_mb: list[float] = field(default_factory=list)
+ errors: list[str] = field(default_factory=list)
@property
def mean(self) -> float:
@@ -130,7 +129,7 @@ def generate_synthetic_volume(
z = np.linspace(0, 1, num_slices)[:, None, None]
y = np.linspace(0, 1, height)[None, :, None]
x = np.linspace(0, 1, width)[None, None, :]
- vol = (z * 0.3 + y * 0.3 + x * 0.4)
+ vol = z * 0.3 + y * 0.3 + x * 0.4
if np.issubdtype(dtype, np.integer):
info = np.iinfo(dtype)
vol = (vol * info.max).astype(dtype)
@@ -149,14 +148,18 @@ def generate_synthetic_volume(
cx = np.random.randint(width // 4, 3 * width // 4)
sz, sy, sx = 3, 15, 15
- z_idx = np.clip(np.arange(cz - sz*2, cz + sz*2), 0, num_slices - 1)
- y_idx = np.clip(np.arange(cy - sy*2, cy + sy*2), 0, height - 1)
- x_idx = np.clip(np.arange(cx - sx*2, cx + sx*2), 0, width - 1)
+ z_idx = np.clip(np.arange(cz - sz * 2, cz + sz * 2), 0, num_slices - 1)
+ y_idx = np.clip(np.arange(cy - sy * 2, cy + sy * 2), 0, height - 1)
+ x_idx = np.clip(np.arange(cx - sx * 2, cx + sx * 2), 0, width - 1)
- zz, yy, xx = np.meshgrid(z_idx, y_idx, x_idx, indexing='ij')
+ zz, yy, xx = np.meshgrid(z_idx, y_idx, x_idx, indexing="ij")
d2 = ((zz - cz) / sz) ** 2 + ((yy - cy) / sy) ** 2 + ((xx - cx) / sx) ** 2
blob = np.exp(-d2 / 2)
- vol[z_idx[0]:z_idx[-1]+1, y_idx[0]:y_idx[-1]+1, x_idx[0]:x_idx[-1]+1] += blob
+ vol[
+ z_idx[0] : z_idx[-1] + 1,
+ y_idx[0] : y_idx[-1] + 1,
+ x_idx[0] : x_idx[-1] + 1,
+ ] += blob
# Add background noise
vol += np.random.random(shape) * 0.1
@@ -178,7 +181,7 @@ def generate_synthetic_volume(
def benchmark_raw_tiff_write(
volume: np.ndarray,
output_dir: Path,
- compression: Optional[str] = "zlib",
+ compression: str | None = "zlib",
) -> tuple[float, float]:
"""
Benchmark raw tifffile write (no FileStore).
@@ -255,7 +258,7 @@ def benchmark_register_volume(
# Main benchmark sweep
# ---------------------------------------------------------------------------
def run_benchmark_sweep(
- slices_list: List[int],
+ slices_list: list[int],
width: int,
height: int,
num_repeats: int,
@@ -265,9 +268,9 @@ def run_benchmark_sweep(
run_put_volume: bool = True,
run_register: bool = True,
skip_projection: bool = False,
-) -> List[BenchmarkResult]:
+) -> list[BenchmarkResult]:
"""Run the full benchmark sweep."""
- results: List[BenchmarkResult] = []
+ results: list[BenchmarkResult] = []
# Create temporary directory for benchmark
temp_dir = Path(tempfile.mkdtemp(prefix="gently_benchmark_"))
@@ -291,10 +294,12 @@ def run_benchmark_sweep(
timepoint = 0
for config_idx, num_slices in enumerate(slices_list):
- print(f"\n{'='*60}")
- print(f"Config {config_idx + 1}/{total_configs}: "
- f"slices={num_slices}, shape=({num_slices}, {height}, {width})")
- print(f"{'='*60}")
+ print(f"\n{'=' * 60}")
+ print(
+ f"Config {config_idx + 1}/{total_configs}: "
+ f"slices={num_slices}, shape=({num_slices}, {height}, {width})"
+ )
+ print(f"{'=' * 60}")
volume_shape = (num_slices, height, width)
@@ -307,22 +312,22 @@ def run_benchmark_sweep(
# --- Raw TIFF write (baseline) ---
if run_raw:
res_raw = BenchmarkResult("raw_tiff_zlib", num_slices, volume_shape)
- print(f"\n[Raw TIFF zlib]")
+ print("\n[Raw TIFF zlib]")
# Warmup
for w in range(num_warmup):
- print(f" Warmup {w+1}/{num_warmup}...", end=" ", flush=True)
+ print(f" Warmup {w + 1}/{num_warmup}...", end=" ", flush=True)
dur, size = benchmark_raw_tiff_write(volume, raw_dir, "zlib")
print(f"{dur:.3f}s, {size:.1f} MB")
# Timed repeats
for r in range(num_repeats):
- print(f" Repeat {r+1}/{num_repeats}...", end=" ", flush=True)
+ print(f" Repeat {r + 1}/{num_repeats}...", end=" ", flush=True)
try:
dur, size = benchmark_raw_tiff_write(volume, raw_dir, "zlib")
res_raw.timings.append(dur)
res_raw.sizes_mb.append(size)
- print(f"{dur:.3f}s, {size:.1f} MB ({1/dur:.1f} vol/s)")
+ print(f"{dur:.3f}s, {size:.1f} MB ({1 / dur:.1f} vol/s)")
except Exception as e:
print(f"ERROR: {e}")
res_raw.errors.append(str(e))
@@ -333,26 +338,38 @@ def run_benchmark_sweep(
# --- put_volume (full pipeline) ---
if run_put_volume:
res_put = BenchmarkResult("put_volume", num_slices, volume_shape)
- print(f"\n[FileStore.put_volume]")
+ print("\n[FileStore.put_volume]")
# Warmup
for w in range(num_warmup):
embryo_id = f"embryo_{w % NUM_EMBRYOS}"
- print(f" Warmup {w+1}/{num_warmup} ({embryo_id})...", end=" ", flush=True)
- dur, size = benchmark_put_volume(store, session_id, embryo_id, timepoint, volume)
+ print(
+ f" Warmup {w + 1}/{num_warmup} ({embryo_id})...",
+ end=" ",
+ flush=True,
+ )
+ dur, size = benchmark_put_volume(
+ store, session_id, embryo_id, timepoint, volume
+ )
timepoint += 1
print(f"{dur:.3f}s, {size:.1f} MB")
# Timed repeats
for r in range(num_repeats):
embryo_id = f"embryo_{r % NUM_EMBRYOS}"
- print(f" Repeat {r+1}/{num_repeats} ({embryo_id})...", end=" ", flush=True)
+ print(
+ f" Repeat {r + 1}/{num_repeats} ({embryo_id})...",
+ end=" ",
+ flush=True,
+ )
try:
- dur, size = benchmark_put_volume(store, session_id, embryo_id, timepoint, volume)
+ dur, size = benchmark_put_volume(
+ store, session_id, embryo_id, timepoint, volume
+ )
timepoint += 1
res_put.timings.append(dur)
res_put.sizes_mb.append(size)
- print(f"{dur:.3f}s, {size:.1f} MB ({1/dur:.1f} vol/s)")
+ print(f"{dur:.3f}s, {size:.1f} MB ({1 / dur:.1f} vol/s)")
except Exception as e:
print(f"ERROR: {e}")
res_put.errors.append(str(e))
@@ -363,26 +380,38 @@ def run_benchmark_sweep(
# --- register_volume (zero-copy path) ---
if run_register:
res_reg = BenchmarkResult("register_volume", num_slices, volume_shape)
- print(f"\n[FileStore.register_volume]")
+ print("\n[FileStore.register_volume]")
# Warmup
for w in range(num_warmup):
embryo_id = f"embryo_{w % NUM_EMBRYOS}"
- print(f" Warmup {w+1}/{num_warmup} ({embryo_id})...", end=" ", flush=True)
- dur, size = benchmark_register_volume(store, session_id, embryo_id, timepoint, volume)
+ print(
+ f" Warmup {w + 1}/{num_warmup} ({embryo_id})...",
+ end=" ",
+ flush=True,
+ )
+ dur, size = benchmark_register_volume(
+ store, session_id, embryo_id, timepoint, volume
+ )
timepoint += 1
print(f"{dur:.3f}s, {size:.1f} MB")
# Timed repeats
for r in range(num_repeats):
embryo_id = f"embryo_{r % NUM_EMBRYOS}"
- print(f" Repeat {r+1}/{num_repeats} ({embryo_id})...", end=" ", flush=True)
+ print(
+ f" Repeat {r + 1}/{num_repeats} ({embryo_id})...",
+ end=" ",
+ flush=True,
+ )
try:
- dur, size = benchmark_register_volume(store, session_id, embryo_id, timepoint, volume)
+ dur, size = benchmark_register_volume(
+ store, session_id, embryo_id, timepoint, volume
+ )
timepoint += 1
res_reg.timings.append(dur)
res_reg.sizes_mb.append(size)
- print(f"{dur:.3f}s, {size:.1f} MB ({1/dur:.1f} vol/s)")
+ print(f"{dur:.3f}s, {size:.1f} MB ({1 / dur:.1f} vol/s)")
except Exception as e:
print(f"ERROR: {e}")
res_reg.errors.append(str(e))
@@ -410,20 +439,24 @@ def _print_single_result(res: BenchmarkResult):
if not res.timings:
print(f" -> {res.approach}: NO SUCCESSFUL RUNS ({len(res.errors)} errors)")
return
- print(f" -> {res.approach}: {res.vol_per_sec:.2f} vol/s, "
- f"mean={res.mean:.3f}s, std={res.std:.3f}s, "
- f"avg_size={res.avg_size_mb:.1f} MB")
+ print(
+ f" -> {res.approach}: {res.vol_per_sec:.2f} vol/s, "
+ f"mean={res.mean:.3f}s, std={res.std:.3f}s, "
+ f"avg_size={res.avg_size_mb:.1f} MB"
+ )
-def print_results_table(results: List[BenchmarkResult]):
+def print_results_table(results: list[BenchmarkResult]):
"""Print formatted ASCII results table."""
if not results:
print("No results to display.")
return
- header = (f"{'Slices':>6} | {'Approach':>18} | {'Vol/s':>7} | "
- f"{'Mean(s)':>7} | {'Std(s)':>6} | {'Min(s)':>6} | "
- f"{'Max(s)':>6} | {'Size(MB)':>8} | {'MB/s':>7}")
+ header = (
+ f"{'Slices':>6} | {'Approach':>18} | {'Vol/s':>7} | "
+ f"{'Mean(s)':>7} | {'Std(s)':>6} | {'Min(s)':>6} | "
+ f"{'Max(s)':>6} | {'Size(MB)':>8} | {'MB/s':>7}"
+ )
sep = "-" * len(header)
print(f"\n{sep}")
@@ -434,19 +467,23 @@ def print_results_table(results: List[BenchmarkResult]):
for r in results:
if r.timings:
- print(f"{r.num_slices:>6} | {r.approach:>18} | "
- f"{r.vol_per_sec:>7.2f} | {r.mean:>7.3f} | {r.std:>6.3f} | "
- f"{r.min_t:>6.3f} | {r.max_t:>6.3f} | {r.avg_size_mb:>8.1f} | "
- f"{r.mb_per_sec:>7.1f}")
+ print(
+ f"{r.num_slices:>6} | {r.approach:>18} | "
+ f"{r.vol_per_sec:>7.2f} | {r.mean:>7.3f} | {r.std:>6.3f} | "
+ f"{r.min_t:>6.3f} | {r.max_t:>6.3f} | {r.avg_size_mb:>8.1f} | "
+ f"{r.mb_per_sec:>7.1f}"
+ )
else:
- print(f"{r.num_slices:>6} | {r.approach:>18} | "
- f"{'FAIL':>7} | {'---':>7} | {'---':>6} | "
- f"{'---':>6} | {'---':>6} | {'---':>8} | {'---':>7}")
+ print(
+ f"{r.num_slices:>6} | {r.approach:>18} | "
+ f"{'FAIL':>7} | {'---':>7} | {'---':>6} | "
+ f"{'---':>6} | {'---':>6} | {'---':>8} | {'---':>7}"
+ )
print(sep)
-def print_overhead_analysis(results: List[BenchmarkResult]):
+def print_overhead_analysis(results: list[BenchmarkResult]):
"""Print overhead analysis comparing FileStore to raw TIFF."""
from collections import defaultdict
@@ -454,9 +491,11 @@ def print_overhead_analysis(results: List[BenchmarkResult]):
for r in results:
groups[r.num_slices][r.approach] = r
- has_data = [(k, v) for k, v in groups.items()
- if "raw_tiff_zlib" in v and
- ("put_volume" in v or "register_volume" in v)]
+ has_data = [
+ (k, v)
+ for k, v in groups.items()
+ if "raw_tiff_zlib" in v and ("put_volume" in v or "register_volume" in v)
+ ]
if not has_data:
return
@@ -487,7 +526,7 @@ def print_overhead_analysis(results: List[BenchmarkResult]):
print(sep)
-def save_results_csv(results: List[BenchmarkResult], path: Path, run_params: dict):
+def save_results_csv(results: list[BenchmarkResult], path: Path, run_params: dict):
"""Save results to CSV."""
import csv
import json
@@ -508,30 +547,44 @@ def save_results_csv(results: List[BenchmarkResult], path: Path, run_params: dic
writer.writerow([])
# Summary table
- writer.writerow([
- "slices", "approach", "vol_per_sec", "mean_s", "std_s",
- "min_s", "max_s", "avg_size_mb", "mb_per_sec", "num_repeats", "errors",
- ])
+ writer.writerow(
+ [
+ "slices",
+ "approach",
+ "vol_per_sec",
+ "mean_s",
+ "std_s",
+ "min_s",
+ "max_s",
+ "avg_size_mb",
+ "mb_per_sec",
+ "num_repeats",
+ "errors",
+ ]
+ )
for r in results:
- writer.writerow([
- r.num_slices, r.approach,
- f"{r.vol_per_sec:.4f}" if r.timings else "",
- f"{r.mean:.6f}" if r.timings else "",
- f"{r.std:.6f}" if r.timings else "",
- f"{r.min_t:.6f}" if r.timings else "",
- f"{r.max_t:.6f}" if r.timings else "",
- f"{r.avg_size_mb:.2f}" if r.sizes_mb else "",
- f"{r.mb_per_sec:.2f}" if r.timings else "",
- len(r.timings),
- "; ".join(r.errors) if r.errors else "",
- ])
+ writer.writerow(
+ [
+ r.num_slices,
+ r.approach,
+ f"{r.vol_per_sec:.4f}" if r.timings else "",
+ f"{r.mean:.6f}" if r.timings else "",
+ f"{r.std:.6f}" if r.timings else "",
+ f"{r.min_t:.6f}" if r.timings else "",
+ f"{r.max_t:.6f}" if r.timings else "",
+ f"{r.avg_size_mb:.2f}" if r.sizes_mb else "",
+ f"{r.mb_per_sec:.2f}" if r.timings else "",
+ len(r.timings),
+ "; ".join(r.errors) if r.errors else "",
+ ]
+ )
# Per-volume timings
writer.writerow([])
writer.writerow(["# Per-volume timings"])
writer.writerow(["slices", "approach", "repeat", "elapsed_s", "size_mb"])
for r in results:
- for i, (t, s) in enumerate(zip(r.timings, r.sizes_mb)):
+ for i, (t, s) in enumerate(zip(r.timings, r.sizes_mb, strict=False)):
writer.writerow([r.num_slices, r.approach, i + 1, f"{t:.6f}", f"{s:.2f}"])
print(f"\nResults saved to: {path}")
@@ -541,24 +594,45 @@ def save_results_csv(results: List[BenchmarkResult], path: Path, run_params: dic
# Main
# ---------------------------------------------------------------------------
def main():
- parser = argparse.ArgumentParser(
- description="Benchmark FileStore volume storage throughput"
+ parser = argparse.ArgumentParser(description="Benchmark FileStore volume storage throughput")
+ parser.add_argument(
+ "--slices",
+ type=int,
+ nargs="+",
+ default=DEFAULT_SLICES,
+ help=f"Slice counts to test (default: {DEFAULT_SLICES})",
+ )
+ parser.add_argument(
+ "--width",
+ type=int,
+ default=DEFAULT_WIDTH,
+ help=f"Image width (default: {DEFAULT_WIDTH})",
+ )
+ parser.add_argument(
+ "--height",
+ type=int,
+ default=DEFAULT_HEIGHT,
+ help=f"Image height (default: {DEFAULT_HEIGHT})",
+ )
+ parser.add_argument(
+ "--repeats",
+ type=int,
+ default=NUM_REPEATS,
+ help=f"Number of timed repeats (default: {NUM_REPEATS})",
+ )
+ parser.add_argument(
+ "--warmup",
+ type=int,
+ default=NUM_WARMUP,
+ help=f"Number of warmup runs (default: {NUM_WARMUP})",
+ )
+ parser.add_argument(
+ "--pattern",
+ choices=["noise", "gradient", "embryo"],
+ default="embryo",
+ help="Volume pattern: noise, gradient, or embryo (default: embryo)",
)
- parser.add_argument("--slices", type=int, nargs="+", default=DEFAULT_SLICES,
- help=f"Slice counts to test (default: {DEFAULT_SLICES})")
- parser.add_argument("--width", type=int, default=DEFAULT_WIDTH,
- help=f"Image width (default: {DEFAULT_WIDTH})")
- parser.add_argument("--height", type=int, default=DEFAULT_HEIGHT,
- help=f"Image height (default: {DEFAULT_HEIGHT})")
- parser.add_argument("--repeats", type=int, default=NUM_REPEATS,
- help=f"Number of timed repeats (default: {NUM_REPEATS})")
- parser.add_argument("--warmup", type=int, default=NUM_WARMUP,
- help=f"Number of warmup runs (default: {NUM_WARMUP})")
- parser.add_argument("--pattern", choices=["noise", "gradient", "embryo"],
- default="embryo",
- help="Volume pattern: noise, gradient, or embryo (default: embryo)")
- parser.add_argument("--save", action="store_true",
- help="Save results to CSV")
+ parser.add_argument("--save", action="store_true", help="Save results to CSV")
args = parser.parse_args()
print("FileStore Volume Storage Benchmark")
@@ -566,7 +640,7 @@ def main():
print(f" Dimensions: {args.width} x {args.height}")
print(f" Pattern: {args.pattern}")
print(f" Repeats: {args.repeats} (+ {args.warmup} warmup)")
- print(f" Approaches: raw_tiff_zlib / put_volume / register_volume")
+ print(" Approaches: raw_tiff_zlib / put_volume / register_volume")
results = run_benchmark_sweep(
slices_list=args.slices,
@@ -581,7 +655,10 @@ def main():
print_overhead_analysis(results)
if args.save:
- csv_path = Path("results") / f"benchmark_gentlystore_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+ csv_path = (
+ Path("results")
+ / f"benchmark_gentlystore_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+ )
run_params = {
"slices": args.slices,
"width": args.width,
diff --git a/diagnostics/benchmark_volume_fps.py b/diagnostics/benchmark_volume_fps.py
index ff7b2e38..381e3697 100644
--- a/diagnostics/benchmark_volume_fps.py
+++ b/diagnostics/benchmark_volume_fps.py
@@ -15,20 +15,21 @@
"""
import os
+import statistics
import sys
import time
-import statistics
-from pathlib import Path
from dataclasses import dataclass, field
-from typing import List, Optional, Tuple
from datetime import datetime
+from pathlib import Path
-import yaml
import numpy as np
import pymmcore
+import yaml
# Add dispim-control to path for ophyd device imports
-DISPIM_CONTROL_DIR = Path(__file__).resolve().parent.parent / "UsersdispimDocumentsGitHubdispim-control"
+DISPIM_CONTROL_DIR = (
+ Path(__file__).resolve().parent.parent / "UsersdispimDocumentsGitHubdispim-control"
+)
if str(DISPIM_CONTROL_DIR) not in sys.path:
sys.path.insert(0, str(DISPIM_CONTROL_DIR))
@@ -41,10 +42,10 @@
PIEZO_DEVICE = "PiezoStage:P:34"
# Default scan parameters (same as run_multi_embryo_volumes.py)
-DEFAULT_GALVO_AMPLITUDE = 0.5 # degrees
-DEFAULT_GALVO_CENTER = 0.0 # degrees
-DEFAULT_PIEZO_AMPLITUDE = 25.0 # um
-DEFAULT_PIEZO_CENTER = 50.0 # um
+DEFAULT_GALVO_AMPLITUDE = 0.5 # degrees
+DEFAULT_GALVO_CENTER = 0.0 # degrees
+DEFAULT_PIEZO_AMPLITUDE = 25.0 # um
+DEFAULT_PIEZO_CENTER = 50.0 # um
DEFAULT_LASER_CONFIG = "488 and 561"
DEFAULT_CAMERA_ROI = (128, 896, 2048, 512) # (x, y, width, height)
@@ -69,10 +70,30 @@
# Simulated embryo calibration profiles for round-robin reconfig test.
# Each entry represents a different embryo with distinct galvo/piezo settings.
EMBRYO_PROFILES = [
- {"galvo_amplitude": 0.50, "galvo_center": 0.00, "piezo_amplitude": 25.0, "piezo_center": 50.0},
- {"galvo_amplitude": 0.45, "galvo_center": 0.12, "piezo_amplitude": 22.5, "piezo_center": 55.0},
- {"galvo_amplitude": 0.55, "galvo_center": -0.08, "piezo_amplitude": 27.5, "piezo_center": 45.0},
- {"galvo_amplitude": 0.48, "galvo_center": 0.05, "piezo_amplitude": 24.0, "piezo_center": 52.0},
+ {
+ "galvo_amplitude": 0.50,
+ "galvo_center": 0.00,
+ "piezo_amplitude": 25.0,
+ "piezo_center": 50.0,
+ },
+ {
+ "galvo_amplitude": 0.45,
+ "galvo_center": 0.12,
+ "piezo_amplitude": 22.5,
+ "piezo_center": 55.0,
+ },
+ {
+ "galvo_amplitude": 0.55,
+ "galvo_center": -0.08,
+ "piezo_amplitude": 27.5,
+ "piezo_center": 45.0,
+ },
+ {
+ "galvo_amplitude": 0.48,
+ "galvo_center": 0.05,
+ "piezo_amplitude": 24.0,
+ "piezo_center": 52.0,
+ },
]
@@ -84,9 +105,9 @@ class BenchmarkResult:
approach: str
num_slices: int
exposure_ms: float
- timings: List[float] = field(default_factory=list)
- image_counts: List[int] = field(default_factory=list)
- errors: List[str] = field(default_factory=list)
+ timings: list[float] = field(default_factory=list)
+ image_counts: list[int] = field(default_factory=list)
+ errors: list[str] = field(default_factory=list)
@property
def mean(self) -> float:
@@ -116,13 +137,13 @@ def total_images(self) -> int:
# ---------------------------------------------------------------------------
# Config loading
# ---------------------------------------------------------------------------
-def load_config(path: str) -> Tuple[str, str]:
+def load_config(path: str) -> tuple[str, str]:
"""Read config.yml and return (mm_dir, config_file)."""
cfg_path = Path(path)
if not cfg_path.exists():
raise FileNotFoundError(f"Config file not found: {cfg_path}")
- with open(cfg_path, "r") as f:
+ with open(cfg_path) as f:
cfg = yaml.safe_load(f)
mm_dir = cfg["mmdirectory"]
@@ -236,8 +257,8 @@ def configure_hardware_raw(core: pymmcore.CMMCore, num_slices: int, exposure_ms:
def acquire_volume_raw(
core: pymmcore.CMMCore,
num_slices: int,
- save_dir: Optional[Path] = None,
-) -> Tuple[int, float]:
+ save_dir: Path | None = None,
+) -> tuple[int, float]:
"""
Trigger SPIM and collect images from the circular buffer.
@@ -329,10 +350,10 @@ def create_ophyd_devices(core: pymmcore.CMMCore):
which imports a theme module that may not be available).
"""
from dispim_control.devices import (
- DiSPIMScanner,
DiSPIMCamera,
- DiSPIMPiezo,
DiSPIMLaserControl,
+ DiSPIMPiezo,
+ DiSPIMScanner,
DiSPIMVolumeScanner,
)
@@ -356,8 +377,8 @@ def acquire_volume_ophyd(
volume_scanner,
num_slices: int,
exposure_ms: float,
- save_dir: Optional[Path] = None,
-) -> Tuple[int, float]:
+ save_dir: Path | None = None,
+) -> tuple[int, float]:
"""
Configure + trigger via ophyd VolumeScanner.
@@ -392,8 +413,9 @@ def acquire_volume_ophyd(
# ---------------------------------------------------------------------------
# Ophyd burst approach -- configure once, skip per-volume reset
# ---------------------------------------------------------------------------
-def configure_ophyd_burst(volume_scanner, num_slices: int, exposure_ms: float,
- core: pymmcore.CMMCore):
+def configure_ophyd_burst(
+ volume_scanner, num_slices: int, exposure_ms: float, core: pymmcore.CMMCore
+):
"""
Configure ophyd devices once for a burst of volumes.
@@ -417,8 +439,9 @@ def configure_ophyd_burst(volume_scanner, num_slices: int, exposure_ms: float,
time.sleep(0.1)
-def acquire_volume_ophyd_burst(volume_scanner, num_slices: int,
- core: pymmcore.CMMCore) -> Tuple[int, float]:
+def acquire_volume_ophyd_burst(
+ volume_scanner, num_slices: int, core: pymmcore.CMMCore
+) -> tuple[int, float]:
"""
Acquire one volume using ophyd devices but without per-volume reset.
@@ -494,8 +517,9 @@ def cleanup_ophyd_burst(volume_scanner, core: pymmcore.CMMCore):
# ---------------------------------------------------------------------------
# Burst reconfig approach -- reconfigure galvo/piezo per volume (round-robin)
# ---------------------------------------------------------------------------
-def configure_burst_reconfig(volume_scanner, num_slices: int, exposure_ms: float,
- core: pymmcore.CMMCore):
+def configure_burst_reconfig(
+ volume_scanner, num_slices: int, exposure_ms: float, core: pymmcore.CMMCore
+):
"""
One-time setup for burst_reconfig: camera, scanner X-axis & timing, lasers.
@@ -519,9 +543,11 @@ def configure_burst_reconfig(volume_scanner, num_slices: int, exposure_ms: float
def acquire_volume_burst_reconfig(
- volume_scanner, num_slices: int, profile_idx: int,
+ volume_scanner,
+ num_slices: int,
+ profile_idx: int,
core: pymmcore.CMMCore,
-) -> Tuple[int, float]:
+) -> tuple[int, float]:
"""
Acquire one volume after reconfiguring galvo/piezo for a specific embryo.
@@ -535,7 +561,6 @@ def acquire_volume_burst_reconfig(
profile = EMBRYO_PROFILES[profile_idx % len(EMBRYO_PROFILES)]
camera_name = volume_scanner.camera.name
scanner = volume_scanner.scanner
- piezo = volume_scanner.piezo
core.clearCircularBuffer()
@@ -548,16 +573,12 @@ def acquire_volume_burst_reconfig(
t0 = time.perf_counter()
# Reconfigure galvo Y-axis for this embryo
- core.setProperty(GALVO_DEVICE, "SingleAxisYAmplitude(deg)",
- float(profile["galvo_amplitude"]))
- core.setProperty(GALVO_DEVICE, "SingleAxisYOffset(deg)",
- float(profile["galvo_center"]))
+ core.setProperty(GALVO_DEVICE, "SingleAxisYAmplitude(deg)", float(profile["galvo_amplitude"]))
+ core.setProperty(GALVO_DEVICE, "SingleAxisYOffset(deg)", float(profile["galvo_center"]))
# Reconfigure piezo for this embryo
- core.setProperty(PIEZO_DEVICE, "SingleAxisAmplitude(um)",
- float(profile["piezo_amplitude"]))
- core.setProperty(PIEZO_DEVICE, "SingleAxisOffset(um)",
- float(profile["piezo_center"]))
+ core.setProperty(PIEZO_DEVICE, "SingleAxisAmplitude(um)", float(profile["piezo_amplitude"]))
+ core.setProperty(PIEZO_DEVICE, "SingleAxisOffset(um)", float(profile["piezo_center"]))
core.setProperty(PIEZO_DEVICE, "SPIMState", "Armed")
time.sleep(0.3)
@@ -595,9 +616,11 @@ def acquire_volume_burst_reconfig(
# Burst reconfig with waitForDevice -- replaces time.sleep() with MMCore API
# ---------------------------------------------------------------------------
def acquire_volume_burst_reconfig_wfd(
- volume_scanner, num_slices: int, profile_idx: int,
+ volume_scanner,
+ num_slices: int,
+ profile_idx: int,
core: pymmcore.CMMCore,
-) -> Tuple[int, float]:
+) -> tuple[int, float]:
"""
Same as burst_reconfig but uses core.waitForDevice() instead of
time.sleep() to wait for hardware readiness.
@@ -608,7 +631,6 @@ def acquire_volume_burst_reconfig_wfd(
"""
profile = EMBRYO_PROFILES[profile_idx % len(EMBRYO_PROFILES)]
camera_name = volume_scanner.camera.name
- scanner = volume_scanner.scanner
core.clearCircularBuffer()
@@ -621,17 +643,13 @@ def acquire_volume_burst_reconfig_wfd(
t0 = time.perf_counter()
# Reconfigure galvo Y-axis for this embryo
- core.setProperty(GALVO_DEVICE, "SingleAxisYAmplitude(deg)",
- float(profile["galvo_amplitude"]))
- core.setProperty(GALVO_DEVICE, "SingleAxisYOffset(deg)",
- float(profile["galvo_center"]))
+ core.setProperty(GALVO_DEVICE, "SingleAxisYAmplitude(deg)", float(profile["galvo_amplitude"]))
+ core.setProperty(GALVO_DEVICE, "SingleAxisYOffset(deg)", float(profile["galvo_center"]))
core.waitForDevice(GALVO_DEVICE)
# Reconfigure piezo for this embryo
- core.setProperty(PIEZO_DEVICE, "SingleAxisAmplitude(um)",
- float(profile["piezo_amplitude"]))
- core.setProperty(PIEZO_DEVICE, "SingleAxisOffset(um)",
- float(profile["piezo_center"]))
+ core.setProperty(PIEZO_DEVICE, "SingleAxisAmplitude(um)", float(profile["piezo_amplitude"]))
+ core.setProperty(PIEZO_DEVICE, "SingleAxisOffset(um)", float(profile["piezo_center"]))
core.setProperty(PIEZO_DEVICE, "SPIMState", "Armed")
core.waitForDevice(PIEZO_DEVICE)
@@ -686,16 +704,16 @@ def _save_volume(volume: np.ndarray, save_dir: Path, approach: str, num_slices:
# ---------------------------------------------------------------------------
def run_benchmark_sweep(
core: pymmcore.CMMCore,
- slices_list: List[int],
- exposures_list: List[float],
+ slices_list: list[int],
+ exposures_list: list[float],
num_repeats: int,
num_warmup: int,
run_raw: bool,
run_ophyd: bool,
- save_dir: Optional[Path] = None,
-) -> List[BenchmarkResult]:
+ save_dir: Path | None = None,
+) -> list[BenchmarkResult]:
"""Run the full parameter sweep and return results."""
- results: List[BenchmarkResult] = []
+ results: list[BenchmarkResult] = []
volume_scanner = None
if run_ophyd:
@@ -709,15 +727,17 @@ def run_benchmark_sweep(
for num_slices in slices_list:
for exposure_ms in exposures_list:
config_idx += 1
- print(f"\n{'='*60}")
- print(f"Config {config_idx}/{total_configs}: "
- f"slices={num_slices}, exposure={exposure_ms}ms")
- print(f"{'='*60}")
+ print(f"\n{'=' * 60}")
+ print(
+ f"Config {config_idx}/{total_configs}: "
+ f"slices={num_slices}, exposure={exposure_ms}ms"
+ )
+ print(f"{'=' * 60}")
# --- Raw MMCore ---
if run_raw:
res_raw = BenchmarkResult("raw", num_slices, exposure_ms)
- print(f"\n[Raw MMCore] Configuring hardware...")
+ print("\n[Raw MMCore] Configuring hardware...")
try:
configure_hardware_raw(core, num_slices, exposure_ms)
except Exception as e:
@@ -728,7 +748,7 @@ def run_benchmark_sweep(
# Warm-up
for w in range(num_warmup):
- print(f" Warm-up {w+1}/{num_warmup}...", end=" ", flush=True)
+ print(f" Warm-up {w + 1}/{num_warmup}...", end=" ", flush=True)
try:
cnt, dur = acquire_volume_raw(core, num_slices)
print(f"{cnt} imgs, {dur:.3f}s")
@@ -737,15 +757,15 @@ def run_benchmark_sweep(
# Timed repeats
for r in range(num_repeats):
- print(f" Repeat {r+1}/{num_repeats}...", end=" ", flush=True)
+ print(f" Repeat {r + 1}/{num_repeats}...", end=" ", flush=True)
try:
cnt, dur = acquire_volume_raw(core, num_slices, save_dir=save_dir)
res_raw.timings.append(dur)
res_raw.image_counts.append(cnt)
- print(f"{cnt} imgs, {dur:.3f}s ({1.0/dur:.1f} vol/s)")
+ print(f"{cnt} imgs, {dur:.3f}s ({1.0 / dur:.1f} vol/s)")
except Exception as e:
print(f"ERROR: {e}")
- res_raw.errors.append(f"repeat {r+1}: {e}")
+ res_raw.errors.append(f"repeat {r + 1}: {e}")
# Cleanup after raw batch (lasers off)
cleanup_raw(core)
@@ -758,27 +778,34 @@ def run_benchmark_sweep(
# Warm-up
for w in range(num_warmup):
- print(f" [Ophyd] Warm-up {w+1}/{num_warmup}...", end=" ", flush=True)
+ print(
+ f" [Ophyd] Warm-up {w + 1}/{num_warmup}...",
+ end=" ",
+ flush=True,
+ )
try:
- cnt, dur = acquire_volume_ophyd(
- volume_scanner, num_slices, exposure_ms)
+ cnt, dur = acquire_volume_ophyd(volume_scanner, num_slices, exposure_ms)
print(f"{cnt} imgs, {dur:.3f}s")
except Exception as e:
print(f"ERROR: {e}")
# Timed repeats
for r in range(num_repeats):
- print(f" [Ophyd] Repeat {r+1}/{num_repeats}...", end=" ", flush=True)
+ print(
+ f" [Ophyd] Repeat {r + 1}/{num_repeats}...",
+ end=" ",
+ flush=True,
+ )
try:
cnt, dur = acquire_volume_ophyd(
- volume_scanner, num_slices, exposure_ms,
- save_dir=save_dir)
+ volume_scanner, num_slices, exposure_ms, save_dir=save_dir
+ )
res_ophyd.timings.append(dur)
res_ophyd.image_counts.append(cnt)
- print(f"{cnt} imgs, {dur:.3f}s ({1.0/dur:.1f} vol/s)")
+ print(f"{cnt} imgs, {dur:.3f}s ({1.0 / dur:.1f} vol/s)")
except Exception as e:
print(f"ERROR: {e}")
- res_ophyd.errors.append(f"repeat {r+1}: {e}")
+ res_ophyd.errors.append(f"repeat {r + 1}: {e}")
results.append(res_ophyd)
_print_single_result(res_ophyd)
@@ -786,10 +813,9 @@ def run_benchmark_sweep(
# --- Ophyd burst (configure once, no per-volume reset) ---
if run_ophyd and volume_scanner is not None:
res_burst = BenchmarkResult("ophyd_burst", num_slices, exposure_ms)
- print(f"\n[Ophyd Burst] Configuring once...")
+ print("\n[Ophyd Burst] Configuring once...")
try:
- configure_ophyd_burst(volume_scanner, num_slices,
- exposure_ms, core)
+ configure_ophyd_burst(volume_scanner, num_slices, exposure_ms, core)
except Exception as e:
print(f" ERROR configuring ophyd burst: {e}")
res_burst.errors.append(f"configure: {e}")
@@ -798,26 +824,24 @@ def run_benchmark_sweep(
# Warm-up
for w in range(num_warmup):
- print(f" Warm-up {w+1}/{num_warmup}...", end=" ", flush=True)
+ print(f" Warm-up {w + 1}/{num_warmup}...", end=" ", flush=True)
try:
- cnt, dur = acquire_volume_ophyd_burst(
- volume_scanner, num_slices, core)
+ cnt, dur = acquire_volume_ophyd_burst(volume_scanner, num_slices, core)
print(f"{cnt} imgs, {dur:.3f}s")
except Exception as e:
print(f"ERROR: {e}")
# Timed repeats
for r in range(num_repeats):
- print(f" Repeat {r+1}/{num_repeats}...", end=" ", flush=True)
+ print(f" Repeat {r + 1}/{num_repeats}...", end=" ", flush=True)
try:
- cnt, dur = acquire_volume_ophyd_burst(
- volume_scanner, num_slices, core)
+ cnt, dur = acquire_volume_ophyd_burst(volume_scanner, num_slices, core)
res_burst.timings.append(dur)
res_burst.image_counts.append(cnt)
- print(f"{cnt} imgs, {dur:.3f}s ({1.0/dur:.1f} vol/s)")
+ print(f"{cnt} imgs, {dur:.3f}s ({1.0 / dur:.1f} vol/s)")
except Exception as e:
print(f"ERROR: {e}")
- res_burst.errors.append(f"repeat {r+1}: {e}")
+ res_burst.errors.append(f"repeat {r + 1}: {e}")
cleanup_ophyd_burst(volume_scanner, core)
results.append(res_burst)
@@ -826,11 +850,12 @@ def run_benchmark_sweep(
# --- Burst reconfig (round-robin galvo/piezo per volume) ---
if run_ophyd and volume_scanner is not None:
res_reconfig = BenchmarkResult("burst_reconfig", num_slices, exposure_ms)
- print(f"\n[Burst Reconfig] Configuring once, "
- f"cycling {len(EMBRYO_PROFILES)} embryo profiles...")
+ print(
+ f"\n[Burst Reconfig] Configuring once, "
+ f"cycling {len(EMBRYO_PROFILES)} embryo profiles..."
+ )
try:
- configure_burst_reconfig(volume_scanner, num_slices,
- exposure_ms, core)
+ configure_burst_reconfig(volume_scanner, num_slices, exposure_ms, core)
except Exception as e:
print(f" ERROR configuring burst reconfig: {e}")
res_reconfig.errors.append(f"configure: {e}")
@@ -839,12 +864,15 @@ def run_benchmark_sweep(
# Warm-up (cycle through profiles)
for w in range(num_warmup):
- print(f" Warm-up {w+1}/{num_warmup} "
- f"(profile {w % len(EMBRYO_PROFILES)})...",
- end=" ", flush=True)
+ print(
+ f" Warm-up {w + 1}/{num_warmup} (profile {w % len(EMBRYO_PROFILES)})...",
+ end=" ",
+ flush=True,
+ )
try:
cnt, dur = acquire_volume_burst_reconfig(
- volume_scanner, num_slices, w, core)
+ volume_scanner, num_slices, w, core
+ )
print(f"{cnt} imgs, {dur:.3f}s")
except Exception as e:
print(f"ERROR: {e}")
@@ -852,17 +880,21 @@ def run_benchmark_sweep(
# Timed repeats (cycle through profiles)
for r in range(num_repeats):
pidx = r % len(EMBRYO_PROFILES)
- print(f" Repeat {r+1}/{num_repeats} "
- f"(profile {pidx})...", end=" ", flush=True)
+ print(
+ f" Repeat {r + 1}/{num_repeats} (profile {pidx})...",
+ end=" ",
+ flush=True,
+ )
try:
cnt, dur = acquire_volume_burst_reconfig(
- volume_scanner, num_slices, r, core)
+ volume_scanner, num_slices, r, core
+ )
res_reconfig.timings.append(dur)
res_reconfig.image_counts.append(cnt)
- print(f"{cnt} imgs, {dur:.3f}s ({1.0/dur:.1f} vol/s)")
+ print(f"{cnt} imgs, {dur:.3f}s ({1.0 / dur:.1f} vol/s)")
except Exception as e:
print(f"ERROR: {e}")
- res_reconfig.errors.append(f"repeat {r+1}: {e}")
+ res_reconfig.errors.append(f"repeat {r + 1}: {e}")
cleanup_ophyd_burst(volume_scanner, core)
results.append(res_reconfig)
@@ -871,11 +903,12 @@ def run_benchmark_sweep(
# --- Burst reconfig with waitForDevice (no time.sleep) ---
if run_ophyd and volume_scanner is not None:
res_wfd = BenchmarkResult("reconfig_wfd", num_slices, exposure_ms)
- print(f"\n[Reconfig WFD] Configuring once, "
- f"using waitForDevice() instead of time.sleep()...")
+ print(
+ "\n[Reconfig WFD] Configuring once, "
+ "using waitForDevice() instead of time.sleep()..."
+ )
try:
- configure_burst_reconfig(volume_scanner, num_slices,
- exposure_ms, core)
+ configure_burst_reconfig(volume_scanner, num_slices, exposure_ms, core)
except Exception as e:
print(f" ERROR configuring reconfig_wfd: {e}")
res_wfd.errors.append(f"configure: {e}")
@@ -884,12 +917,15 @@ def run_benchmark_sweep(
# Warm-up (cycle through profiles)
for w in range(num_warmup):
- print(f" Warm-up {w+1}/{num_warmup} "
- f"(profile {w % len(EMBRYO_PROFILES)})...",
- end=" ", flush=True)
+ print(
+ f" Warm-up {w + 1}/{num_warmup} (profile {w % len(EMBRYO_PROFILES)})...",
+ end=" ",
+ flush=True,
+ )
try:
cnt, dur = acquire_volume_burst_reconfig_wfd(
- volume_scanner, num_slices, w, core)
+ volume_scanner, num_slices, w, core
+ )
print(f"{cnt} imgs, {dur:.3f}s")
except Exception as e:
print(f"ERROR: {e}")
@@ -897,17 +933,21 @@ def run_benchmark_sweep(
# Timed repeats (cycle through profiles)
for r in range(num_repeats):
pidx = r % len(EMBRYO_PROFILES)
- print(f" Repeat {r+1}/{num_repeats} "
- f"(profile {pidx})...", end=" ", flush=True)
+ print(
+ f" Repeat {r + 1}/{num_repeats} (profile {pidx})...",
+ end=" ",
+ flush=True,
+ )
try:
cnt, dur = acquire_volume_burst_reconfig_wfd(
- volume_scanner, num_slices, r, core)
+ volume_scanner, num_slices, r, core
+ )
res_wfd.timings.append(dur)
res_wfd.image_counts.append(cnt)
- print(f"{cnt} imgs, {dur:.3f}s ({1.0/dur:.1f} vol/s)")
+ print(f"{cnt} imgs, {dur:.3f}s ({1.0 / dur:.1f} vol/s)")
except Exception as e:
print(f"ERROR: {e}")
- res_wfd.errors.append(f"repeat {r+1}: {e}")
+ res_wfd.errors.append(f"repeat {r + 1}: {e}")
cleanup_ophyd_burst(volume_scanner, core)
results.append(res_wfd)
@@ -922,22 +962,25 @@ def run_benchmark_sweep(
def _print_single_result(res: BenchmarkResult):
"""Print a single intermediate result."""
if not res.timings:
- print(f" -> {res.approach}: NO SUCCESSFUL RUNS "
- f"({len(res.errors)} errors)")
+ print(f" -> {res.approach}: NO SUCCESSFUL RUNS ({len(res.errors)} errors)")
return
- print(f" -> {res.approach}: {res.vol_per_sec:.2f} vol/s, "
- f"mean={res.mean:.3f}s, std={res.std:.3f}s")
+ print(
+ f" -> {res.approach}: {res.vol_per_sec:.2f} vol/s, "
+ f"mean={res.mean:.3f}s, std={res.std:.3f}s"
+ )
-def print_results_table(results: List[BenchmarkResult]):
+def print_results_table(results: list[BenchmarkResult]):
"""Print formatted ASCII results table."""
if not results:
print("No results to display.")
return
- header = (f"{'Slices':>6} | {'Exp(ms)':>7} | {'Approach':>14} | "
- f"{'Vol/s':>7} | {'Mean(s)':>7} | {'Std(s)':>7} | "
- f"{'Min(s)':>7} | {'Max(s)':>7} | {'Images':>6}")
+ header = (
+ f"{'Slices':>6} | {'Exp(ms)':>7} | {'Approach':>14} | "
+ f"{'Vol/s':>7} | {'Mean(s)':>7} | {'Std(s)':>7} | "
+ f"{'Min(s)':>7} | {'Max(s)':>7} | {'Images':>6}"
+ )
sep = "-" * len(header)
print(f"\n{sep}")
@@ -948,35 +991,43 @@ def print_results_table(results: List[BenchmarkResult]):
for r in results:
if r.timings:
- print(f"{r.num_slices:>6} | {r.exposure_ms:>7.1f} | {r.approach:>14} | "
- f"{r.vol_per_sec:>7.2f} | {r.mean:>7.3f} | {r.std:>7.3f} | "
- f"{r.min_t:>7.3f} | {r.max_t:>7.3f} | {r.total_images:>6}")
+ print(
+ f"{r.num_slices:>6} | {r.exposure_ms:>7.1f} | {r.approach:>14} | "
+ f"{r.vol_per_sec:>7.2f} | {r.mean:>7.3f} | {r.std:>7.3f} | "
+ f"{r.min_t:>7.3f} | {r.max_t:>7.3f} | {r.total_images:>6}"
+ )
else:
- print(f"{r.num_slices:>6} | {r.exposure_ms:>7.1f} | {r.approach:>14} | "
- f"{'FAIL':>7} | {'---':>7} | {'---':>7} | "
- f"{'---':>7} | {'---':>7} | {'---':>6}")
+ print(
+ f"{r.num_slices:>6} | {r.exposure_ms:>7.1f} | {r.approach:>14} | "
+ f"{'FAIL':>7} | {'---':>7} | {'---':>7} | "
+ f"{'---':>7} | {'---':>7} | {'---':>6}"
+ )
print(sep)
-def print_summary(results: List[BenchmarkResult]):
+def print_summary(results: list[BenchmarkResult]):
"""Print overhead analysis comparing ophyd and ophyd_burst vs raw."""
from collections import defaultdict
+
groups = defaultdict(dict)
for r in results:
groups[(r.num_slices, r.exposure_ms)][r.approach] = r
# Need at least raw + one ophyd variant
- has_data = [(k, v) for k, v in groups.items()
- if "raw" in v and ("ophyd" in v or "ophyd_burst" in v
- or "burst_reconfig" in v
- or "reconfig_wfd" in v)]
+ has_data = [
+ (k, v)
+ for k, v in groups.items()
+ if "raw" in v
+ and ("ophyd" in v or "ophyd_burst" in v or "burst_reconfig" in v or "reconfig_wfd" in v)
+ ]
if not has_data:
return
print()
- header = (f"{'Slices':>6} | {'Exp(ms)':>7} | "
- f"{'Approach':>14} | {'vs Raw(ms)':>10} | {'vs Raw(%)':>9}")
+ header = (
+ f"{'Slices':>6} | {'Exp(ms)':>7} | {'Approach':>14} | {'vs Raw(ms)':>10} | {'vs Raw(%)':>9}"
+ )
sep = "-" * len(header)
print(sep)
@@ -995,14 +1046,15 @@ def print_summary(results: List[BenchmarkResult]):
other_mean = approaches[label].mean
overhead_ms = (other_mean - raw_mean) * 1000.0
overhead_pct = ((other_mean - raw_mean) / raw_mean) * 100.0
- print(f"{ns:>6} | {exp:>7.1f} | {label:>14} | "
- f"{overhead_ms:>+10.1f} | {overhead_pct:>+8.1f}%")
+ print(
+ f"{ns:>6} | {exp:>7.1f} | {label:>14} | "
+ f"{overhead_ms:>+10.1f} | {overhead_pct:>+8.1f}%"
+ )
print(sep)
-def save_results_csv(results: List[BenchmarkResult], path: Path,
- run_params: dict):
+def save_results_csv(results: list[BenchmarkResult], path: Path, run_params: dict):
"""Write benchmark results to a CSV file with full metadata."""
import csv
import json
@@ -1031,37 +1083,63 @@ def save_results_csv(results: List[BenchmarkResult], path: Path,
writer.writerow([])
# --- Summary table ---
- writer.writerow([
- "slices", "exposure_ms", "approach",
- "vol_per_sec", "mean_s", "std_s", "min_s", "max_s",
- "total_images", "num_repeats", "errors",
- ])
+ writer.writerow(
+ [
+ "slices",
+ "exposure_ms",
+ "approach",
+ "vol_per_sec",
+ "mean_s",
+ "std_s",
+ "min_s",
+ "max_s",
+ "total_images",
+ "num_repeats",
+ "errors",
+ ]
+ )
for r in results:
- writer.writerow([
- r.num_slices, r.exposure_ms, r.approach,
- f"{r.vol_per_sec:.4f}" if r.timings else "",
- f"{r.mean:.6f}" if r.timings else "",
- f"{r.std:.6f}" if r.timings else "",
- f"{r.min_t:.6f}" if r.timings else "",
- f"{r.max_t:.6f}" if r.timings else "",
- r.total_images,
- len(r.timings),
- "; ".join(r.errors) if r.errors else "",
- ])
+ writer.writerow(
+ [
+ r.num_slices,
+ r.exposure_ms,
+ r.approach,
+ f"{r.vol_per_sec:.4f}" if r.timings else "",
+ f"{r.mean:.6f}" if r.timings else "",
+ f"{r.std:.6f}" if r.timings else "",
+ f"{r.min_t:.6f}" if r.timings else "",
+ f"{r.max_t:.6f}" if r.timings else "",
+ r.total_images,
+ len(r.timings),
+ "; ".join(r.errors) if r.errors else "",
+ ]
+ )
# --- Per-volume raw timings ---
writer.writerow([])
writer.writerow(["# Per-volume timings (seconds)"])
- writer.writerow([
- "slices", "exposure_ms", "approach",
- "repeat", "elapsed_s", "image_count",
- ])
+ writer.writerow(
+ [
+ "slices",
+ "exposure_ms",
+ "approach",
+ "repeat",
+ "elapsed_s",
+ "image_count",
+ ]
+ )
for r in results:
- for i, (t, cnt) in enumerate(zip(r.timings, r.image_counts)):
- writer.writerow([
- r.num_slices, r.exposure_ms, r.approach,
- i + 1, f"{t:.6f}", cnt,
- ])
+ for i, (t, cnt) in enumerate(zip(r.timings, r.image_counts, strict=False)):
+ writer.writerow(
+ [
+ r.num_slices,
+ r.exposure_ms,
+ r.approach,
+ i + 1,
+ f"{t:.6f}",
+ cnt,
+ ]
+ )
print(f"\nResults saved to: {path}")
@@ -1076,8 +1154,10 @@ def main():
print(f" Slices series: {SLICES_SERIES}")
print(f" Exposure: {EXPOSURE_MS} ms")
print(f" Repeats: {NUM_REPEATS} (+ {NUM_WARMUP} warmup)")
- print(f" Approaches: raw / ophyd / ophyd_burst / burst_reconfig / reconfig_wfd")
- print(f" Embryo profiles: {len(EMBRYO_PROFILES)} (for burst_reconfig & reconfig_wfd round-robin)")
+ print(" Approaches: raw / ophyd / ophyd_burst / burst_reconfig / reconfig_wfd")
+ print(
+ f" Embryo profiles: {len(EMBRYO_PROFILES)} (for burst_reconfig & reconfig_wfd round-robin)"
+ )
# Load config and initialize
mm_dir, config_file = load_config(config_path)
@@ -1099,7 +1179,9 @@ def main():
print_summary(results)
# Save CSV
- csv_path = Path("results") / f"benchmark_volume_fps_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+ csv_path = (
+ Path("results") / f"benchmark_volume_fps_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+ )
run_params = {
"slices": SLICES_SERIES,
"exposure_ms": EXPOSURE_MS,
diff --git a/diagnostics/measure_centering_error.py b/diagnostics/measure_centering_error.py
index 0f159c79..c8c22ef4 100644
--- a/diagnostics/measure_centering_error.py
+++ b/diagnostics/measure_centering_error.py
@@ -6,8 +6,9 @@
"""
import json
-import numpy as np
+
import matplotlib.pyplot as plt
+import numpy as np
from PIL import Image
# Load the image after moving to embryo
@@ -21,6 +22,7 @@
# Store clicked position
clicked_pos = [None, None]
+
def on_click(event):
if event.xdata is not None and event.ydata is not None:
clicked_pos[0] = event.xdata
@@ -47,48 +49,56 @@ def on_click(event):
"error_y_direction": "BELOW" if error_y > 0 else "ABOVE",
"error_x_um": float(error_x_um),
"error_y_um": float(error_y_um),
- "um_per_pixel": um_per_pixel
+ "um_per_pixel": um_per_pixel,
}
# Write to file
- with open(OUTPUT_FILE, 'w') as f:
+ with open(OUTPUT_FILE, "w") as f:
json.dump(result, f, indent=2)
- print(f"\n{'='*50}")
+ print(f"\n{'=' * 50}")
print(f"CLICKED POSITION: ({clicked_pos[0]:.1f}, {clicked_pos[1]:.1f})")
print(f"CENTER POSITION: ({CENTER_X}, {CENTER_Y})")
- print(f"{'='*50}")
+ print(f"{'=' * 50}")
print(f"ERROR X: {error_x:+.1f} pixels ({result['error_x_direction']} of center)")
print(f"ERROR Y: {error_y:+.1f} pixels ({result['error_y_direction']} center)")
- print(f"{'='*50}")
+ print(f"{'=' * 50}")
print(f"ERROR X: {error_x_um:+.1f} um")
print(f"ERROR Y: {error_y_um:+.1f} um")
- print(f"{'='*50}")
+ print(f"{'=' * 50}")
print(f"\nSaved to: {OUTPUT_FILE}")
# Update the plot with clicked marker
- ax.plot(clicked_pos[0], clicked_pos[1], 'go', markersize=15, markeredgewidth=3,
- markerfacecolor='none', label='Actual embryo position')
+ ax.plot(
+ clicked_pos[0],
+ clicked_pos[1],
+ "go",
+ markersize=15,
+ markeredgewidth=3,
+ markerfacecolor="none",
+ label="Actual embryo position",
+ )
ax.legend()
fig.canvas.draw()
+
# Load image
img = np.array(Image.open(IMAGE_PATH))
# Create figure
fig, ax = plt.subplots(figsize=(12, 12))
-ax.imshow(img, cmap='gray')
+ax.imshow(img, cmap="gray")
# Draw crosshairs at center
-ax.axhline(CENTER_Y, color='red', linestyle='--', alpha=0.7, linewidth=1, label='Center')
-ax.axvline(CENTER_X, color='red', linestyle='--', alpha=0.7, linewidth=1)
-ax.plot(CENTER_X, CENTER_Y, 'r+', markersize=30, markeredgewidth=2)
+ax.axhline(CENTER_Y, color="red", linestyle="--", alpha=0.7, linewidth=1, label="Center")
+ax.axvline(CENTER_X, color="red", linestyle="--", alpha=0.7, linewidth=1)
+ax.plot(CENTER_X, CENTER_Y, "r+", markersize=30, markeredgewidth=2)
ax.set_title("Click on where EMBRYO 3 actually is\n(Red crosshairs = center where it SHOULD be)")
ax.legend()
# Connect click event
-fig.canvas.mpl_connect('button_press_event', on_click)
+fig.canvas.mpl_connect("button_press_event", on_click)
print("\nClick on where embryo_3 actually appears in the image.")
print("The red crosshairs show the center (where it should be).\n")
diff --git a/diagnostics/plot_benchmark_results.py b/diagnostics/plot_benchmark_results.py
index 2eba25de..c3b5cdf1 100644
--- a/diagnostics/plot_benchmark_results.py
+++ b/diagnostics/plot_benchmark_results.py
@@ -10,14 +10,13 @@
python diagnostics/plot_benchmark_results.py results/benchmark_volume_fps_20260127_123405.csv
"""
-import sys
import csv
-from pathlib import Path
+import sys
from collections import defaultdict
+from pathlib import Path
-import numpy as np
import matplotlib.pyplot as plt
-import matplotlib.ticker as ticker
+import numpy as np
# ---------------------------------------------------------------------------
@@ -29,7 +28,7 @@ def parse_benchmark_csv(path: Path) -> dict:
summary = []
per_volume = []
- with open(path, "r") as f:
+ with open(path) as f:
reader = csv.reader(f)
section = "metadata"
@@ -55,27 +54,31 @@ def parse_benchmark_csv(path: Path) -> dict:
continue
if section == "summary":
- summary.append({
- "slices": int(row[0]),
- "exposure_ms": float(row[1]),
- "approach": row[2],
- "vol_per_sec": float(row[3]) if row[3] else None,
- "mean_s": float(row[4]) if row[4] else None,
- "std_s": float(row[5]) if row[5] else None,
- "min_s": float(row[6]) if row[6] else None,
- "max_s": float(row[7]) if row[7] else None,
- "total_images": int(row[8]) if row[8] else 0,
- "num_repeats": int(row[9]) if row[9] else 0,
- })
+ summary.append(
+ {
+ "slices": int(row[0]),
+ "exposure_ms": float(row[1]),
+ "approach": row[2],
+ "vol_per_sec": float(row[3]) if row[3] else None,
+ "mean_s": float(row[4]) if row[4] else None,
+ "std_s": float(row[5]) if row[5] else None,
+ "min_s": float(row[6]) if row[6] else None,
+ "max_s": float(row[7]) if row[7] else None,
+ "total_images": int(row[8]) if row[8] else 0,
+ "num_repeats": int(row[9]) if row[9] else 0,
+ }
+ )
elif section == "per_volume":
- per_volume.append({
- "slices": int(row[0]),
- "exposure_ms": float(row[1]),
- "approach": row[2],
- "repeat": int(row[3]),
- "elapsed_s": float(row[4]),
- "image_count": int(row[5]),
- })
+ per_volume.append(
+ {
+ "slices": int(row[0]),
+ "exposure_ms": float(row[1]),
+ "approach": row[2],
+ "repeat": int(row[3]),
+ "elapsed_s": float(row[4]),
+ "image_count": int(row[5]),
+ }
+ )
return {"metadata": metadata, "summary": summary, "per_volume": per_volume}
@@ -102,18 +105,18 @@ def plot_throughput(data: dict, output_dir: Path):
# Colors and labels
color_map = {
- "raw": "#2563eb",
- "ophyd": "#dc2626",
- "ophyd_burst": "#16a34a",
- "burst_reconfig": "#ea580c",
- "reconfig_wfd": "#7c3aed",
+ "raw": "#2563eb",
+ "ophyd": "#dc2626",
+ "ophyd_burst": "#16a34a",
+ "burst_reconfig": "#ea580c",
+ "reconfig_wfd": "#7c3aed",
}
label_map = {
- "raw": "Raw MMCore",
- "ophyd": "Ophyd (full)",
- "ophyd_burst": "Ophyd burst",
- "burst_reconfig": "Reconfig (sleep)",
- "reconfig_wfd": "Reconfig (waitForDevice)",
+ "raw": "Raw MMCore",
+ "ophyd": "Ophyd (full)",
+ "ophyd_burst": "Ophyd burst",
+ "burst_reconfig": "Reconfig (sleep)",
+ "reconfig_wfd": "Reconfig (waitForDevice)",
}
fig, ax = plt.subplots(figsize=(10, 5.5))
@@ -124,16 +127,27 @@ def plot_throughput(data: dict, output_dir: Path):
for i, approach in enumerate(approaches):
vals = [vps[s].get(approach, 0) for s in slices_set]
offset = (i - n / 2 + 0.5) * width
- bars = ax.bar(x + offset, vals, width * 0.92,
- label=label_map.get(approach, approach),
- color=color_map.get(approach, "#888"),
- edgecolor="white", linewidth=0.5)
+ bars = ax.bar(
+ x + offset,
+ vals,
+ width * 0.92,
+ label=label_map.get(approach, approach),
+ color=color_map.get(approach, "#888"),
+ edgecolor="white",
+ linewidth=0.5,
+ )
# Value labels on bars
- for bar, v in zip(bars, vals):
+ for bar, v in zip(bars, vals, strict=False):
if v > 0:
- ax.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 0.02,
- f"{v:.2f}", ha="center", va="bottom", fontsize=7,
- fontweight="bold")
+ ax.text(
+ bar.get_x() + bar.get_width() / 2,
+ bar.get_height() + 0.02,
+ f"{v:.2f}",
+ ha="center",
+ va="bottom",
+ fontsize=7,
+ fontweight="bold",
+ )
ax.set_xlabel("Slices per volume", fontsize=11)
ax.set_ylabel("Volumes per second", fontsize=11)
@@ -149,7 +163,7 @@ def plot_throughput(data: dict, output_dir: Path):
fig.tight_layout()
fig.savefig(output_dir / "benchmark_throughput.png", dpi=180)
plt.close(fig)
- print(f" Saved: benchmark_throughput.png")
+ print(" Saved: benchmark_throughput.png")
# ---------------------------------------------------------------------------
@@ -167,14 +181,14 @@ def plot_overhead(data: dict, output_dir: Path):
compare = ["ophyd", "burst_reconfig", "reconfig_wfd"]
color_map = {
- "ophyd": "#dc2626",
- "burst_reconfig": "#ea580c",
- "reconfig_wfd": "#7c3aed",
+ "ophyd": "#dc2626",
+ "burst_reconfig": "#ea580c",
+ "reconfig_wfd": "#7c3aed",
}
label_map = {
- "ophyd": "Ophyd (full teardown/setup)",
- "burst_reconfig": "Reconfig (time.sleep)",
- "reconfig_wfd": "Reconfig (waitForDevice)",
+ "ophyd": "Ophyd (full teardown/setup)",
+ "burst_reconfig": "Reconfig (time.sleep)",
+ "reconfig_wfd": "Reconfig (waitForDevice)",
}
overhead = defaultdict(dict)
@@ -192,15 +206,26 @@ def plot_overhead(data: dict, output_dir: Path):
for i, approach in enumerate(compare):
vals = [overhead[s].get(approach, 0) for s in slices_set]
offset = (i - n / 2 + 0.5) * width
- bars = ax.bar(x + offset, vals, width * 0.92,
- label=label_map.get(approach, approach),
- color=color_map.get(approach, "#888"),
- edgecolor="white", linewidth=0.5)
- for bar, v in zip(bars, vals):
+ bars = ax.bar(
+ x + offset,
+ vals,
+ width * 0.92,
+ label=label_map.get(approach, approach),
+ color=color_map.get(approach, "#888"),
+ edgecolor="white",
+ linewidth=0.5,
+ )
+ for bar, v in zip(bars, vals, strict=False):
if v > 0:
- ax.text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 8,
- f"{v:.0f}", ha="center", va="bottom", fontsize=8,
- fontweight="bold")
+ ax.text(
+ bar.get_x() + bar.get_width() / 2,
+ bar.get_height() + 8,
+ f"{v:.0f}",
+ ha="center",
+ va="bottom",
+ fontsize=8,
+ fontweight="bold",
+ )
ax.set_xlabel("Slices per volume", fontsize=11)
ax.set_ylabel("Overhead vs raw MMCore (ms)", fontsize=11)
@@ -216,7 +241,7 @@ def plot_overhead(data: dict, output_dir: Path):
fig.tight_layout()
fig.savefig(output_dir / "benchmark_overhead.png", dpi=180)
plt.close(fig)
- print(f" Saved: benchmark_overhead.png")
+ print(" Saved: benchmark_overhead.png")
# ---------------------------------------------------------------------------
@@ -243,20 +268,35 @@ def plot_wfd_savings(data: dict, output_dir: Path):
x = np.arange(len(slices_set))
width = 0.32
- for i, (approach, label, color) in enumerate([
- ("burst_reconfig", "sleep()", "#ea580c"),
- ("reconfig_wfd", "waitForDevice()", "#7c3aed"),
- ]):
+ for i, (approach, label, color) in enumerate(
+ [
+ ("burst_reconfig", "sleep()", "#ea580c"),
+ ("reconfig_wfd", "waitForDevice()", "#7c3aed"),
+ ]
+ ):
acq_times = [raw_means.get(s, 0) for s in slices_set]
overheads = [means[s].get(approach, 0) - raw_means.get(s, 0) for s in slices_set]
offset = (i - 0.5) * width
- ax.bar(x + offset, acq_times, width * 0.92,
- color="#93c5fd", edgecolor="white", linewidth=0.5,
- label="Acquisition time" if i == 0 else None)
- ax.bar(x + offset, overheads, width * 0.92,
- bottom=acq_times, color=color, edgecolor="white", linewidth=0.5,
- label=f"Overhead ({label})")
+ ax.bar(
+ x + offset,
+ acq_times,
+ width * 0.92,
+ color="#93c5fd",
+ edgecolor="white",
+ linewidth=0.5,
+ label="Acquisition time" if i == 0 else None,
+ )
+ ax.bar(
+ x + offset,
+ overheads,
+ width * 0.92,
+ bottom=acq_times,
+ color=color,
+ edgecolor="white",
+ linewidth=0.5,
+ label=f"Overhead ({label})",
+ )
ax.set_xlabel("Slices per volume", fontsize=11)
ax.set_ylabel("Total time per volume (s)", fontsize=11)
@@ -282,27 +322,53 @@ def plot_wfd_savings(data: dict, output_dir: Path):
savings.append(so - wo)
bar_width = 0.55
- bars_sleep = ax2.barh(x + 0.15, sleep_overhead, bar_width * 0.48,
- color="#ea580c", label="time.sleep() overhead")
- bars_wfd = ax2.barh(x - 0.15, wfd_overhead, bar_width * 0.48,
- color="#7c3aed", label="waitForDevice() overhead")
-
- for bar, val, sav in zip(bars_sleep, sleep_overhead, savings):
- ax2.text(bar.get_width() + 8, bar.get_y() + bar.get_height() / 2,
- f"{val:.0f}ms", va="center", fontsize=9, color="#ea580c",
- fontweight="bold")
- for bar, val in zip(bars_wfd, wfd_overhead):
- ax2.text(bar.get_width() + 8, bar.get_y() + bar.get_height() / 2,
- f"{val:.0f}ms", va="center", fontsize=9, color="#7c3aed",
- fontweight="bold")
+ bars_sleep = ax2.barh(
+ x + 0.15,
+ sleep_overhead,
+ bar_width * 0.48,
+ color="#ea580c",
+ label="time.sleep() overhead",
+ )
+ bars_wfd = ax2.barh(
+ x - 0.15,
+ wfd_overhead,
+ bar_width * 0.48,
+ color="#7c3aed",
+ label="waitForDevice() overhead",
+ )
+
+ for bar, val, _sav in zip(bars_sleep, sleep_overhead, savings, strict=False):
+ ax2.text(
+ bar.get_width() + 8,
+ bar.get_y() + bar.get_height() / 2,
+ f"{val:.0f}ms",
+ va="center",
+ fontsize=9,
+ color="#ea580c",
+ fontweight="bold",
+ )
+ for bar, val in zip(bars_wfd, wfd_overhead, strict=False):
+ ax2.text(
+ bar.get_width() + 8,
+ bar.get_y() + bar.get_height() / 2,
+ f"{val:.0f}ms",
+ va="center",
+ fontsize=9,
+ color="#7c3aed",
+ fontweight="bold",
+ )
# Add savings annotation
- for i, (s, sav) in enumerate(zip(slices_set, savings)):
- ax2.annotate(f"-{sav:.0f}ms",
- xy=(sleep_overhead[i], i + 0.15),
- xytext=(sleep_overhead[i] + 60, i + 0.35),
- fontsize=8.5, fontweight="bold", color="#166534",
- arrowprops=dict(arrowstyle="->", color="#166534", lw=1.2))
+ for i, (_s, sav) in enumerate(zip(slices_set, savings, strict=False)):
+ ax2.annotate(
+ f"-{sav:.0f}ms",
+ xy=(sleep_overhead[i], i + 0.15),
+ xytext=(sleep_overhead[i] + 60, i + 0.35),
+ fontsize=8.5,
+ fontweight="bold",
+ color="#166534",
+ arrowprops=dict(arrowstyle="->", color="#166534", lw=1.2),
+ )
ax2.set_yticks(x)
ax2.set_yticklabels([f"{s} slices" for s in slices_set])
@@ -316,7 +382,7 @@ def plot_wfd_savings(data: dict, output_dir: Path):
fig.tight_layout()
fig.savefig(output_dir / "benchmark_wfd_savings.png", dpi=180)
plt.close(fig)
- print(f" Saved: benchmark_wfd_savings.png")
+ print(" Saved: benchmark_wfd_savings.png")
# ---------------------------------------------------------------------------
@@ -328,18 +394,18 @@ def plot_consistency(data: dict, output_dir: Path):
approaches_order = ["raw", "ophyd_burst", "reconfig_wfd", "burst_reconfig", "ophyd"]
label_map = {
- "raw": "Raw\nMMCore",
- "ophyd": "Ophyd\n(full)",
- "ophyd_burst": "Ophyd\nburst",
- "burst_reconfig": "Reconfig\n(sleep)",
- "reconfig_wfd": "Reconfig\n(wfd)",
+ "raw": "Raw\nMMCore",
+ "ophyd": "Ophyd\n(full)",
+ "ophyd_burst": "Ophyd\nburst",
+ "burst_reconfig": "Reconfig\n(sleep)",
+ "reconfig_wfd": "Reconfig\n(wfd)",
}
color_map = {
- "raw": "#2563eb",
- "ophyd": "#dc2626",
- "ophyd_burst": "#16a34a",
- "burst_reconfig": "#ea580c",
- "reconfig_wfd": "#7c3aed",
+ "raw": "#2563eb",
+ "ophyd": "#dc2626",
+ "ophyd_burst": "#16a34a",
+ "burst_reconfig": "#ea580c",
+ "reconfig_wfd": "#7c3aed",
}
slices_set = sorted(set(r["slices"] for r in per_volume))
@@ -348,21 +414,28 @@ def plot_consistency(data: dict, output_dir: Path):
if len(slices_set) == 1:
axes = [axes]
- for ax, ns in zip(axes, slices_set):
+ for ax, ns in zip(axes, slices_set, strict=False):
box_data = []
labels = []
colors = []
for approach in approaches_order:
- timings = [r["elapsed_s"] for r in per_volume
- if r["slices"] == ns and r["approach"] == approach]
+ timings = [
+ r["elapsed_s"]
+ for r in per_volume
+ if r["slices"] == ns and r["approach"] == approach
+ ]
if timings:
box_data.append(timings)
labels.append(label_map.get(approach, approach))
colors.append(color_map.get(approach, "#888"))
- bp = ax.boxplot(box_data, patch_artist=True, widths=0.55,
- medianprops=dict(color="black", linewidth=1.5))
- for patch, c in zip(bp["boxes"], colors):
+ bp = ax.boxplot(
+ box_data,
+ patch_artist=True,
+ widths=0.55,
+ medianprops=dict(color="black", linewidth=1.5),
+ )
+ for patch, c in zip(bp["boxes"], colors, strict=False):
patch.set_facecolor(c)
patch.set_alpha(0.7)
@@ -377,7 +450,7 @@ def plot_consistency(data: dict, output_dir: Path):
fig.tight_layout()
fig.savefig(output_dir / "benchmark_consistency.png", dpi=180, bbox_inches="tight")
plt.close(fig)
- print(f" Saved: benchmark_consistency.png")
+ print(" Saved: benchmark_consistency.png")
# ---------------------------------------------------------------------------
diff --git a/diagnostics/run_multi_embryo_volumes.py b/diagnostics/run_multi_embryo_volumes.py
index d52aeada..90af3c68 100644
--- a/diagnostics/run_multi_embryo_volumes.py
+++ b/diagnostics/run_multi_embryo_volumes.py
@@ -9,14 +9,15 @@
python run_multi_embryo_volumes.py
"""
-import time
import json
-import numpy as np
-from pathlib import Path
+import time
from datetime import datetime, timedelta
-from client import get_mmc
-import tifffile
+from pathlib import Path
+
+import numpy as np
import rpyc
+import tifffile
+from client import get_mmc
from tqdm import tqdm
# Device configuration
@@ -36,9 +37,11 @@
def load_database():
"""Load embryo database."""
if not DATABASE_FILE.exists():
- raise FileNotFoundError(f"Database not found: {DATABASE_FILE}\nRun multi_embryo_calibration.py first!")
+ raise FileNotFoundError(
+ f"Database not found: {DATABASE_FILE}\nRun multi_embryo_calibration.py first!"
+ )
- with open(DATABASE_FILE, 'r') as f:
+ with open(DATABASE_FILE) as f:
return json.load(f)
@@ -58,8 +61,8 @@ def move_to_embryo(embryo_data):
embryo_data : dict
Embryo information from database
"""
- target_x = embryo_data['stage_position_after_centering_um']['x']
- target_y = embryo_data['stage_position_after_centering_um']['y']
+ target_x = embryo_data["stage_position_after_centering_um"]["x"]
+ target_y = embryo_data["stage_position_after_centering_um"]["y"]
print(f" Moving to embryo position: ({target_x:.2f}, {target_y:.2f}) µm")
@@ -94,7 +97,7 @@ def configure_hardware_for_volume(calibration, num_slices):
# Stop any existing sequence acquisition (from previous embryo or calibration)
if core.isSequenceRunning():
- print(f" Stopping previous sequence...")
+ print(" Stopping previous sequence...")
core.stopSequenceAcquisition()
time.sleep(0.5)
@@ -105,14 +108,14 @@ def configure_hardware_for_volume(calibration, num_slices):
try:
core.setProperty(GALVO_DEVICE, "SPIMState", "Idle")
time.sleep(0.2)
- except:
+ except Exception:
pass
# Extract calibration parameters
- slope = calibration['slope_um_per_deg']
- offset = calibration['offset_um']
- galvo_top = calibration.get('edge_top_deg', calibration['galvo_top_deg'])
- galvo_bottom = calibration.get('edge_bottom_deg', calibration['galvo_bottom_deg'])
+ slope = calibration["slope_um_per_deg"]
+ offset = calibration["offset_um"]
+ galvo_top = calibration.get("edge_top_deg", calibration["galvo_top_deg"])
+ galvo_bottom = calibration.get("edge_bottom_deg", calibration["galvo_bottom_deg"])
# Calculate galvo parameters
galvo_center = (galvo_top + galvo_bottom) / 2.0
@@ -126,8 +129,14 @@ def configure_hardware_for_volume(calibration, num_slices):
piezo_range = piezo_bottom - piezo_top
piezo_amplitude = piezo_range / 2.0
- print(f" Galvo: center={galvo_center:+.4f}°, amplitude=±{galvo_amplitude:.4f}° (range: {galvo_range:.4f}°)")
- print(f" Piezo: center={piezo_center:.1f}µm, amplitude=±{piezo_amplitude:.1f}µm (range: {piezo_range:.1f}µm)")
+ print(
+ f" Galvo: center={galvo_center:+.4f}°, amplitude=±{galvo_amplitude:.4f}°"
+ f" (range: {galvo_range:.4f}°)"
+ )
+ print(
+ f" Piezo: center={piezo_center:.1f}µm, amplitude=±{piezo_amplitude:.1f}µm"
+ f" (range: {piezo_range:.1f}µm)"
+ )
# System startup
core.setConfig("System", "Startup")
@@ -189,13 +198,13 @@ def configure_hardware_for_volume(calibration, num_slices):
core.setProperty(PIEZO_DEVICE, "SPIMState", "Armed")
time.sleep(0.3)
- print(f" ✓ Hardware configured for hardware-triggered acquisition")
+ print(" ✓ Hardware configured for hardware-triggered acquisition")
return {
- 'galvo_center': galvo_center,
- 'galvo_amplitude': galvo_amplitude,
- 'piezo_center': piezo_center,
- 'piezo_amplitude': piezo_amplitude
+ "galvo_center": galvo_center,
+ "galvo_amplitude": galvo_amplitude,
+ "piezo_center": piezo_center,
+ "piezo_amplitude": piezo_amplitude,
}
@@ -238,7 +247,7 @@ def acquire_volume_for_embryo(embryo_id, calibration, num_slices=50):
# Trigger SPIM state machine
core.setProperty(GALVO_DEVICE, "SPIMState", "Running")
- print(f" ✓ SPIM triggered")
+ print(" ✓ SPIM triggered")
# Collect images
images = []
@@ -296,52 +305,59 @@ def save_volume(volume, embryo_id, embryo_number, output_dir):
def main():
"""Main multi-embryo volume acquisition workflow."""
- print(f"{'='*70}")
+ print(f"{'=' * 70}")
print("MULTI-EMBRYO VOLUME ACQUISITION")
- print(f"{'='*70}")
+ print(f"{'=' * 70}")
try:
# Load database
- print(f"\n{'='*70}")
+ print(f"\n{'=' * 70}")
print("LOADING DATABASE")
- print(f"{'='*70}")
+ print(f"{'=' * 70}")
database = load_database()
- embryos = database.get('embryos', {})
+ embryos = database.get("embryos", {})
num_embryos = len(embryos)
print(f" Database: {DATABASE_FILE}")
print(f" Found {num_embryos} embryo(s)")
if num_embryos == 0:
- print(f"\n ⚠ No embryos in database!")
- print(f" Run multi_embryo_calibration.py first.")
+ print("\n ⚠ No embryos in database!")
+ print(" Run multi_embryo_calibration.py first.")
return
# List embryos
- print(f"\n Embryos:")
+ print("\n Embryos:")
for emb_id, emb_data in embryos.items():
- emb_num = emb_data.get('embryo_number', '?')
- pos = emb_data['stage_position_after_centering_um']
+ emb_num = emb_data.get("embryo_number", "?")
+ pos = emb_data["stage_position_after_centering_um"]
print(f" {emb_id} (#{emb_num}): ({pos['x']:.1f}, {pos['y']:.1f}) µm")
# Acquisition parameters
- print(f"\n{'='*70}")
+ print(f"\n{'=' * 70}")
print("ACQUISITION PARAMETERS")
- print(f"{'='*70}")
+ print(f"{'=' * 70}")
- num_slices = int(input(f" Number of slices per volume (default 50): ").strip() or "50")
+ num_slices = int(input(" Number of slices per volume (default 50): ").strip() or "50")
print(f" ✓ Will acquire {num_slices} slices per embryo")
# Timelapse parameters
- num_timepoints = int(input(f" Number of timepoints (default 1 for single acquisition): ").strip() or "1")
+ num_timepoints = int(
+ input(" Number of timepoints (default 1 for single acquisition): ").strip() or "1"
+ )
interval_minutes = 0
if num_timepoints > 1:
- interval_minutes = float(input(f" Interval between timepoints in minutes (e.g., 2): ").strip() or "2")
+ interval_minutes = float(
+ input(" Interval between timepoints in minutes (e.g., 2): ").strip() or "2"
+ )
total_duration_hours = (num_timepoints - 1) * interval_minutes / 60.0
- print(f" ✓ Timelapse: {num_timepoints} timepoints every {interval_minutes} min ({total_duration_hours:.1f} hours total)")
+ print(
+ f" ✓ Timelapse: {num_timepoints} timepoints every {interval_minutes} min"
+ f" ({total_duration_hours:.1f} hours total)"
+ )
else:
- print(f" ✓ Single acquisition (no timelapse)")
+ print(" ✓ Single acquisition (no timelapse)")
# Create output directory
session_dir = OUTPUT_DIR / datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -358,8 +374,11 @@ def main():
desc="Timepoints",
unit="tp",
position=0,
- colour='green',
- bar_format='{desc}: {percentage:3.0f}%|{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]'
+ colour="green",
+ bar_format=(
+ "{desc}: {percentage:3.0f}%|{bar}| {n_fmt}/{total_fmt}"
+ " [{elapsed}<{remaining}, {rate_fmt}]"
+ ),
)
for timepoint in range(num_timepoints):
@@ -367,13 +386,15 @@ def main():
elapsed_hours = (timepoint_start_time - session_start_time) / 3600.0
# Update timepoint progress bar
- timepoint_pbar.set_description(f"Timepoint {timepoint+1}/{num_timepoints} (Elapsed: {elapsed_hours:.1f}h)")
+ timepoint_pbar.set_description(
+ f"Timepoint {timepoint + 1}/{num_timepoints} (Elapsed: {elapsed_hours:.1f}h)"
+ )
- print(f"\n{'='*70}")
+ print(f"\n{'=' * 70}")
print(f"TIMEPOINT {timepoint + 1}/{num_timepoints}")
if num_timepoints > 1:
print(f"Elapsed: {elapsed_hours:.2f} hours")
- print(f"{'='*70}")
+ print(f"{'=' * 70}")
# Acquire volume for each embryo
timepoint_results = []
@@ -385,51 +406,53 @@ def main():
unit="embryo",
position=1,
leave=False,
- colour='cyan'
+ colour="cyan",
)
for idx, (emb_id, emb_data) in enumerate(embryos.items(), 1):
- emb_num = emb_data.get('embryo_number', idx)
+ emb_num = emb_data.get("embryo_number", idx)
embryo_pbar.set_description(f" Embryo {emb_num} (t{timepoint:04d})")
print(f"\n[Embryo {idx}/{num_embryos}] {emb_id} (Embryo #{emb_num})")
- print(f"{'─'*70}")
+ print(f"{'─' * 70}")
# Move to embryo
move_to_embryo(emb_data)
# Configure hardware
- calibration = emb_data['calibration']
+ calibration = emb_data["calibration"]
configure_hardware_for_volume(calibration, num_slices)
# Acquire volume
volume = acquire_volume_for_embryo(emb_id, calibration, num_slices)
if volume is None:
- print(f" ✗ Failed to acquire volume")
- timepoint_results.append({
- 'embryo_id': emb_id,
- 'timepoint': timepoint,
- 'success': False
- })
+ print(" ✗ Failed to acquire volume")
+ timepoint_results.append(
+ {"embryo_id": emb_id, "timepoint": timepoint, "success": False}
+ )
embryo_pbar.update(1)
continue
# Save volume with timepoint in filename
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
- filename = session_dir / f"{emb_id}_embryo{emb_num:03d}_t{timepoint:04d}_{timestamp}.tif"
+ filename = (
+ session_dir / f"{emb_id}_embryo{emb_num:03d}_t{timepoint:04d}_{timestamp}.tif"
+ )
tifffile.imwrite(filename, volume)
print(f" ✓ Saved: {filename.name}")
- timepoint_results.append({
- 'embryo_id': emb_id,
- 'embryo_number': emb_num,
- 'timepoint': timepoint,
- 'success': True,
- 'filename': str(filename),
- 'shape': volume.shape
- })
+ timepoint_results.append(
+ {
+ "embryo_id": emb_id,
+ "embryo_number": emb_num,
+ "timepoint": timepoint,
+ "success": True,
+ "filename": str(filename),
+ "shape": volume.shape,
+ }
+ )
print(f" ✓ Complete: {volume.shape}")
embryo_pbar.update(1)
@@ -447,10 +470,10 @@ def main():
if wait_time > 0:
next_timepoint_time = datetime.now() + timedelta(seconds=wait_time)
- print(f"\n{'─'*70}")
- print(f"Waiting {wait_time/60:.1f} minutes until next timepoint...")
+ print(f"\n{'─' * 70}")
+ print(f"Waiting {wait_time / 60:.1f} minutes until next timepoint...")
print(f"Next timepoint at: {next_timepoint_time.strftime('%H:%M:%S')}")
- print(f"{'─'*70}")
+ print(f"{'─' * 70}")
# Progress bar for waiting
wait_pbar = tqdm(
@@ -459,7 +482,7 @@ def main():
unit="s",
position=1,
leave=False,
- colour='yellow'
+ colour="yellow",
)
for _ in range(int(wait_time)):
time.sleep(1)
@@ -469,70 +492,81 @@ def main():
# Sleep remaining fractional seconds
time.sleep(wait_time - int(wait_time))
else:
- print(f"\n{'─'*70}")
- print(f"⚠ Warning: Acquisition took {timepoint_duration/60:.1f} min (longer than {interval_minutes} min interval)")
- print(f"Proceeding immediately to next timepoint...")
- print(f"{'─'*70}")
+ print(f"\n{'─' * 70}")
+ print(
+ f"⚠ Warning: Acquisition took {timepoint_duration / 60:.1f} min"
+ f" (longer than {interval_minutes} min interval)"
+ )
+ print("Proceeding immediately to next timepoint...")
+ print(f"{'─' * 70}")
timepoint_pbar.close()
# Cleanup
- print(f"\n{'='*70}")
+ print(f"\n{'=' * 70}")
print("CLEANUP")
- print(f"{'='*70}")
+ print(f"{'=' * 70}")
core.setConfig("Laser", "ALL OFF")
- print(f" ✓ Lasers OFF")
+ print(" ✓ Lasers OFF")
# Summary
- print(f"\n{'='*70}")
+ print(f"\n{'=' * 70}")
print("ACQUISITION COMPLETE")
- print(f"{'='*70}")
+ print(f"{'=' * 70}")
total_duration = time.time() - session_start_time
- successful = sum(1 for r in all_results if r['success'])
+ successful = sum(1 for r in all_results if r["success"])
total_acquisitions = num_embryos * num_timepoints
- print(f"\n Session duration: {total_duration/3600:.2f} hours")
+ print(f"\n Session duration: {total_duration / 3600:.2f} hours")
print(f" Timepoints: {num_timepoints}")
print(f" Embryos per timepoint: {num_embryos}")
print(f" Successful acquisitions: {successful}/{total_acquisitions}")
print(f" Output directory: {session_dir}")
- print(f"\n Results:")
+ print("\n Results:")
for result in all_results:
- if result['success']:
- t = result.get('timepoint', 0)
- print(f" ✓ {result['embryo_id']} t{t:04d}: {result['shape']} → {Path(result['filename']).name}")
+ if result["success"]:
+ t = result.get("timepoint", 0)
+ print(
+ f" ✓ {result['embryo_id']} t{t:04d}: {result['shape']}"
+ f" → {Path(result['filename']).name}"
+ )
else:
- t = result.get('timepoint', 0)
+ t = result.get("timepoint", 0)
print(f" ✗ {result['embryo_id']} t{t:04d}: Failed")
# Save acquisition log
log_file = session_dir / "acquisition_log.json"
- with open(log_file, 'w') as f:
- json.dump({
- 'timestamp': datetime.now().isoformat(),
- 'session_duration_hours': total_duration / 3600.0,
- 'num_embryos': num_embryos,
- 'num_slices': num_slices,
- 'num_timepoints': num_timepoints,
- 'interval_minutes': interval_minutes,
- 'total_acquisitions': total_acquisitions,
- 'successful_acquisitions': successful,
- 'results': all_results
- }, f, indent=2)
+ with open(log_file, "w") as f:
+ json.dump(
+ {
+ "timestamp": datetime.now().isoformat(),
+ "session_duration_hours": total_duration / 3600.0,
+ "num_embryos": num_embryos,
+ "num_slices": num_slices,
+ "num_timepoints": num_timepoints,
+ "interval_minutes": interval_minutes,
+ "total_acquisitions": total_acquisitions,
+ "successful_acquisitions": successful,
+ "results": all_results,
+ },
+ f,
+ indent=2,
+ )
print(f"\n ✓ Log saved: {log_file}")
- print(f"\n{'='*70}\n")
+ print(f"\n{'=' * 70}\n")
except KeyboardInterrupt:
- print(f"\n\nInterrupted\n")
+ print("\n\nInterrupted\n")
except Exception as e:
- print(f"\n{'='*70}")
+ print(f"\n{'=' * 70}")
print("ERROR")
- print(f"{'='*70}")
+ print(f"{'=' * 70}")
print(f"Error: {e}")
import traceback
+
traceback.print_exc()
diff --git a/diagnostics/segment_embryo_nuclei.py b/diagnostics/segment_embryo_nuclei.py
index a99538c8..b9c0405f 100644
--- a/diagnostics/segment_embryo_nuclei.py
+++ b/diagnostics/segment_embryo_nuclei.py
@@ -3,11 +3,12 @@
Run with venv_cv: venv_cv/Scripts/python segment_embryo_nuclei.py
"""
+from pathlib import Path
+
+import napari
import numpy as np
import tifffile
-from pathlib import Path
from cellpose import models
-import napari
def load_volume(tiff_path: Path) -> np.ndarray:
@@ -39,10 +40,10 @@ def segment_nuclei_3d(volume: np.ndarray, diameter: float = 30.0) -> np.ndarray:
masks, flows, styles = model.eval(
vol_norm,
diameter=diameter,
- do_3D=False, # 2D per slice (fast!)
+ do_3D=False, # 2D per slice (fast!)
z_axis=0,
stitch_threshold=0.5, # stitch 2D masks into 3D
- batch_size=64, # larger batch for speed
+ batch_size=64, # larger batch for speed
)
n_nuclei = len(np.unique(masks)) - 1
@@ -76,6 +77,7 @@ def main():
# Downsample by factor of 2
from scipy.ndimage import zoom
+
volume = zoom(volume, (1, 0.5, 0.5), order=1)
print(f" Downsampled 2x: {volume.shape}")
@@ -85,7 +87,7 @@ def main():
# Visualize in Napari
print("Opening Napari viewer...")
viewer = napari.Viewer()
- viewer.add_image(volume, name="Volume", colormap='gray')
+ viewer.add_image(volume, name="Volume", colormap="gray")
viewer.add_labels(masks, name="Nuclei segmentation")
napari.run()
diff --git a/diagnostics/spim_hardware_triggering_reference.py b/diagnostics/spim_hardware_triggering_reference.py
index cab5cfb1..87a9f7a4 100644
--- a/diagnostics/spim_hardware_triggering_reference.py
+++ b/diagnostics/spim_hardware_triggering_reference.py
@@ -70,9 +70,11 @@
"""
import time
+
import numpy as np
from client import get_mmc
+
def configure_camera_for_hardware_trigger(core, camera_name, exposure_ms):
"""
Configure Hamamatsu camera for external edge triggering in light sheet mode.
@@ -132,8 +134,15 @@ def configure_camera_for_hardware_trigger(core, camera_name, exposure_ms):
raise Exception(f"Failed to set TRIGGER ACTIVE to EDGE (got: {trigger_active})")
-def configure_spim_scanner(core, scanner_name, num_slices, slice_step_um,
- scan_duration_ms, camera_duration_ms, laser_duration_ms):
+def configure_spim_scanner(
+ core,
+ scanner_name,
+ num_slices,
+ slice_step_um,
+ scan_duration_ms,
+ camera_duration_ms,
+ laser_duration_ms,
+):
"""
Configure ASI Tiger scanner for SPIM state machine operation.
@@ -180,7 +189,7 @@ def configure_spim_scanner(core, scanner_name, num_slices, slice_step_um,
core.setProperty(scanner_name, "SingleAxisYPattern", "1 - Triangle")
core.setProperty(scanner_name, "SingleAxisYMode", "3 - Enabled with axes synced")
- print(f" X-axis (light sheet): Amplitude=2.0°, Pattern=Triangle, Mode=Synced")
+ print(" X-axis (light sheet): Amplitude=2.0°, Pattern=Triangle, Mode=Synced")
print(f" Y-axis (slice step): Amplitude={y_amplitude:.4f}°, Pattern=Triangle, Mode=Synced")
print(f" (Calculated for {num_slices} slices × {slice_step_um} μm steps)")
@@ -206,7 +215,7 @@ def configure_spim_scanner(core, scanner_name, num_slices, slice_step_um,
core.setProperty(scanner_name, "SPIMDelayBeforeScan(ms)", 0.0)
core.setProperty(scanner_name, "SPIMDelayBeforeCamera(ms)", 0.5)
- print(f" SPIM State Machine:")
+ print(" SPIM State Machine:")
print(f" NumSlices: {num_slices}")
print(f" ScanDuration: {scan_duration_ms} ms (total time per slice)")
print(f" CameraDuration: {camera_duration_ms} ms (TTL trigger pulse width)")
@@ -214,10 +223,16 @@ def configure_spim_scanner(core, scanner_name, num_slices, slice_step_um,
# Verify critical timing relationships
if camera_duration_ms > scan_duration_ms:
- raise Exception(f"CameraDuration ({camera_duration_ms}ms) must be <= ScanDuration ({scan_duration_ms}ms)")
+ raise Exception(
+ f"CameraDuration ({camera_duration_ms}ms) must be <="
+ f" ScanDuration ({scan_duration_ms}ms)"
+ )
if laser_duration_ms > camera_duration_ms:
- raise Exception(f"LaserDuration ({laser_duration_ms}ms) must be <= CameraDuration ({camera_duration_ms}ms)")
+ raise Exception(
+ f"LaserDuration ({laser_duration_ms}ms) must be <="
+ f" CameraDuration ({camera_duration_ms}ms)"
+ )
def arm_spim_state_machine(core, scanner_name):
@@ -256,8 +271,9 @@ def trigger_spim_acquisition(core, scanner_name):
print(f" SPIMState: {state}")
-def acquire_spim_volume(core, camera_name, scanner_name, num_slices,
- scan_duration_ms, timeout_extra_sec=5.0):
+def acquire_spim_volume(
+ core, camera_name, scanner_name, num_slices, scan_duration_ms, timeout_extra_sec=5.0
+):
"""
Perform hardware-triggered SPIM volume acquisition.
@@ -337,7 +353,10 @@ def acquire_spim_volume(core, camera_name, scanner_name, num_slices,
count = core.getRemainingImageCount()
seq_running = core.isSequenceRunning(camera_name)
spim_state = core.getProperty(scanner_name, "SPIMState")
- print(f" t={elapsed:.1f}s: images={count}/{num_slices}, seq={seq_running}, SPIM={spim_state}")
+ print(
+ f" t={elapsed:.1f}s: images={count}/{num_slices},"
+ f" seq={seq_running}, SPIM={spim_state}"
+ )
last_print_time = time.time()
time.sleep(0.01)
@@ -350,13 +369,16 @@ def acquire_spim_volume(core, camera_name, scanner_name, num_slices,
print(" Retrieving images from buffer...")
import rpyc
+
images = []
for i in range(count):
img = core.popNextImage()
img = rpyc.classic.obtain(img) # Transfer from remote to local
images.append(img)
- print(f" Image {i+1}/{count}: shape={img.shape}, dtype={img.dtype}, "
- f"range=[{img.min()}, {img.max()}], mean={img.mean():.1f}")
+ print(
+ f" Image {i + 1}/{count}: shape={img.shape}, dtype={img.dtype}, "
+ f"range=[{img.min()}, {img.max()}], mean={img.mean():.1f}"
+ )
# Convert to 3D numpy array
volume = np.array(images)
@@ -380,9 +402,9 @@ def main():
camera_duration_ms = 155.0 # TTL pulse width (should be ~= exposure)
laser_duration_ms = 154.0 # Laser on time (slightly less than camera)
- print("="*80)
+ print("=" * 80)
print("ASI diSPIM HARDWARE-TRIGGERED VOLUME ACQUISITION")
- print("="*80)
+ print("=" * 80)
try:
# Apply system configuration
@@ -413,8 +435,13 @@ def main():
# Configure SPIM scanner
print()
configure_spim_scanner(
- core, scanner_name, num_slices, slice_step_um,
- scan_duration_ms, camera_duration_ms, laser_duration_ms
+ core,
+ scanner_name,
+ num_slices,
+ slice_step_um,
+ scan_duration_ms,
+ camera_duration_ms,
+ laser_duration_ms,
)
# Arm SPIM state machine
@@ -423,43 +450,50 @@ def main():
# Acquire volume
print()
- volume = acquire_spim_volume(
- core, camera_name, scanner_name, num_slices, scan_duration_ms
- )
+ volume = acquire_spim_volume(core, camera_name, scanner_name, num_slices, scan_duration_ms)
# Save volume
print("\nSaving volume...")
from PIL import Image as PILImage
+
img_list = [PILImage.fromarray(img.astype(np.uint16)) for img in volume]
- img_list[0].save('spim_hardware_triggered_volume.tif',
- save_all=True, append_images=img_list[1:])
+ img_list[0].save(
+ "spim_hardware_triggered_volume.tif",
+ save_all=True,
+ append_images=img_list[1:],
+ )
print(f" Saved {len(volume)}-slice volume to: spim_hardware_triggered_volume.tif")
print(f" Volume shape: {volume.shape} (slices, height, width)")
# Display in napari (optional)
try:
import napari
+
print("\nDisplaying in napari...")
viewer = napari.Viewer()
- viewer.add_image(volume, name='SPIM Volume', colormap='gray',
- contrast_limits=[np.percentile(volume, 1),
- np.percentile(volume, 99)])
- viewer.dims.axis_labels = ['Z', 'Y', 'X']
+ viewer.add_image(
+ volume,
+ name="SPIM Volume",
+ colormap="gray",
+ contrast_limits=[np.percentile(volume, 1), np.percentile(volume, 99)],
+ )
+ viewer.dims.axis_labels = ["Z", "Y", "X"]
print(" Close napari window to continue...")
napari.run()
except ImportError:
print(" (napari not available, skipping visualization)")
- print("\n" + "="*80)
+ print("\n" + "=" * 80)
print("ACQUISITION COMPLETE!")
- print("="*80)
+ print("=" * 80)
except Exception as e:
- print("\n" + "="*80)
+ print("\n" + "=" * 80)
print("ACQUISITION FAILED")
- print("="*80)
+ print("=" * 80)
print(f"Error: {e}")
import traceback
+
traceback.print_exc()
finally:
@@ -469,26 +503,26 @@ def main():
if core.isSequenceRunning(camera_name):
core.stopSequenceAcquisition(camera_name)
print(" Stopped camera sequence")
- except:
+ except Exception:
pass
try:
core.setProperty(scanner_name, "SPIMState", "Idle")
print(" Reset SPIM to Idle")
- except:
+ except Exception:
pass
try:
# Reset camera to internal triggering for live mode
core.setProperty(camera_name, "TRIGGER SOURCE", "INTERNAL")
print(" Reset camera to internal triggering")
- except:
+ except Exception:
pass
try:
core.setConfig("Laser", "ALL OFF")
print(" Lasers OFF")
- except:
+ except Exception:
pass
diff --git a/diagnostics/switchbot_webgui.py b/diagnostics/switchbot_webgui.py
new file mode 100644
index 00000000..5df81015
--- /dev/null
+++ b/diagnostics/switchbot_webgui.py
@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""
+Temporary web GUI to play with the SwitchBot Bot that switches the diSPIM room
+light (on for bottom-camera/brightfield imaging, off otherwise).
+
+This is a TEST TOOL, not part of the production device layer. It drives the Bot
+directly over BLE using the same command protocol as
+``gently.hardware.switchbot.SwitchBot`` (same command bytes + GATT UUIDs), but
+over a single *persistent* connection so the buttons feel snappy and the morse
+blinker is fast — the device-layer class is connect-per-command (~1-2 s each),
+which is fine for a plan step but hopeless for blinking.
+
+Features: ON / OFF / PRESS buttons, and a morse-code blinker (blinks the real
+room light + mirrors the pattern on screen). The Bot is a mechanical switch
+pusher, so each toggle is a ~0.5-1 s servo move — morse is deliberately slow.
+
+Run:
+ .venv/bin/python diagnostics/switchbot_webgui.py
+ # then open http://127.0.0.1:8765
+
+ .venv/bin/python diagnostics/switchbot_webgui.py --address EC:6F:04:06:5B:23 --port 8765
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, JSONResponse
+from pydantic import BaseModel
+
+# Reuse the device-layer device's protocol definitions (single source of truth).
+from gently.hardware.switchbot import _COMMANDS, _CTRL_CHAR
+
+logger = logging.getLogger("switchbot_webgui")
+
+DEFAULT_ADDRESS = "EC:6F:04:06:5B:23"
+
+# ITU morse, letters + digits. Unsupported characters are skipped.
+MORSE = {
+ "A": ".-",
+ "B": "-...",
+ "C": "-.-.",
+ "D": "-..",
+ "E": ".",
+ "F": "..-.",
+ "G": "--.",
+ "H": "....",
+ "I": "..",
+ "J": ".---",
+ "K": "-.-",
+ "L": ".-..",
+ "M": "--",
+ "N": "-.",
+ "O": "---",
+ "P": ".--.",
+ "Q": "--.-",
+ "R": ".-.",
+ "S": "...",
+ "T": "-",
+ "U": "..-",
+ "V": "...-",
+ "W": ".--",
+ "X": "-..-",
+ "Y": "-.--",
+ "Z": "--..",
+ "0": "-----",
+ "1": ".----",
+ "2": "..---",
+ "3": "...--",
+ "4": "....-",
+ "5": ".....",
+ "6": "-....",
+ "7": "--...",
+ "8": "---..",
+ "9": "----.",
+}
+
+
+class Bot:
+ """A single persistent BLE connection to the Bot, with serialized access."""
+
+ def __init__(self, address: str):
+ self.address = address
+ self._client = None
+ self._lock = asyncio.Lock()
+ self._morse_task: asyncio.Task | None = None
+ self.state = "unknown"
+ self.busy = False
+
+ async def _ensure(self):
+ from bleak import BleakClient
+
+ if self._client is not None and self._client.is_connected:
+ return
+ self._client = BleakClient(self.address, timeout=20)
+ await self._client.connect()
+ logger.info("connected to %s", self.address)
+
+ async def _write(self, action: str):
+ """Write one command, reconnecting once if the link dropped."""
+ from bleak.exc import BleakError
+
+ for attempt in (1, 2):
+ try:
+ await self._ensure()
+ await self._client.write_gatt_char(_CTRL_CHAR, _COMMANDS[action], response=True)
+ if action in ("on", "off"):
+ self.state = action
+ return
+ except (BleakError, OSError, asyncio.TimeoutError) as exc:
+ logger.warning("write %s attempt %d failed: %s", action, attempt, exc)
+ self._client = None # force reconnect
+ if attempt == 2:
+ raise
+
+ async def _cancel_morse(self):
+ task = self._morse_task
+ if task and not task.done():
+ task.cancel()
+ await asyncio.gather(task, return_exceptions=True)
+ self._morse_task = None
+
+ async def command(self, action: str) -> str:
+ """ON/OFF/PRESS. Interrupts any running morse (manual override)."""
+ await self._cancel_morse()
+ async with self._lock:
+ await self._write(action)
+ return self.state
+
+ def schedule(self, text: str, unit: float):
+ """Build an on/off timeline [(state, seconds), ...] for a message."""
+ seq = [("off", round(unit, 3))] # settle to a known state first
+ for ch in text.upper():
+ if ch == " ":
+ seq.append(("off", round(unit * 7, 3)))
+ continue
+ code = MORSE.get(ch)
+ if not code:
+ continue
+ for sym in code:
+ seq.append(("on", round(unit * (3 if sym == "-" else 1), 3)))
+ seq.append(("off", round(unit, 3))) # intra-letter gap
+ st, _ = seq[-1]
+ seq[-1] = (st, round(unit * 3, 3)) # upgrade to inter-letter gap
+ return seq
+
+ async def start_morse(self, text: str, unit: float):
+ await self._cancel_morse()
+ seq = self.schedule(text, unit)
+ if len(seq) <= 1:
+ return None
+ restore = self.state
+ self._morse_task = asyncio.create_task(self._play(seq, restore))
+ return seq
+
+ async def _play(self, seq, restore: str):
+ async with self._lock:
+ self.busy = True
+ try:
+ for state, dur in seq:
+ await self._write(state)
+ await asyncio.sleep(dur)
+ await self._write(restore if restore in ("on", "off") else "off")
+ finally:
+ self.busy = False
+
+ async def stop(self):
+ await self._cancel_morse()
+ async with self._lock:
+ await self._write("off")
+ return self.state
+
+ async def disconnect(self):
+ await self._cancel_morse()
+ if self._client is not None and self._client.is_connected:
+ await self._client.disconnect()
+
+
+BOT: Bot | None = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+ yield
+ if BOT is not None:
+ await BOT.disconnect()
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+class MorseReq(BaseModel):
+ text: str
+ unit: float = 1.5
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index():
+ return PAGE.replace("__ADDRESS__", BOT.address)
+
+
+@app.get("/status")
+async def status():
+ return {"state": BOT.state, "busy": BOT.busy, "address": BOT.address}
+
+
+@app.post("/cmd/{action}")
+async def cmd(action: str):
+ if action not in _COMMANDS:
+ return JSONResponse({"error": f"unknown action {action!r}"}, status_code=400)
+ try:
+ state = await BOT.command(action)
+ except Exception as exc:
+ return JSONResponse({"error": str(exc)}, status_code=502)
+ return {"state": state}
+
+
+@app.post("/morse")
+async def morse(req: MorseReq):
+ unit = max(0.3, min(4.0, req.unit))
+ text = req.text[:40]
+ try:
+ seq = await BOT.start_morse(text, unit)
+ except Exception as exc:
+ return JSONResponse({"error": str(exc)}, status_code=502)
+ if seq is None:
+ return JSONResponse({"error": "nothing sendable in that text"}, status_code=400)
+ seconds = round(sum(d for _, d in seq), 1)
+ return {"schedule": seq, "unit": unit, "seconds": seconds}
+
+
+@app.post("/stop")
+async def stop():
+ try:
+ state = await BOT.stop()
+ except Exception as exc:
+ return JSONResponse({"error": str(exc)}, status_code=502)
+ return {"state": state}
+
+
+PAGE = """
+
+
+{content}
+
+
+"""
+
+
+def main():
+ ap = argparse.ArgumentParser(description="Temporary SwitchBot room-light web GUI")
+ ap.add_argument("--address", default=DEFAULT_ADDRESS, help="Bot BLE MAC address")
+ ap.add_argument("--port", type=int, default=8765)
+ ap.add_argument("--host", default="127.0.0.1", help="bind host (default: localhost only)")
+ args = ap.parse_args()
+
+ logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+ global BOT
+ BOT = Bot(args.address)
+ print(f"\n diSPIM Room Light GUI → http://{args.host}:{args.port}\n Bot: {args.address}\n")
+ uvicorn.run(app, host=args.host, port=args.port, log_level="warning")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/docs/CLOSED_LOOP_PARADIGM.md b/docs/CLOSED_LOOP_PARADIGM.md
new file mode 100644
index 00000000..8f1cf80d
--- /dev/null
+++ b/docs/CLOSED_LOOP_PARADIGM.md
@@ -0,0 +1,536 @@
+# Closed-Loop Paradigm: Notes on the Discussion
+
+This document captures the design conversation that produced everything on the
+`paradigm/closed-loop` branch: the schema split, the Map-as-embryo-home work,
+the operator-action vocabulary, the eval substrate (capture / replay /
+decisions / shadow), and the trajectory the system is on. It is a
+distillation, not a transcript — a future-self / new-collaborator reference
+for *why* this code looks the way it does and *where it is going*.
+
+---
+
+## 1. The Original Friction
+
+The conversation started from a small, concrete observation by the operator:
+
+> "It feels awkward that the operator has to go between the chat in the TUI
+> and the viz server… or even to chat about detecting embryos."
+
+That awkwardness is a symptom, not a defect. It surfaces a deeper design
+question: **what is the orchestrator (the agent) actually for?** Today the
+orchestrator does at least four jobs at once, and one of them — *tool router*
+— is the one creating the friction.
+
+### The four orchestrator roles
+
+| Role | Description | Replaceable by a button? |
+| --- | --- | --- |
+| 1. Tool router | "Detect embryos" → `detect_embryos()` call | **Yes** — this is the friction surface |
+| 2. Workflow runner | Timelapses, multi-embryo plans, perception loops | No |
+| 3. Domain reasoner | Knows microscopy, embryos, safety constraints | No |
+| 4. Session memory | Coherent narrative of what happened and why | No |
+
+Routing a single click through chat for a routine action is the system
+fighting against its own users. Routing a multi-step scientific decision
+through Claude is using the right tool for the right job. The paradigm here
+is: **shrink role 1 to its essentials, keep roles 2–4 first-class, and let
+the UI carry the rest.**
+
+---
+
+## 2. Web ↔ Chat Reconciliation Patterns
+
+Four ways to relate the web UI and the chat orchestrator. Each has a
+distinct world model property:
+
+### A. Chat-only intent (the old default)
+
+Every action originates in chat. The web is observation + delegated subtasks
+(e.g. the marking canvas is a delegation the orchestrator triggers).
+
+* Cleanest record.
+* Worst friction.
+* Orchestrator's world model is "complete" because every change passes
+ through it.
+
+### B. Two parallel command surfaces
+
+Operator clicks in web, web acts directly; orchestrator finds out by polling
+state or doesn't find out at all.
+
+* Lowest friction.
+* Orchestrator's world model **drifts from reality** — fatal for role 4
+ (session memory) and dangerous for role 3 (safety reasoning).
+
+### C. Web acts, orchestrator subscribes *(the chosen direction)*
+
+Operator clicks → web performs the action **and** publishes an event
+(`OPERATOR_*`) → orchestrator's session memory ingests it.
+
+* Chat log shows only human conversation.
+* Orchestrator's working context shows chat + events as a single timeline.
+* Phase 7 (operator events vocabulary + reactive candidate) is the first
+ installment of this pattern.
+
+### D. Cross-pattern hybrid
+
+Different action classes use different patterns. Heavy / novel / composite
+actions use chat (A); routine / clickable / contextual actions use web (C).
+This is what the system actually drifts toward; pattern C is the substrate
+that makes it possible.
+
+The orchestrator's job shifts from being **a funnel for action** to being **a
+brain that knows what's happening on every surface**.
+
+---
+
+## 3. The "Turn" is Wrong; the "Decision Moment" is Right
+
+Chat-AI literature reasons in *turns* (user message → assistant response).
+That model imports an assumption that does not hold here: the human is at
+the keyboard continuously. In a microscopy experiment running 12+ hours, the
+human checks in once, twice, maybe ten times. The agent is autonomous in
+between.
+
+The right unit is a **decision moment**, triggered by:
+
+1. **User message** — rare, interrupting (classic chat turn).
+2. **Critical event** — error, safety violation, lost focus, perception
+ anomaly. Wake immediately; decide to act / abort / escalate.
+3. **Phase boundary** — between timepoints, between embryos. Built-in
+ checkpoint: review state, decide whether to continue.
+4. **Periodic checkpoint** — every N minutes if nothing else happened.
+ Catches slow drifts.
+
+Between moments the agent is asleep. Plans execute autonomously. Events
+accumulate on the bus and in the world model. When the next decision
+moment fires, the agent reads:
+
+* The trigger (why am I waking up?)
+* The world snapshot (NOW state)
+* The events digest (what happened since last wake)
+* The conversation history (which might be hours old and less relevant
+ than usual)
+
+This is closer to a **supervisory controller** than a chat partner. The
+conversation history matters less than usual; what matters more is the
+**flight log** (events) plus the **current state snapshot**.
+
+### Trigger model — concrete
+
+A small router (in code, not Claude) sits between the bus and the brain:
+
+```
+ user input ─┐
+ event bus ──┼─► wake-router ──► (compose context) ──► claude.messages.create
+ schedule ──┘
+```
+
+The router's responsibilities:
+* Subscribe to a whitelist of "wake-worthy" event types.
+* Hold a debounce / coalescing buffer (so a burst of events becomes one
+ wake).
+* Keep a heartbeat schedule (every N minutes if no other trigger fired).
+* On wake, package: trigger, world snapshot, events digest, recent
+ conversation tail.
+* Surface the package to the brain.
+
+The brain stays the brain (Claude). The router is cheap, deterministic,
+debuggable code. It's the **meta-orchestrator** the operator mentioned —
+**not as another LLM**, but as a control surface.
+
+### Phase boundaries: hand-back vs subscribe
+
+Two designs for letting the brain look in mid-plan:
+
+* **Plan hands control back** at well-known points (between embryos, every
+ 5 timepoints). Cheaper, predictable, slightly less reactive.
+* **Plan never pauses; brain subscribes to plan events** ("perception
+ complete for embryo 3"). More reactive, more plan-coupling.
+
+The first one composes better with the supervisory-controller framing and
+is the recommended starting point.
+
+### Idle ticks
+
+If 30 min pass with no event and no user, should the agent wake to verify
+everything's OK? Default to **yes — periodic ticks with a high action
+threshold.** Most ticks should result in the agent doing nothing. The
+purpose is catching slow drifts (focus, sample state, hardware
+degradation) that don't trigger their own events.
+
+---
+
+## 4. World Model — Tiered, Not Monolithic
+
+A common mistake is "summarise everything every turn." Better is a tiered
+model where different freshness/density tiers carry different cadence
+costs.
+
+### Tier 1 — World snapshot
+
+Structured, ~30 lines, computed from in-memory state (not events), every
+wake.
+
+Includes: live stage XY/Z, current session id, embryo list with
+calibration state, current plan, acquisition status, recent operator
+actions (one-line summary).
+
+Cheap to build, fresh every time. Already mostly present in the
+codebase — `agent.experiment.get_summary()` plus the cached
+`DEVICE_STATE_UPDATE` payload is 80% of this.
+
+### Tier 2 — Recent-events digest
+
+Hand-written formatter over the events bus, filtered to wake-worthy types,
+inserted as a system note at each wake.
+
+Shape: `"Since last response: operator added embryo 4 via Map at 14:32; calibration completed for embryo 2; one perception trace pending."`
+
+Hand-written because LLM summarisation here adds latency, cost, and
+non-determinism for low value. Events are already structured.
+
+### Tier 3 — Pull tools
+
+For when reasoning needs depth: `get_recent_perceptions(embryo_id, n=5)`,
+`get_session_timeline()`, `get_learnings(campaign_id)`, etc. The agent
+calls these when it wants the detail.
+
+### Tier 4 — Optional LLM summariser
+
+Reserved for genuinely natural-language streams that resist rule-based
+compression: accumulated CV reasoning chains, narrative observations,
+cross-session learnings. Use a smaller, faster Claude model (Haiku is the
+natural fit). Run lazily, when a tier-3 tool asks for "summarise the last
+30 min for embryo 3."
+
+### Why this shape
+
+Decision moments are **rare** in autonomous mode. Token budget per wake
+can be generous (it's mostly idle compute). What matters more than budget
+is **cadence of waking** — saving 200 tokens per turn doesn't help if
+you're waking up at the wrong moments.
+
+---
+
+## 5. Testing — Where Most Projects Fail
+
+You cannot iterate on agent architecture without a way to compare
+architectures. Microscopy makes this hard:
+
+* Physical, non-deterministic, non-replayable in the trivial sense.
+* "Correct" is fuzzy — biological judgements rarely have ground truth.
+* Slow feedback (a timelapse takes hours).
+* Can't always reset to a clean state (samples are consumed).
+
+Five testing primitives, ranked by payoff per unit work (this ordering
+informed Phase 6's build order):
+
+### 5.1 Event replay *(built — Phase 6a/6b)*
+
+Capture the full event stream during a real run. Offline, replay it
+through any candidate architecture. Diff its decisions against
+production's. **Foundation** — without it, every change to the
+orchestrator is a flight test.
+
+### 5.2 Shadow mode *(built — Phase 6d)*
+
+During a real experiment, candidate architectures run alongside
+production. They see the same events but their decisions are *logged,
+not enacted*. Unique value over pure replay: shadow agents experience
+real temporal cadence, so timing-sensitive things (drift, races) are
+caught.
+
+### 5.3 Synthetic event sequences
+
+Hand-crafted streams: cascading errors, ambiguous perception,
+contradictory operator actions, focus drift, network drop mid-acquisition.
+Stress / chaos testing. The orchestrator is correct if it doesn't do
+something catastrophic — much easier to score than biological
+correctness.
+
+Trivially built on top of 5.1 — write a `jsonl` by hand, replay it.
+
+### 5.4 Decision-level micro-benchmarks
+
+Specific judgements — "given this perception result and these recent
+observations, should the agent re-focus?" — captured as
+(input → expected decision) pairs labelled by a biologist. Regression
+suite. Cheap with biologist time, expensive to bootstrap, very valuable
+once you have a few hundred.
+
+### 5.5 Multi-agent A/B in production
+
+Two embryos in the same dish, one supervised by architecture A and one
+by B (both honouring the firmware fence). Compare biological outcomes.
+Slow (one timelapse per data point), but the **only thing that measures
+biological correctness end-to-end.**
+
+---
+
+## 6. Embryo Schema: Coarse vs Fine
+
+Foundational and quietly important. Each embryo carries:
+
+* `position_coarse` — set by bottom-camera detection or manual Map
+ placement. Always present.
+* `position_fine` — set later by SPIM-objective alignment (workflow not
+ yet built). Initially `{}`.
+* `stage_position` — a *derived property*: `fine if fine else coarse`.
+ Downstream motion / perception keeps reading this and stays agnostic
+ about which calibration stage we're in.
+
+This is the seed for a broader idea: **measurements have provenance and
+calibration state**. The same embryo at the same nominal XY can have
+different "true" positions depending on which sensor sighted it. Encode
+that explicitly so any downstream decision can ask *"how confident is
+this position?"* without needing to know the whole calibration history.
+
+When the operator drags an embryo on the Map, the PUT clears `fine` —
+overriding the sighting invalidates any SPIM-derived fine alignment
+derived from the old coarse. `OPERATOR_EDITED_EMBRYO` carries
+`fine_position_invalidated` so the candidate / future controller can
+schedule a re-alignment without inferring it.
+
+---
+
+## 7. The Map as Collaborative World Model
+
+The Devices > Map page is more than visualisation. It is the **first
+collaborative surface** between operator and orchestrator: both can read
+the embryo list; both can mutate it. The orchestrator subscribes; the
+operator clicks.
+
+Visual semantics matter:
+
+* Coarse-only embryo → outlined ring + number. *Provisional.*
+* SPIM-fine-calibrated → filled disc + number. *Committed.*
+
+Calibration state is then visible at a glance across the slide — the
+operator can scan and see "embryo 3 still needs alignment" without
+opening anything.
+
+The pick-up / drop interaction (Phase 5) deliberately rejects
+click-to-add: the Map is a schematic, not a satellite view. Adding a
+new sighting without a visual reference is guessing. New embryos go
+through the bottom-camera marking canvas. The Map is for **editing what
+already exists**.
+
+### Future arc
+
+* **Annotations beyond position**: operator marks "this is the control",
+ "this one is dead, skip", "I think this is in 2-cell stage". These
+ become first-class scientific observations through additional
+ `OPERATOR_*` events.
+* **Satellite tile**: render the live bottom-camera frame as an overlay
+ on the Map at the current stage XY, scaled by um_per_pixel. Inside
+ that tile, click-to-add becomes meaningful (you can see what you're
+ picking). Outside, the Map stays schematic.
+
+---
+
+## 8. Revolutionary Trajectories
+
+Some of these are reasonable extensions; some are genuinely new.
+
+### 8.1 Plans-as-goals, not scripts
+
+Operator specifies "characterise gut development for these four
+embryos." Orchestrator translates this into a continuously adapted
+imaging plan that changes based on what perception sees mid-run. The
+plan isn't a fixed script handed to Bluesky — it's a negotiation the
+orchestrator keeps in flight, with the world model as the substrate
+for adaptation.
+
+Requires: tier-1 + tier-2 world model, decent perception loop, a way
+to express goals as predicates over the world model.
+
+### 8.2 Compounding cross-session learning
+
+`agent/learnings/` already exists. Today it's barely used. With replay
++ shadow, an architecture that proposes priors ("embryos at 3-fold
+typically need slower piezo") becomes **A/B testable across sessions**.
+Improvement gets *measurable*, which is the unlock — most "smart
+microscopy" today is shallow because it has no measurement loop.
+
+The right framing: each session is a **trial**, the orchestrator is the
+**experimenter**, the world model is what carries learning between
+trials.
+
+### 8.3 Collaborative world model
+
+The Map (operator edits embryos) is the first instance. Extend
+everywhere:
+
+* Operator annotates morphology on the Map → orchestrator updates
+ hypothesis space.
+* Operator marks a focus failure → orchestrator marks the calibration
+ region as untrustworthy.
+* Operator confirms a perception → orchestrator increases confidence in
+ the perception predicate for similar inputs.
+
+The point is making the operator's tacit knowledge **first-class data**
+that the system can reason about, not just record.
+
+### 8.4 Reverse-mode microscopy
+
+"I want to know X — plan the imaging that answers X." The orchestrator
+translates scientific goals into imaging plans. This is the
+plans-as-goals idea taken to its conclusion: the operator describes
+intent in scientific terms, the orchestrator owns the imaging strategy.
+
+Tractable only once 8.1 and the goal language are built.
+
+### 8.5 Continuous shadow / always-on critic
+
+Run the production orchestrator + a shadow candidate continuously, and
+log all decision divergences. Over weeks, the divergence log becomes a
+**dataset of disagreements**. Each disagreement is either:
+
+* Production was right, candidate was wrong → candidate needs a fix.
+* Candidate was right, production was wrong → consider promotion or
+ investigate why production picked differently.
+* Both were defensible → annotate the case.
+
+Free with the eval substrate (Phase 6); the only addition is a
+divergence collator.
+
+---
+
+## 9. Concretely Built Today (`paradigm/closed-loop` branch)
+
+| # | Commit | What |
+| --- | --- | --- |
+| 1 | `3e410581` | Schema split: `position_coarse` / `position_fine` / derived `stage_position`. |
+| 2 | `617e54c9` | `ExperimentState.notify_embryos_changed()` observer → `EMBRYOS_UPDATE` broadcast. |
+| 3 | `144d9fc9` | Map render layer — lavender rings (coarse) / discs (fine) / numbers. |
+| 4 | `4fbb9edf` | `detect_embryos` flows through web Marking canvas; `auth.py` + `require_control`. |
+| 5 | `8f6553e1` | Map pick-up / drop / Delete to edit embryos in place (control-gated PUT/DELETE). |
+| 6 | `808fe813` | Side-fix: re-enable XY joystick at device-layer boot. |
+| 7 | `f7a13d69` | Side-fix: image-anchored crosshair + scroll-to-zoom in camera panel. |
+| 8 | `d69cc219` | `gently/eval/`: event capture / replay / shadow / decision log scaffolding. |
+| 9 | `75d7c9db` | Production decision capture wired through `ConversationManager.call_claude`. |
+| 10 | `0a97563e` | `OPERATOR_*` event vocabulary + `ReactiveCandidate` (first real shadow). |
+
+### Per-session disk shape now
+
+`D:\Gently3\sessions\{id}\`
+
+* `events.jsonl` — captured event bus, telemetry-filtered.
+* `decisions.jsonl` — every Claude turn (success + error).
+* `interaction_log.jsonl` — pre-existing chat-shaped interactions.
+* `timeline.jsonl` — pre-existing session timeline.
+* Plus everything from the legacy FileStore layout.
+
+### Eval CLI
+
+`python scripts/replay_session.py {session_id_prefix} [--histogram] [--candidate {name}] [--real-time] [--time-scale N]`
+
+---
+
+## 10. What is *Not* Done Yet
+
+These are the natural follow-ups; sketched as future-self breadcrumbs.
+
+### Near-term (days)
+
+* **Tier-1 world snapshot** as a system-prompt section the brain sees
+ on every wake. Build the snapshot from `agent.experiment` plus the
+ last cached `DEVICE_STATE_UPDATE`. ~30 lines of formatted prose, every
+ wake.
+* **Tier-2 events digest** — hand-written formatter that reads the
+ bus's recent meaningful events (or the captured jsonl tail) and
+ produces a one-paragraph "since last response" note.
+* **Snapshot ingest into the brain's prompt** — `_update_system_prompt`
+ already takes a `context_summary`; route tier-1 + tier-2 through it.
+
+### Medium-term (weeks)
+
+* **Wake-router** — the code-level scheduler from §3. Currently the
+ brain only wakes on user message. Add: event-driven wake (subscribe
+ to wake-worthy events), periodic-tick wake (heartbeat), debounce /
+ coalesce buffer.
+* **More operator events** — `OPERATOR_ANNOTATED_EMBRYO` ("this is the
+ control", "skip, looks dead"), `OPERATOR_STARTED_TIMELAPSE`,
+ `OPERATOR_INTERRUPTED_PLAN`, `OPERATOR_TOGGLED_CAMERA`. Whatever the
+ Map / web UI lets the operator do should publish a typed event.
+* **SPIM-fine alignment workflow** — populate `position_fine`. Tool +
+ per-embryo state transition. Triggers `EMBRYOS_UPDATE` and a new
+ `FINE_ALIGNMENT_COMPLETED` event the orchestrator can react to.
+* **Continuous-shadow harness** — extend `ShadowRunner` to run a
+ candidate alongside production in the live agent process (not just
+ during replay). Collect divergences into a per-session
+ `divergences.jsonl`.
+
+### Longer arc (months)
+
+* **A goal expression language** — predicates over the world model that
+ let the operator say "image until 4-fold" or "follow the cell
+ divisions in embryo 3 at high resolution." This is the substrate for
+ §8.1 (plans-as-goals).
+* **LLM-driven candidates** — once the rule-based `ReactiveCandidate`
+ proves the substrate, add Claude-driven candidates (Haiku for cheap,
+ Opus for thinking). Use the snapshot+digest as their input.
+* **Cross-session learning loop** — wire the `learnings/` store into
+ the world model as priors. Add a learning-write surface (a tool the
+ orchestrator can call when it notices a pattern). Use shadow A/B to
+ validate that learnings improve decisions.
+* **Goal-driven evaluation** — once goals exist, "did the experiment
+ achieve its goal" becomes a measurable end-to-end success rate. The
+ ultimate metric is this, not turn-level decision diffs.
+
+---
+
+## 11. Principles That Surface Throughout
+
+A few recurring design priors worth naming:
+
+1. **Distill, don't dump.** Structured summaries beat raw logs in
+ prompts. Hand-written formatters beat LLM summarisers for
+ structured data. LLMs for prose, code for structure.
+2. **Pull beats push when uncertain.** Default to tools the agent
+ queries on demand, not data shoved into every prompt. Push only
+ what's universally relevant (the world snapshot).
+3. **Same shape for production and shadow.** If production writes a
+ Decision with these fields, shadow candidates write Decisions with
+ the same fields. Diff is then trivial.
+4. **Events carry intent; state carries position.** `EMBRYOS_UPDATE`
+ is state (the embryo list now). `OPERATOR_EDITED_EMBRYO` is intent
+ (a human just did this). Both exist; they answer different
+ questions.
+5. **The brain doesn't move hardware.** All hardware action goes
+ through tools that go through the device layer that goes through
+ ophyd that goes through MMCore. Shadow candidates are constructively
+ prevented from acting. Layers are not negotiable.
+6. **No SaveCardSettings.** Firmware persistent state silently inherits
+ between sessions; if it ever gets out of sync with code it's a
+ debugging nightmare. Apply firmware config every boot, code wins.
+7. **Localhost is the diSPIM box. Remote is view-only by default.**
+ Auth surface stays tiny and explicit. Token upgrade is the seam,
+ not user accounts.
+
+---
+
+## 12. Open Questions (Worth Revisiting Later)
+
+* **Continuous vs episodic shadows.** Continuous always-on shadow
+ captures divergence over time but multiplies cost (multiple LLM
+ candidates running). Episodic shadow at decision moments is cheaper
+ but misses timing-sensitive cases. Hybrid?
+* **Is the conversation history the right substrate at all?** With
+ decision moments hours apart, prior chat may be more distracting
+ than useful. Maybe the brain shouldn't see chat history beyond N
+ hours; the world model + events digest are the durable memory and
+ chat is just for the active dialogue.
+* **How much should the operator know about the orchestrator's plan?**
+ Today the operator drives by asking. With autonomous mode, the
+ orchestrator runs experiments largely on its own. Should there be a
+ permanent "what is the orchestrator thinking right now" surface
+ visible on the Map? An always-on intent display?
+* **Failure semantics.** If a candidate would have made a different
+ decision than production, and production's decision led to a bad
+ outcome, the candidate "wins." How do we score? Define "bad outcome"
+ rigorously enough that it can be measured?
+
+These are not blockers. They are notes for the next iteration of this
+document, after a few weeks of running on the substrate built here.
diff --git a/docs/EVAL.md b/docs/EVAL.md
new file mode 100644
index 00000000..73f35b69
--- /dev/null
+++ b/docs/EVAL.md
@@ -0,0 +1,187 @@
+
+
+> **Status:** design + intended usage for the `gently/eval/` capture/replay substrate and the
+> proposed offline replay harness for testing agentic orchestrator patterns. Grounded in the
+> code as of the 0.22 epoch; the harness itself is a work-in-progress (see the incremental plan).
+
+# Testing agentic orchestrator patterns offline (replay harness)
+
+## Goal
+
+We want to iterate on the agent's design — its realtime reasoning and the wake-router that
+turns developmental events into autonomous turns — **without booking a live microscope run**.
+Concretely: take a recorded session, simulate the microscope conditions from its on-disk
+artifacts (captured events, recorded volumes, recorded perception traces), drive the *real*
+`WakeRouter -> run_wake_turn -> Claude` loop offline, and observe/diff what the agent decides.
+This lets us tune wake triggers, coalescing/throttling, prompt construction, and tool policy on
+a laptop, replayed at a controllable clock (e.g. 10x), instead of waiting hours for embryos to
+develop on a live rig.
+
+## What's already in place (reuse)
+
+A real, tested replay/eval substrate shipped in the 0.22 epoch (`gently/eval/`), plus production
+capture wiring. None of this is hypothetical — it's on disk and runnable today:
+
+- **`gently/eval/event_capture.py`** — `EventCapture` wildcard-subscribes the bus and appends every
+ `Event.to_dict()` to `{session_dir}/events.jsonl`. Auto-wired into **every** live session by
+ `gently/app/agent.py` `_init_event_capture()` (line ~506, called at agent init). Skips only
+ `_NO_HISTORY_TYPES` (`DEVICE_STATE_UPDATE`, `BOTTOM_CAMERA_FRAME`, `LOG_RECORD`); `DETECTOR_EVALUATED`
+ and lifecycle events are **not** skipped.
+- **`gently/eval/event_replay.py`** — `EventReplay(path).replay(target_bus, real_time=, time_scale=, on_event=)`
+ republishes each event via `target.publish_event(ev)`, **preserving the original `Event.timestamp`**
+ (not re-stamping `now()`). `real_time=True` sleeps `(ev.timestamp - prev)/time_scale` between events,
+ so cadence is reproducible. `event_types()` gives a pre-flight histogram.
+- **`gently/eval/shadow.py` + `candidates.py`** — `ShadowRunner` + `OrchestratorCandidate` host
+ sandboxed rule-based candidates (e.g. `ReactiveCandidate`) that may *only* write a `DecisionLog`.
+- **`gently/eval/decision_log.py`** — `Decision`/`DecisionLog` + `prompt_hash()` (sha256[:16] over
+ system prompt + messages) for apples-to-apples A/B diffing.
+- **`scripts/replay_session.py`** — working CLI: resolves a session by id-prefix via
+ `FileStore.list_sessions`, prints `--histogram`, or replays `events.jsonl` into a **fresh** `EventBus()`
+ with an optional `NoOpCandidate`.
+- **Recorded perception inputs/outputs** persist via `FileStore` (`gently/core/file_store.py`):
+ `embryos/{id}/volumes/t{NNNN}.tif` + `.meta.yaml`, `projections/t{NNNN}.jpg`,
+ `predictions.jsonl`, and `traces/t{NNNN}.json` (verbatim `predicted_stage`/`reasoning`/`raw_response`/`stability`).
+ Verified on disk: session `68e7dc33` has 9 embryos, 56 predictions on embryo_001, volume
+ `t0001.tif` shape `[50,512,2048]` uint16.
+- **`timeline.jsonl`** (durable, predates eval) carries 256 `detection/evaluated` records on `68e7dc33`
+ with exactly the fields `WakeRouter._is_wake_worthy` reads (`embryo_id`, `timepoint`,
+ `detector_name`, `stage`, `reasoning`) — a fallback event source for pre-eval-scaffold sessions.
+
+### The one central wiring gap
+
+The real agent subscribes its `WakeRouter` to the **global singleton** bus
+(`gently/app/agent.py:126` `self._event_bus = get_event_bus()`; WakeRouter built with that same bus).
+But `scripts/replay_session.py:124` replays into a **fresh** `EventBus()` that the agent never sees.
+**So today's replay reaches shadow candidates but never the real WakeRouter/agent.** Bridging this —
+either `set_event_bus(replay_bus)` before constructing the agent, or replaying into `get_event_bus()`
+directly — is the core seam to build.
+
+## Approaches, compared
+
+### (A) Event-stream replay into the agent's bus — *recommended first*
+Publish recorded `DETECTOR_EVALUATED` + critical events (`HATCHING_DETECTED`, `EMBRYO_TERMINATED`,
+`ERROR_OCCURRED`, …) onto the bus the agent's `WakeRouter` is subscribed to, on a controllable clock.
+
+- **Reuses:** `EventReplay`, `EventCapture` output, the entire real `WakeRouter` (`_is_wake_worthy`
+ filter at wake_router.py:129, coalesce `COALESCE_WINDOW=20s`, throttle `MIN_WAKE_INTERVAL=120s`,
+ `_flush -> agent.run_wake_turn`).
+- **Fidelity:** Exercises the *real* wake path end-to-end: filtering, transition gate, coalescing,
+ throttling, prompt build, and a real Claude turn (`run_wake_turn -> handle_message_stream`, gated on
+ `agent.mode=='run'`). Highest leverage for the least new code.
+- **Effort:** Medium. Needs (1) the bus bridge above; (2) a running asyncio loop so the async dispatch
+ + `loop.call_later` coalesce timers fire (`EventReplay.replay` is a blocking `time.sleep` loop — run it
+ in a thread or port it to `await asyncio.sleep`, and call `bus.set_event_loop(loop)`); (3) a stub
+ client so any tools the woken agent calls don't hit hardware (autonomous mode already refuses
+ irreversible tools via `_autonomous_active`).
+- **Can't catch:** Anything depending on *fresh* perception of new pixels — the wake note embeds
+ `build_perception_snapshot(agent.perceiver, ...)`, which reads **live** Perceiver state, so this
+ approach needs (B) to make that snapshot reflect the replayed timepoint rather than empty state.
+- **Blocker today:** No recorded session yet contains `DETECTOR_EVALUATED` (verified: all 20 captured
+ `events.jsonl` hold only `STATUS_CHANGED`/`EMBRYO_DETECTED`/`EMBRYOS_UPDATE`). Either capture one fresh
+ perception-driven session, or synthesize `DETECTOR_EVALUATED` events from `traces/`+`timeline.jsonl`.
+
+### (B) Perceiver stub — feed recorded traces
+Replace `agent.perceiver`/`orchestrator.perceiver` with a duck-typed stub whose `__call__(...)` returns
+`.stage`/`.reasoning` from `traces/t{NNNN}.json`, and whose `get_session(embryo_id)` returns an object
+with `.stability`/`.summary()` matching what `build_perception_snapshot` reads
+(`current_stage`/`stability`/`temporal`/`stage_sequence`).
+
+- **Reuses:** All downstream code in `_run_perception` (DETECTOR_EVALUATED emit, trace write,
+ `store_prediction`, `_check_interval_rules`) is pure local code; the Perceiver is the *only* external
+ VLM dependency. `perceiver` is already an optional ctor arg (timelapse.py:71).
+- **Fidelity:** Reproduces recorded perception verbatim — no VLM spend, deterministic. Makes (A)'s wake
+ snapshot reflect the replayed timepoint.
+- **Effort:** Low-medium (one stub class).
+- **Can't catch:** Perception on *new* conditions — it only echoes what the recorded run already saw.
+ Also the stub interface was inferred from call sites (`templates.py` `build_perception_snapshot`,
+ `timelapse.py` `_run_perception`), not from `gently_perception` source — **verify against the
+ installed package** before relying on it.
+
+### (C) Full offline re-feed through the timelapse loop
+Inject a fake `microscope_client` whose `acquire_volume(...)` returns
+`{'success': True, 'volume': diSPIM Room Light
+SwitchBot Bot · __ADDRESS__
+
+ —
+
+
+
+
+
+
+
+
+
+
+ fast
+
+ slow
+ 0.7s
+
+
+
+
+
+ $1');
+ html = html.replace(/\*\*([^*]+)\*\*/g, '$1');
+ html = html.replace(/\*([^*]+)\*/g, '$1');
+ html = html.replace(/\n/g, ''); + return html; + } + + // Pin-to-bottom autoscroll: only follow new content if the user is already + // near the bottom; otherwise count unseen items and show a "↓ N new" pill so + // a streaming agent never yanks the operator away from something they're reading. + let stickBottom = true; + let newCount = 0; + let jumpPill = null; + function nearBottom() { return (log.scrollHeight - log.scrollTop - log.clientHeight) < 60; } + function renderJumpPill() { + if (!jumpPill) return; + if (!stickBottom && newCount > 0) { + jumpPill.textContent = `↓ ${newCount} new`; + jumpPill.classList.remove('hidden'); + } else { + jumpPill.classList.add('hidden'); + } + } + function scrollToBottom(isNewItem = true) { + if (stickBottom) { log.scrollTop = log.scrollHeight; } + // Only count genuinely new items (bubbles/rows), not in-place streaming + // text edits — otherwise the "N new" pill inflates per chunk. + else { if (isNewItem) newCount += 1; renderJumpPill(); } + } + function jumpToBottom() { + stickBottom = true; newCount = 0; + log.scrollTop = log.scrollHeight; + renderJumpPill(); + } + + // ── Activity indicator ──────────────────────────────────── + // A single reusable "the agent is working" row, always pinned to the + // bottom of the log. This is the trust signal — something is happening. + function setActivity(label) { + if (!activityEl) { + activityEl = document.createElement('div'); + activityEl.className = 'ac-activity'; + activityEl.innerHTML = + '' + + ''; + } + activityEl.querySelector('.ac-activity-label').textContent = label; + log.appendChild(activityEl); // (re)pin to bottom + scrollToBottom(); + } + function hideActivity() { + if (activityEl && activityEl.parentNode) activityEl.parentNode.removeChild(activityEl); + } + + // ── Message elements ────────────────────────────────────── + function addTurn(role) { + const wrap = document.createElement('div'); + wrap.className = `ac-turn ac-turn-${role}`; + if (role === 'agent' && autonomousTurn) wrap.classList.add('ac-turn-autonomous'); + if (role === 'agent') { + const label = document.createElement('div'); + label.className = 'ac-role'; + label.textContent = autonomousTurn ? 'Gently · autonomous' : 'Gently'; + wrap.appendChild(label); + } + const content = document.createElement('div'); + content.className = 'ac-content'; + wrap.appendChild(content); + log.appendChild(wrap); + scrollToBottom(); + return content; + } + + function addUserMessage(text, author) { + const wrap = document.createElement('div'); + wrap.className = 'ac-turn ac-turn-user'; + if (author) { + const label = document.createElement('div'); + label.className = 'ac-role ac-role-user'; + label.textContent = author; + wrap.appendChild(label); + } + const content = document.createElement('div'); + content.className = 'ac-content'; + content.textContent = text; + wrap.appendChild(content); + log.appendChild(wrap); + scrollToBottom(); + } + + /** Rebuild the transcript from a persisted/replayed history list. */ + function renderHistory(items) { + log.innerHTML = ''; + currentAgentEl = null; + activityEl = null; + stickBottom = true; newCount = 0; // a full rebuild jumps to latest + (items || []).forEach(it => { + if (it.role === 'user') { + addUserMessage(it.text, it.author); + } else if (it.role === 'agent') { + const c = addTurn('agent'); + c._raw = it.text || ''; + c.innerHTML = mdToHtml(c._raw); + } else if (it.role === 'autonomous_start') { + addAutonomousBanner(it.trigger || ''); + } else if (it.role === 'autonomous') { + autonomousTurn = true; + const c = addTurn('agent'); + c._raw = it.text || ''; + c.innerHTML = mdToHtml(c._raw); + autonomousTurn = false; + } else if (it.role === 'tool') { + const el = document.createElement('div'); + el.className = 'ac-tool ac-tool-done'; + const dur = it.duration ? ` · ${(it.duration.toFixed ? it.duration.toFixed(1) : it.duration)}s` : ''; + const summary = it.summary ? ` — ${escapeHtml(it.summary)}` : ''; + el.innerHTML = `✓${escapeHtml(it.name || 'tool')}`; + log.appendChild(el); + } else if (it.role === 'system') { + addSystemLine(it.text, it.level || 'info'); + } + }); + scrollToBottom(); + } + + /** A divider announcing the agent woke itself, with the trigger reason. */ + function addAutonomousBanner(trigger) { + const el = document.createElement('div'); + el.className = 'ac-autonomous-banner'; + const t = trigger ? `Gently woke up — ${trigger}` : 'Gently woke up'; + el.innerHTML = `${escapeHtml(t)}`; + log.appendChild(el); + scrollToBottom(); + } + + function addSystemLine(text, level = 'info') { + const el = document.createElement('div'); + el.className = `ac-system ac-level-${level}`; + el.textContent = text; + log.appendChild(el); + scrollToBottom(); + } + + // ── Protocol handlers ───────────────────────────────────── + function handle(msg) { + switch (msg.type) { + case 'connected': + reconnectDelay = 1000; + setConn(true, msg.version ? `Connected · v${msg.version}` : 'Connected'); + // The bridge ships the command + tool registries on connect. + // Capture them so the composer can offer autocomplete — the + // data was always on the wire; we just never used it. + commands = Array.isArray(msg.commands) ? msg.commands : []; + tools = Array.isArray(msg.tools) ? msg.tools : []; + break; + + case 'control_status': + hasControl = !!msg.you_have_control; + holderLabel = msg.holder_label || null; + renderControl(); + break; + + case 'history': + renderHistory(msg.items || []); + break; + + case 'user_message': + hideActivity(); + addUserMessage(msg.text, msg.author); + break; + + case 'stream_start': + streaming = true; + currentAgentEl = null; // created lazily on first text + setBusy(true, 'user'); + setActivity('Working…'); + break; + + case 'autonomous_start': + // The agent woke itself — render a distinct banner + label the + // following text as autonomous (no stream_start precedes this). + hideActivity(); + autonomousTurn = true; + currentAgentEl = null; + setBusy(true, 'wake'); + addAutonomousBanner(msg.trigger || ''); + bumpBadge(); + break; + + case 'thinking': + if (streaming) setActivity('Thinking…'); + break; + + case 'text': { + if (!currentAgentEl) { + hideActivity(); + currentAgentEl = addTurn('agent'); + currentAgentEl._raw = ''; + } + currentAgentEl._raw += (msg.text || ''); + currentAgentEl.innerHTML = mdToHtml(currentAgentEl._raw); + scrollToBottom(false); // in-place edit, not a new item + break; + } + + case 'tool_start': { + hideActivity(); // the running tool row is the signal now + currentAgentEl = null; // text after a tool starts a fresh bubble + const label = msg.tool_label || msg.tool_name || 'tool'; + const args = fmtArgs(msg.tool_input); + const el = document.createElement('div'); + el.className = 'ac-tool ac-tool-running'; + el.dataset.tool = msg.tool_name || ''; + el.innerHTML = + `
` +
+ `${escapeHtml(label)}
` +
+ (args ? `${escapeHtml(args)}
` : '');
+ log.appendChild(el);
+ scrollToBottom();
+ break;
+ }
+
+ case 'tool_call': {
+ const running = [...log.querySelectorAll('.ac-tool-running')]
+ .filter(e => e.dataset.tool === (msg.tool_name || ''));
+ const el = running[running.length - 1];
+ const label = msg.tool_name || 'tool';
+ const dur = msg.duration
+ ? ` · ${(msg.duration.toFixed ? msg.duration.toFixed(1) : msg.duration)}s` : '';
+ const args = fmtArgs(msg.tool_input);
+ const summary = msg.result_summary || '';
+ // Show ⚠ instead of ✓ when the tool errored or its result reads
+ // like a failure — so the operator can tell when a tool did nothing.
+ const isErr = !!msg.is_error || looksLikeError(summary);
+ const icon = isErr
+ ? `⚠`
+ : `✓`;
+ const html =
+ `${icon}` +
+ `${escapeHtml(label)}` +
+ `
` +
+ (args ? `${escapeHtml(args)}
` : '') +
+ (summary ? `${escapeHtml(summary)}
` : '');
+ if (el) {
+ el.className = 'ac-tool ac-tool-done' + (isErr ? ' ac-tool-err' : '');
+ el.innerHTML = html;
+ } else {
+ // No matching running row (e.g. after a reconnect) — append fresh.
+ const fresh = document.createElement('div');
+ fresh.className = 'ac-tool ac-tool-done' + (isErr ? ' ac-tool-err' : '');
+ fresh.innerHTML = html;
+ log.appendChild(fresh);
+ }
+ if (streaming) setActivity('Working…'); // agent continues after the tool
+ scrollToBottom();
+ break;
+ }
+
+ case 'choice_request':
+ hideActivity();
+ renderChoice(msg);
+ bumpBadge();
+ break;
+
+ case 'applied_spec':
+ renderSpec(msg.spec || {});
+ break;
+
+ case 'stream_end':
+ streaming = false;
+ currentAgentEl = null;
+ autonomousTurn = false;
+ hideActivity();
+ setBusy(false);
+ break;
+
+ case 'command_result':
+ if (msg.error) addSystemLine(`${msg.command}: ${msg.error}`, 'error');
+ else if (msg.content) addSystemLine(`${msg.command} ✓`, 'info');
+ break;
+
+ case 'notification':
+ addSystemLine(msg.body ? `${msg.title} — ${msg.body}` : msg.title, msg.level || 'info');
+ bumpBadge();
+ break;
+
+ case 'error':
+ streaming = false;
+ hideActivity();
+ setBusy(false);
+ addSystemLine(msg.error || 'Unknown error', 'error');
+ break;
+
+ case 'ping':
+ send({ type: 'pong' });
+ break;
+
+ default:
+ break; // pong / state_update / browse_result / unknown — ignored
+ }
+ }
+
+ function renderChoice(msg) {
+ const data = msg.choice_data || {};
+ const reqId = msg.request_id || data.request_id || '';
+ const isWake = msg.origin === 'wake';
+ const wrap = document.createElement('div');
+ wrap.className = 'ac-choice' + (isWake ? ' ac-choice-wake' : '');
+ if (isWake) {
+ const tag = document.createElement('div');
+ tag.className = 'ac-choice-origin';
+ tag.textContent = 'Autonomy proposal — your approval needed';
+ wrap.appendChild(tag);
+ }
+ const q = document.createElement('div');
+ q.className = 'ac-choice-q';
+ q.innerHTML = mdToHtml(data.question || 'Choose:');
+ wrap.appendChild(q);
+
+ (data.options || []).forEach(opt => {
+ const btn = document.createElement('button');
+ btn.className = 'ac-choice-opt';
+ btn.disabled = !!opt.disabled || !hasControl; // observers see it read-only
+ const desc = opt.description ? `${escapeHtml(opt.description)}` : '';
+ btn.innerHTML = `${escapeHtml(opt.label)}${desc}`;
+ btn.addEventListener('click', () => {
+ send({ type: 'choice_response', request_id: reqId, selected: opt.id });
+ [...wrap.querySelectorAll('button')].forEach(b => b.disabled = true);
+ wrap.classList.add('ac-choice-answered');
+ btn.classList.add('ac-choice-picked');
+ if (streaming) setActivity('Working…');
+ if (isWake && pendingSlot) {
+ setTimeout(() => { pendingSlot.classList.add('hidden'); pendingSlot.innerHTML = ''; }, 700);
+ }
+ });
+ wrap.appendChild(btn);
+ });
+ // ASK approvals pin to the sticky slot above the composer so they can't
+ // scroll out of reach; ordinary choices stay inline in the transcript.
+ if (isWake && pendingSlot) {
+ pendingSlot.innerHTML = '';
+ pendingSlot.appendChild(wrap);
+ pendingSlot.classList.remove('hidden');
+ return;
+ }
+ log.appendChild(wrap);
+ scrollToBottom();
+ }
+
+ function renderSpec(spec) {
+ const rows = [];
+ const add = (k, v) => { if (v !== undefined && v !== null && v !== '') rows.push([k, v]); };
+ add('Strain', spec.strain);
+ add('Temperature', spec.temperature_c != null ? `${spec.temperature_c} °C` : null);
+ add('Slices', spec.num_slices);
+ add('Exposure', spec.exposure_ms != null ? `${spec.exposure_ms} ms` : null);
+ add('Interval', spec.interval_s != null ? `${spec.interval_s} s` : null);
+ add('Stop at', spec.stop_condition);
+ if (!rows.length) return;
+ const el = document.createElement('div');
+ el.className = 'ac-spec';
+ el.innerHTML = 'Imaging spec applied
' +
+ rows.map(([k, v]) => `${escapeHtml(k)}${escapeHtml(v)}
`).join('');
+ log.appendChild(el);
+ scrollToBottom();
+ }
+
+ // ── Tool argument formatting ──────────────────────────────
+ /** Compact, escaped "key=value" rendering of a tool's input for the chat. */
+ function fmtArgs(input) {
+ if (!input || typeof input !== 'object') return '';
+ const parts = [];
+ for (const [k, v] of Object.entries(input)) {
+ if (k === 'context' || v === null || v === undefined || v === '') continue;
+ let val = (typeof v === 'object') ? JSON.stringify(v) : String(v);
+ if (val.length > 48) val = val.slice(0, 47) + '…';
+ parts.push(`${k}=${val}`);
+ }
+ return parts.join(' ');
+ }
+
+ /** Heuristic: does a tool's result summary read like a failure?
+ * Used to show ⚠ for tools that return an error STRING (the agent only
+ * flags raised exceptions). Avoids false alarms like "No errors found". */
+ function looksLikeError(s) {
+ if (!s) return false;
+ const t = s.trim();
+ if (/^no\s+(errors?|issues?|problems?|anomal|changes?|warnings?)\b/i.test(t)) return false;
+ if (/^(error|failed|failure|unable|cannot|can'?t|could\s?n'?t|could not|denied|invalid|no |not )/i.test(t)) return true;
+ // mid-string failure markers, e.g. "Timepoint 7 not found for embryo_2".
+ return /\bnot (found|available|connected|recognized|valid|supported)\b/i.test(t);
+ }
+
+ // ── Autocomplete ──────────────────────────────────────────
+ /** The whitespace-delimited token immediately left of the caret. */
+ function currentToken() {
+ const v = input.value;
+ const pos = (input.selectionStart != null) ? input.selectionStart : v.length;
+ const before = v.slice(0, pos);
+ const m = before.match(/(\S+)$/);
+ return { token: m ? m[1] : '', start: m ? pos - m[1].length : pos, pos };
+ }
+
+ /** Compute completion items for the current input/caret, or []. */
+ function computeCompletions() {
+ const trimmed = input.value.trimStart().toLowerCase();
+ // Slash commands: whole-input prefix (mirrors the TUI). A trailing space
+ // (i.e. typing args) naturally yields no matches and hides the menu.
+ if (trimmed.startsWith('/')) {
+ return commands.filter(c =>
+ (c.name && c.name.toLowerCase().startsWith(trimmed)) ||
+ (c.aliases || []).some(a => String(a).toLowerCase().startsWith(trimmed))
+ ).slice(0, 8).map(c => ({ kind: 'command', name: c.name, desc: c.description || '' }));
+ }
+ // @tool mention: complete the token under the caret against tool names.
+ const tok = currentToken();
+ if (tok.token.startsWith('@') && tools.length) {
+ const q = tok.token.slice(1).toLowerCase();
+ return tools.filter(t => t.name.toLowerCase().includes(q))
+ .slice(0, 8)
+ .map(t => ({ kind: 'tool', name: t.name, desc: t.description || '', token: tok }));
+ }
+ return [];
+ }
+
+ function renderCompletions(items) {
+ acItems = items || [];
+ acIdx = acItems.length ? 0 : -1;
+ if (!acComplete) return;
+ if (!acItems.length) { hideCompletions(); return; }
+ acComplete.innerHTML = '';
+ acItems.forEach((it, i) => {
+ const row = document.createElement('div');
+ row.className = 'ac-complete-item' + (i === acIdx ? ' active' : '');
+ row.innerHTML =
+ `${escapeHtml(it.name)}` +
+ (it.desc ? `${escapeHtml(it.desc)}` : '');
+ // mousedown (not click) so it fires before the textarea blurs.
+ row.addEventListener('mousedown', (e) => { e.preventDefault(); acceptCompletion(it); });
+ acComplete.appendChild(row);
+ });
+ acComplete.classList.remove('hidden');
+ }
+
+ function hideCompletions() {
+ acItems = [];
+ acIdx = -1;
+ if (acComplete) { acComplete.classList.add('hidden'); acComplete.innerHTML = ''; }
+ }
+
+ function updateCompletions() {
+ renderCompletions(computeCompletions());
+ }
+
+ function moveCompletion(delta) {
+ if (!acItems.length || !acComplete) return;
+ acIdx = (acIdx + delta + acItems.length) % acItems.length;
+ [...acComplete.children].forEach((c, i) => c.classList.toggle('active', i === acIdx));
+ }
+
+ function acceptCompletion(item) {
+ if (!item) return;
+ if (item.kind === 'command') {
+ input.value = item.name + ' ';
+ const p = input.value.length;
+ try { input.setSelectionRange(p, p); } catch (_) {}
+ } else if (item.kind === 'tool') {
+ const tok = item.token || currentToken();
+ const v = input.value;
+ const insert = '@' + item.name + ' ';
+ input.value = v.slice(0, tok.start) + insert + v.slice(tok.pos);
+ const p = tok.start + insert.length;
+ try { input.setSelectionRange(p, p); } catch (_) {}
+ }
+ hideCompletions();
+ input.focus();
+ autosize();
+ }
+
+ // ── Control / UI state ────────────────────────────────────
+ function renderControl() {
+ if (hasControl) {
+ banner.classList.add('hidden');
+ banner.innerHTML = '';
+ input.disabled = false;
+ sendBtn.disabled = false;
+ input.placeholder = 'Message Gently… ( / commands · @ tools )';
+ } else {
+ banner.classList.remove('hidden');
+ const who = holderLabel || 'another session';
+ input.disabled = true;
+ sendBtn.disabled = true;
+ if (me && me.accounts && !me.authenticated) {
+ // Anonymous — viewing is open; sign in to control.
+ banner.innerHTML = `Viewing — sign in to control.`;
+ const btn = document.createElement('button');
+ btn.className = 'ac-take-control';
+ btn.textContent = 'Sign in';
+ btn.addEventListener('click', () => { window.location.href = '/login'; });
+ banner.appendChild(btn);
+ input.placeholder = 'Viewing — sign in to control…';
+ } else if (me && me.authenticated && me.can_control === false) {
+ // Viewer-role account — watching is all this account can do.
+ banner.innerHTML = `View-only access — you can watch but not control.`;
+ input.placeholder = 'View-only access';
+ } else {
+ banner.innerHTML = `Control held by ${escapeHtml(who)}`;
+ const btn = document.createElement('button');
+ btn.className = 'ac-take-control';
+ btn.textContent = 'Take control';
+ btn.addEventListener('click', () => send({ type: 'take_control' }));
+ banner.appendChild(btn);
+ input.placeholder = 'Viewing only — take control to drive…';
+ }
+ }
+ }
+
+ function setBusy(busy, source) {
+ agentBusy = !!busy;
+ busySource = agentBusy ? (source || 'user') : null;
+ // Send no longer doubles as Stop — it queues while busy. A separate Stop
+ // (shown only for a cancellable user turn) aborts the current turn.
+ if (stopBtn) stopBtn.classList.toggle('hidden', !(agentBusy && busySource === 'user'));
+ sendBtn.classList.toggle('ac-busy', agentBusy);
+ if (agentBusy) {
+ input.placeholder = (busySource === 'wake')
+ ? 'Gently is acting autonomously — your message will queue'
+ : 'Gently is working — your message will queue';
+ } else {
+ if (hasControl) input.placeholder = 'Message Gently… ( / commands · @ tools )';
+ drainQueue(); // a turn just ended — send the next queued message
+ }
+ }
+
+ // ── Message queue (type-while-busy) ───────────────────────
+ function enqueue(text) { msgQueue.push(text); renderQueue(); }
+ function removeQueued(i) {
+ if (i >= 0 && i < msgQueue.length) { msgQueue.splice(i, 1); renderQueue(); }
+ }
+ function clearQueue() { msgQueue = []; renderQueue(); }
+ function drainQueue() {
+ if (agentBusy || !msgQueue.length) return;
+ if (!ws || ws.readyState !== WebSocket.OPEN) return; // keep queued until reconnect
+ const next = msgQueue.shift();
+ renderQueue();
+ actuallySend(next);
+ }
+ function renderQueue() {
+ if (!queuePanel) return;
+ if (!msgQueue.length) { queuePanel.classList.add('hidden'); queuePanel.innerHTML = ''; return; }
+ queuePanel.classList.remove('hidden');
+ queuePanel.innerHTML = '';
+ const head = document.createElement('div');
+ head.className = 'ac-queue-head';
+ const lbl = document.createElement('span');
+ lbl.textContent = `⏳ Queued (${msgQueue.length})`;
+ const clear = document.createElement('button');
+ clear.className = 'ac-queue-clear';
+ clear.textContent = 'Clear all';
+ clear.addEventListener('click', clearQueue);
+ head.appendChild(lbl);
+ head.appendChild(clear);
+ queuePanel.appendChild(head);
+ msgQueue.forEach((m, i) => {
+ const row = document.createElement('div');
+ row.className = 'ac-queue-item';
+ const span = document.createElement('span');
+ span.className = 'ac-queue-text';
+ span.textContent = m;
+ const x = document.createElement('button');
+ x.className = 'ac-queue-remove';
+ x.textContent = '✕';
+ x.title = 'Remove from queue';
+ x.addEventListener('click', () => removeQueued(i));
+ row.appendChild(span);
+ row.appendChild(x);
+ queuePanel.appendChild(row);
+ });
+ }
+
+ function setConn(ok, label) {
+ conn.classList.toggle('ac-conn-ok', ok);
+ conn.classList.toggle('ac-conn-bad', !ok);
+ conn.textContent = label || (ok ? 'Connected' : 'Reconnecting…');
+ if (toggleDot) toggleDot.classList.toggle('ok', ok);
+ }
+
+ // ── Transport ─────────────────────────────────────────────
+ function send(obj) {
+ if (ws && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(obj));
+ }
+
+ function connect() {
+ const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+ setConn(false, 'Connecting…');
+ ws = new WebSocket(`${proto}//${location.host}/ws/agent`);
+ ws.onopen = () => { reconnectDelay = 1000; setConn(true); };
+ ws.onclose = () => {
+ setConn(false, 'Reconnecting…');
+ setBusy(false);
+ streaming = false;
+ hideActivity();
+ setTimeout(connect, reconnectDelay);
+ reconnectDelay = Math.min(reconnectDelay * 2, MAX_DELAY);
+ };
+ ws.onerror = () => {};
+ ws.onmessage = (e) => {
+ let msg;
+ try { msg = JSON.parse(e.data); } catch { return; }
+ handle(msg);
+ };
+ }
+
+ // ── Input handling ────────────────────────────────────────
+ function actuallySend(text) {
+ if (text.startsWith('/')) {
+ addUserMessage(text); // commands aren't broadcast; echo locally
+ send({ type: 'command', command: text }); // slash commands (e.g. /status)
+ // Most commands reply with a single 'command_result' and no stream —
+ // do NOT mark the composer busy, or the queue would stick forever.
+ // Commands that DO stream (e.g. /wizard) set busy via stream_start.
+ return;
+ }
+ send({ type: 'chat', text }); // echoed to all via 'user_message'
+ // Instant feedback before the first chunk arrives.
+ setBusy(true, 'user');
+ setActivity('Working…');
+ }
+
+ function submit() {
+ hideCompletions();
+ const text = input.value.trim();
+ if (!text) return;
+ if (!hasControl) { renderControl(); return; }
+ input.value = '';
+ autosize();
+ // While the agent is busy (a user OR autonomous turn), queue instead of
+ // cancelling — Send no longer doubles as Stop.
+ if (agentBusy) { enqueue(text); return; }
+ actuallySend(text);
+ }
+
+ function autosize() {
+ input.style.height = 'auto';
+ input.style.height = Math.min(input.scrollHeight, 140) + 'px';
+ }
+
+ function togglePanel(open) {
+ panelOpen = (open === undefined) ? !panelOpen : open;
+ panel.classList.toggle('open', panelOpen);
+ if (toggleBtn) {
+ toggleBtn.setAttribute('aria-pressed', panelOpen ? 'true' : 'false');
+ toggleBtn.setAttribute('aria-expanded', panelOpen ? 'true' : 'false');
+ }
+ if (panelOpen) {
+ clearBadge();
+ if (!ws) connect();
+ // Re-pin to the latest content (it may have streamed while closed,
+ // where scroll events don't fire to keep stickBottom current).
+ setTimeout(() => { input.focus(); jumpToBottom(); }, 50);
+ }
+ // Opening/closing while docked reflows .app-main — tell viewers to resize.
+ if (document.body.classList.contains('chat-docked')) emitLayoutChanged();
+ }
+
+ // ── Layout: dock, resize, persistence ─────────────────────
+ const CHAT_MIN_W = 320;
+ const CHAT_DEFAULT_W = 460;
+ // Roomy ceiling: the panel shows agent reasoning, tool calls, approvals and
+ // pickers — content that wraps badly in a narrow column — so allow up to
+ // ~half the viewport (was min(560, 45vw), which capped power users too low).
+ function chatMaxW() { return Math.min(760, Math.round(window.innerWidth * 0.60)); }
+
+ function emitLayoutChanged() {
+ // Let the CSS settle, then notify viewers (e.g. the 3D canvas) to resize.
+ requestAnimationFrame(() => window.dispatchEvent(new CustomEvent('gently:layout-changed')));
+ }
+
+ function curChatWidth() {
+ return parseInt(getComputedStyle(document.documentElement).getPropertyValue('--chat-w')) || CHAT_DEFAULT_W;
+ }
+
+ function setChatWidth(px, persist) {
+ const w = Math.max(CHAT_MIN_W, Math.min(chatMaxW(), Math.round(px)));
+ document.documentElement.style.setProperty('--chat-w', w + 'px');
+ if (persist) { try { localStorage.setItem('gently-chat-w', String(w)); } catch (_) {} }
+ return w;
+ }
+
+ function applyDock(docked, persist) {
+ document.body.classList.toggle('chat-docked', docked);
+ if (pinBtn) {
+ pinBtn.setAttribute('aria-pressed', docked ? 'true' : 'false');
+ pinBtn.title = docked ? 'Unpin (float over content)' : 'Pin to dock';
+ }
+ if (persist) { try { localStorage.setItem('gently-chat-docked', docked ? '1' : '0'); } catch (_) {} }
+ // Suppress the slide animation across the mode flip, then notify viewers.
+ panel.style.transition = 'none';
+ requestAnimationFrame(() => { panel.style.transition = ''; emitLayoutChanged(); });
+ }
+
+ function togglePin() {
+ const docked = !document.body.classList.contains('chat-docked');
+ if (docked && !panelOpen) togglePanel(true); // pinning implies showing
+ applyDock(docked, true);
+ }
+
+ function setupResize() {
+ if (!resizeEl) return;
+ let startX = 0, startW = 0, dragging = false, rafId = 0, pid = null;
+ const onMove = (e) => {
+ if (!dragging) return;
+ setChatWidth(startW + (startX - e.clientX), false); // right panel: drag left = wider
+ if (document.body.classList.contains('chat-docked')) {
+ if (rafId) cancelAnimationFrame(rafId);
+ rafId = requestAnimationFrame(emitLayoutChanged); // coalesce dock reflow
+ }
+ };
+ const onUp = () => {
+ if (!dragging) return;
+ dragging = false;
+ resizeEl.classList.remove('dragging');
+ resizeEl.removeEventListener('pointermove', onMove);
+ resizeEl.removeEventListener('pointerup', onUp);
+ resizeEl.removeEventListener('pointercancel', onUp);
+ if (pid !== null && resizeEl.hasPointerCapture && resizeEl.hasPointerCapture(pid)) {
+ try { resizeEl.releasePointerCapture(pid); } catch (_) {}
+ }
+ pid = null;
+ document.body.style.userSelect = '';
+ setChatWidth(curChatWidth(), true);
+ emitLayoutChanged();
+ };
+ resizeEl.addEventListener('pointerdown', (e) => {
+ if (e.button !== 0) return; // primary button only
+ e.preventDefault();
+ dragging = true;
+ startX = e.clientX;
+ startW = curChatWidth();
+ pid = e.pointerId;
+ // Capture so move/up/cancel always reach the handle (touch/pen-safe).
+ try { resizeEl.setPointerCapture(pid); } catch (_) {}
+ resizeEl.classList.add('dragging');
+ document.body.style.userSelect = 'none';
+ resizeEl.addEventListener('pointermove', onMove);
+ resizeEl.addEventListener('pointerup', onUp);
+ resizeEl.addEventListener('pointercancel', onUp);
+ });
+ resizeEl.addEventListener('dblclick', () => { setChatWidth(CHAT_DEFAULT_W, true); emitLayoutChanged(); });
+ }
+
+ function restorePrefs() {
+ try {
+ const w = parseInt(localStorage.getItem('gently-chat-w'));
+ if (w) setChatWidth(w, false);
+ if (localStorage.getItem('gently-chat-docked') === '1') applyDock(true, false);
+ } catch (_) {}
+ }
+
+ // Unseen-activity badge on the header toggle — so a closed panel still tells
+ // the operator the agent did something (woke, proposed an approval, notified).
+ let badgeCount = 0;
+ function bumpBadge() {
+ if (panelOpen) return; // they're watching; no badge needed
+ badgeCount += 1;
+ if (toggleBadge) {
+ toggleBadge.textContent = badgeCount > 9 ? '9+' : String(badgeCount);
+ toggleBadge.classList.remove('hidden');
+ }
+ }
+ function clearBadge() {
+ badgeCount = 0;
+ if (toggleBadge) { toggleBadge.classList.add('hidden'); toggleBadge.textContent = ''; }
+ }
+
+ // ── Identity ──────────────────────────────────────────────
+ function fetchMe() {
+ fetch('/api/auth/me').then(r => r.json()).then(m => {
+ me = m;
+ if (m && m.authenticated) {
+ userEl.textContent = m.username;
+ userEl.title = `Signed in as ${m.username} (${m.role})`;
+ signoutBtn.textContent = 'Sign out';
+ signoutBtn.dataset.action = 'logout';
+ signoutBtn.style.display = '';
+ } else if (m && m.accounts) {
+ // Anonymous — viewing is open; sign in to gain control.
+ userEl.textContent = 'viewing';
+ userEl.title = 'Not signed in — view-only';
+ signoutBtn.textContent = 'Sign in';
+ signoutBtn.dataset.action = 'login';
+ signoutBtn.style.display = '';
+ } else {
+ // No accounts configured (legacy mode).
+ userEl.textContent = '';
+ signoutBtn.style.display = 'none';
+ }
+ renderControl();
+ }).catch(() => {});
+ }
+
+ // ── Init ──────────────────────────────────────────────────
+ function init() {
+ panel = document.getElementById('agent-chat');
+ log = document.getElementById('agent-chat-log');
+ input = document.getElementById('agent-chat-text');
+ sendBtn = document.getElementById('agent-chat-send');
+ conn = document.getElementById('agent-chat-conn');
+ banner = document.getElementById('agent-control-banner');
+ closeBtn = document.getElementById('agent-chat-close');
+ userEl = document.getElementById('agent-chat-user');
+ signoutBtn = document.getElementById('agent-chat-signout');
+ toggleBtn = document.getElementById('agent-chat-toggle');
+ pinBtn = document.getElementById('agent-chat-pin');
+ resizeEl = document.getElementById('agent-chat-resize');
+ toggleDot = document.getElementById('agent-chat-toggle-dot');
+ toggleBadge = document.getElementById('agent-chat-toggle-badge');
+ if (!panel) return; // markup not present
+
+ restorePrefs();
+ if (toggleBtn) toggleBtn.addEventListener('click', () => togglePanel());
+ closeBtn.addEventListener('click', () => togglePanel(false));
+ if (pinBtn) pinBtn.addEventListener('click', togglePin);
+ setupResize();
+ // Ctrl/Cmd+J toggles the panel from anywhere.
+ document.addEventListener('keydown', (e) => {
+ if ((e.ctrlKey || e.metaKey) && (e.key === 'j' || e.key === 'J')) {
+ e.preventDefault(); // suppress browser default (downloads) always
+ if (e.repeat) return; // ignore held-key auto-repeat
+ if (document.activeElement === input) return; // don't toggle while composing
+ togglePanel();
+ }
+ });
+ signoutBtn.addEventListener('click', async () => {
+ if (signoutBtn.dataset.action === 'login') {
+ window.location.href = '/login';
+ return;
+ }
+ try { await fetch('/api/auth/logout', { method: 'POST' }); } catch (_) {}
+ window.location.reload();
+ });
+ fetchMe();
+
+ // Build the autocomplete dropdown inside the composer (positioned above
+ // the textarea via CSS).
+ const inputWrap = input.parentNode;
+ if (inputWrap) {
+ acComplete = document.createElement('div');
+ acComplete.className = 'ac-complete hidden';
+ inputWrap.insertBefore(acComplete, inputWrap.firstChild);
+
+ // Queued-message panel (above the composer) for type-while-busy.
+ queuePanel = document.createElement('div');
+ queuePanel.className = 'ac-queue hidden';
+ if (inputWrap.parentNode) inputWrap.parentNode.insertBefore(queuePanel, inputWrap);
+
+ // Explicit Stop button — shown only during a cancellable user turn.
+ stopBtn = document.createElement('button');
+ stopBtn.className = 'ac-stop hidden';
+ stopBtn.textContent = 'Stop';
+ stopBtn.title = 'Stop the current turn';
+ stopBtn.addEventListener('click', () => { send({ type: 'cancel' }); setBusy(false); });
+ inputWrap.appendChild(stopBtn);
+
+ // Sticky ASK-approval slot — above the queue + composer, never scrolls away.
+ pendingSlot = document.createElement('div');
+ pendingSlot.className = 'ac-pending hidden';
+ if (inputWrap.parentNode) inputWrap.parentNode.insertBefore(pendingSlot, queuePanel);
+ }
+
+ // "↓ N new" jump pill + pin-to-bottom scroll tracking.
+ jumpPill = document.createElement('button');
+ jumpPill.className = 'ac-jump hidden';
+ jumpPill.addEventListener('click', jumpToBottom);
+ panel.appendChild(jumpPill);
+ log.addEventListener('scroll', () => {
+ stickBottom = nearBottom();
+ if (stickBottom) newCount = 0;
+ renderJumpPill();
+ });
+
+ sendBtn.addEventListener('click', submit);
+ input.addEventListener('input', () => { autosize(); updateCompletions(); });
+ // Close the menu shortly after blur (delay lets a mousedown selection land).
+ input.addEventListener('blur', () => setTimeout(hideCompletions, 120));
+ input.addEventListener('keydown', (e) => {
+ // While the completion menu is open it owns the navigation keys.
+ if (acItems.length) {
+ if (e.key === 'ArrowDown') { e.preventDefault(); moveCompletion(1); return; }
+ if (e.key === 'ArrowUp') { e.preventDefault(); moveCompletion(-1); return; }
+ if (e.key === 'Tab') { e.preventDefault(); acceptCompletion(acItems[acIdx]); return; }
+ if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); acceptCompletion(acItems[acIdx]); return; }
+ if (e.key === 'Escape') { e.preventDefault(); hideCompletions(); return; }
+ }
+ if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); submit(); }
+ // Escape mirrors Stop: cancel a cancellable (user) turn and clear busy
+ // (a cancelled turn emits no stream_end, so clear optimistically).
+ if (e.key === 'Escape' && agentBusy && busySource === 'user') {
+ e.preventDefault(); send({ type: 'cancel' }); setBusy(false);
+ }
+ });
+ }
+
+ document.addEventListener('DOMContentLoaded', init);
+
+ // Public: programmatically send a message/command (e.g. the Home page's
+ // "Start / continue an experiment" button sends '/wizard').
+ function runCommand(text) {
+ if (!text) return;
+ if (!hasControl) { renderControl(); return; }
+ actuallySend(text);
+ }
+
+ return { togglePanel, runCommand };
+})();
diff --git a/gently/ui/web/static/js/app.js b/gently/ui/web/static/js/app.js
index 203cea04..d1e75a72 100644
--- a/gently/ui/web/static/js/app.js
+++ b/gently/ui/web/static/js/app.js
@@ -6,7 +6,7 @@
const state = {
ws: null,
connected: false,
- tab: TABS.EMBRYOS, // Default to Embryos tab
+ tab: TABS.HOME, // Default to the Home landing tab
snapshots: [],
calibration: [],
embryos: [],
@@ -71,6 +71,9 @@ function switchTab(tabName) {
const content = document.getElementById(`${tabName}-content`);
if (content) content.classList.add('active');
+ // Lazy-init Home landing tab
+ if (tabName === TABS.HOME && typeof HomeApp !== 'undefined') HomeApp.init();
+
// Render galleries
if (tabName === TABS.CALIBRATION) renderCalibrationGallery();
if (tabName === TABS.EVENTS) renderEventsTable();
@@ -631,7 +634,7 @@ document.addEventListener('DOMContentLoaded', () => {
const hash = window.location.hash.slice(1); // remove #
if (hash) {
const [tab, param] = hash.split(':');
- if (tab === TABS.PLANS || tab === TABS.SESSIONS || tab === TABS.EMBRYOS || tab === TABS.CALIBRATION || tab === TABS.EVENTS || tab === TABS.EXPERIMENT) {
+ if (tab === TABS.HOME || tab === TABS.PLANS || tab === TABS.SESSIONS || tab === TABS.EMBRYOS || tab === TABS.CALIBRATION || tab === TABS.EVENTS || tab === TABS.EXPERIMENT) {
switchTab(tab);
if (tab === TABS.PLANS && param && typeof openCampaign === 'function') {
setTimeout(() => openCampaign(param), 200);
diff --git a/gently/ui/web/static/js/devices.js b/gently/ui/web/static/js/devices.js
index 0f2f5316..caa1bf48 100644
--- a/gently/ui/web/static/js/devices.js
+++ b/gently/ui/web/static/js/devices.js
@@ -32,11 +32,14 @@ const DevicesManager = (function () {
let _mapWrap;
let _scalebarLabel;
- // Embryos overlay state: list of {embryo_id, x, y, role, ...}.
- // Populated by /api/embryos/positions on init + EMBRYO_DETECTED /
- // STATUS_CHANGED WS pushes thereafter. Roles drive the marker color
+ // Embryo waypoints — driven by EMBRYOS_UPDATE events (the canonical bulk
+ // mutation broadcast added by the embryos-broadcast commit) and the
+ // initial /api/embryos/current snapshot. Each entry mirrors
+ // EmbryoState.to_dict() (id, position_coarse, position_fine,
+ // has_fine_position, nickname, role, ...). Role drives marker color
// (mirrors the marking-window legend: magenta=test, cyan=calibration,
- // grey=unassigned).
+ // grey=unassigned). EMBRYO_DETECTED / STATUS_CHANGED listeners stay
+ // hooked as a belt-and-braces refresh path.
let _embryos = [];
const _ROLE_COLOR = {
test: '#ff66cc',
@@ -44,8 +47,14 @@ const DevicesManager = (function () {
unassigned: '#888888',
};
+ // Map-side edit state. _selectedEmbryoId means "picked up": the next
+ // click on empty map space drops it there (with a confirm), Delete /
+ // Backspace removes it (with a confirm), Escape clears the selection.
+ let _selectedEmbryoId = null;
+
// Bottom-camera panel DOM + state
let _camPanel, _camToggle, _camImg, _camPlaceholder, _camLed, _camMeta;
+ let _camStage, _camCrosshair, _camCrosshairGroup;
let _camStreaming = false;
let _camLastFrameTs = 0;
let _camHasFrame = false;
@@ -53,6 +62,32 @@ const DevicesManager = (function () {
const _CAM_FPS_WINDOW = 12;
let _camFrameTimes = [];
+ // Camera zoom / pan. Identity transform = (zoom 1, tx 0, ty 0); pan only
+ // engages once zoom > 1. Reset on double-click and on stream-off.
+ let _camZoom = 1;
+ let _camTx = 0;
+ let _camTy = 0;
+ let _camPanLast = null; // {x, y} clientX/Y of last pointermove during pan
+ const _CAM_ZOOM_MIN = 1;
+ const _CAM_ZOOM_MAX = 8;
+ const _CAM_ZOOM_STEP = 1.15; // multiplicative per wheel notch
+
+ // Room-light toggle (header). Drives the SwitchBot Bot that switches the
+ // diSPIM room light. State is the bot's cached on/off; hidden until the
+ // device layer reports the accessory is configured.
+ let _roomLightToggle, _roomLightLabel;
+ let _roomLightState = 'unknown';
+ let _roomLightAvailable = false;
+ let _roomLightBusy = false;
+ let _roomLightTimer = null;
+
+ // Temperature-controller panel DOM + state
+ let _tempEl, _tempReadout, _tempInput, _tempSet;
+ let _tempState = 'unknown';
+ let _tempAvailable = false;
+ let _tempBusy = false;
+ let _tempTimer = null;
+
let _lastTs = 0;
let _previousTs = 0;
let _lastWallTs = 0;
@@ -110,9 +145,20 @@ const DevicesManager = (function () {
_camToggle = document.getElementById('devices-camera-toggle');
_camImg = document.getElementById('devices-camera-img');
_camPlaceholder = document.getElementById('devices-camera-placeholder');
+ _camStage = _camPanel ? _camPanel.querySelector('.devices-camera-stage') : null;
+ _camCrosshair = document.getElementById('devices-camera-crosshair');
+ _camCrosshairGroup = document.getElementById('devices-camera-crosshair-group');
_camLed = document.getElementById('devices-camera-led');
_camMeta = document.getElementById('devices-camera-meta');
+ _roomLightToggle = document.getElementById('devices-room-light-toggle');
+ _roomLightLabel = document.getElementById('devices-room-light-label');
+
+ _tempEl = document.getElementById('devices-temp');
+ _tempReadout = document.getElementById('devices-temp-readout');
+ _tempInput = document.getElementById('devices-temp-input');
+ _tempSet = document.getElementById('devices-temp-set');
+
// Recompute the scale bar caption whenever the canvas resizes.
if (_mapSvg && window.ResizeObserver) {
new ResizeObserver(() => updateScalebar()).observe(_mapSvg);
@@ -257,6 +303,30 @@ const DevicesManager = (function () {
}
}
+ // Initial embryo snapshot — closes the gap for clients that connect
+ // mid-session, after the last EMBRYOS_UPDATE has already been broadcast
+ // and aged out of history. Subsequent updates arrive over the event bus.
+ async function loadEmbryosSnapshot() {
+ try {
+ const res = await fetch('/api/embryos/current');
+ if (!res.ok) return;
+ const data = await res.json();
+ handleEmbryosUpdate(data);
+ } catch (err) {
+ console.debug('embryos snapshot fetch failed:', err);
+ }
+ }
+
+ function handleEmbryosUpdate(payload) {
+ _embryos = (payload && Array.isArray(payload.embryos)) ? payload.embryos : [];
+ if (!_viewBox) {
+ computeViewBox();
+ renderMap();
+ } else {
+ renderEmbryos();
+ }
+ }
+
// =====================================================================
// Properties table (Details view)
// =====================================================================
@@ -744,6 +814,215 @@ const DevicesManager = (function () {
return Math.round(v).toString();
}
+ // =====================================================================
+ // Embryo waypoints
+ // =====================================================================
+
+ // "embryo_007" / "embryo_7" -> 7. Falls back to a 1-based index from the
+ // caller so the label always shows *something*, even for stray ids.
+ function embryoLabelText(id, fallbackIndex) {
+ const m = id && String(id).match(/(\d+)/);
+ if (m) {
+ const n = parseInt(m[1], 10);
+ if (Number.isFinite(n)) return String(n);
+ }
+ return String(fallbackIndex + 1);
+ }
+
+ // Resolve XY for rendering — fine if SPIM-aligned, else coarse. Returns
+ // null when neither stage carries usable values so the entry is skipped
+ // (e.g. an embryo whose detection record came in malformed).
+ function embryoResolvedXY(emb) {
+ const f = emb && emb.position_fine;
+ if (f && Number.isFinite(f.x) && Number.isFinite(f.y)) return { x: f.x, y: f.y };
+ const c = emb && emb.position_coarse;
+ if (c && Number.isFinite(c.x) && Number.isFinite(c.y)) return { x: c.x, y: c.y };
+ return null;
+ }
+
+ function renderEmbryos() {
+ if (!_mapEmbryos || !_viewBox) return;
+ _mapEmbryos.innerHTML = '';
+ if (!_embryos || !_embryos.length) return;
+ const span = Math.max(_viewBox.xMax - _viewBox.xMin,
+ _viewBox.yMax - _viewBox.yMin);
+ const radius = span * 0.012;
+ const fontSize = span * 0.015;
+
+ _embryos.forEach((emb, i) => {
+ const xy = embryoResolvedXY(emb);
+ if (!xy) return;
+
+ const isFine = !!emb.has_fine_position;
+ const isSelected = _selectedEmbryoId !== null
+ && emb.id === _selectedEmbryoId;
+
+ // Wrap circle + label in a group so a single closest() lookup
+ // finds the embryo regardless of which child the click hit.
+ const group = document.createElementNS(SVG_NS, 'g');
+ group.setAttribute('class',
+ 'devices-embryo-group' + (isSelected ? ' devices-embryo-selected' : ''));
+ group.setAttribute('data-embryo-id', emb.id || '');
+ group.setAttribute('data-embryo-stage', isFine ? 'fine' : 'coarse');
+
+ const circle = document.createElementNS(SVG_NS, 'circle');
+ circle.setAttribute('cx', xy.x);
+ circle.setAttribute('cy', svgY(xy.y));
+ circle.setAttribute('r', radius);
+ circle.setAttribute('class',
+ isFine ? 'devices-embryo-disc' : 'devices-embryo-ring');
+ group.appendChild(circle);
+
+ const label = document.createElementNS(SVG_NS, 'text');
+ label.setAttribute('x', xy.x);
+ label.setAttribute('y', svgY(xy.y));
+ label.setAttribute('class', 'devices-embryo-label');
+ label.setAttribute('font-size', fontSize);
+ label.textContent = embryoLabelText(emb.id, i);
+ group.appendChild(label);
+
+ _mapEmbryos.appendChild(group);
+ });
+ }
+
+ // ---- Map-side edit interactions ------------------------------------
+ // Convert a pointer event's client coords into stage µm. SVG y axis is
+ // positive-down and stage y is positive-up, so the y component is
+ // negated to match the convention used elsewhere in this module.
+ function eventToStageXY(event) {
+ if (!_mapSvg || !_mapSvg.getScreenCTM) return null;
+ const ctm = _mapSvg.getScreenCTM();
+ if (!ctm) return null;
+ const pt = _mapSvg.createSVGPoint();
+ pt.x = event.clientX;
+ pt.y = event.clientY;
+ const local = pt.matrixTransform(ctm.inverse());
+ return { x: local.x, y: -local.y };
+ }
+
+ function findEmbryoIdAt(target) {
+ if (!target) return null;
+ const node = target.closest && target.closest('[data-embryo-id]');
+ return node ? node.getAttribute('data-embryo-id') : null;
+ }
+
+ function embryoById(id) {
+ return _embryos.find(e => e.id === id) || null;
+ }
+
+ function embryoNumberFor(emb) {
+ return embryoLabelText(emb.id, _embryos.indexOf(emb));
+ }
+
+ function setSelectedEmbryo(id) {
+ if (_selectedEmbryoId === id) return;
+ _selectedEmbryoId = id;
+ renderEmbryos();
+ }
+
+ function clearSelection() {
+ if (_selectedEmbryoId === null) return;
+ _selectedEmbryoId = null;
+ renderEmbryos();
+ }
+
+ async function attemptMoveSelected(targetStage) {
+ const id = _selectedEmbryoId;
+ if (!id) return;
+ const emb = embryoById(id);
+ if (!emb) { clearSelection(); return; }
+ const cur = embryoResolvedXY(emb);
+ const num = embryoNumberFor(emb);
+ const oldStr = cur ? `(${cur.x.toFixed(1)}, ${cur.y.toFixed(1)})` : '(unknown)';
+ const newStr = `(${targetStage.x.toFixed(1)}, ${targetStage.y.toFixed(1)})`;
+ if (!window.confirm(`Move embryo ${num} from ${oldStr} to ${newStr}?`)) {
+ return; // keep the embryo picked up so they can try again
+ }
+ try {
+ const res = await fetch(`/api/embryos/${encodeURIComponent(id)}/position`, {
+ method: 'PUT',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ x: targetStage.x, y: targetStage.y }),
+ });
+ if (!res.ok) {
+ window.alert(`Move failed (${res.status}): ${await res.text()}`);
+ return;
+ }
+ // EMBRYOS_UPDATE will arrive over the bus and refresh the layer;
+ // dropping clears the picked-up state regardless.
+ clearSelection();
+ } catch (err) {
+ console.error('move embryo:', err);
+ window.alert(`Move failed: ${err.message}`);
+ }
+ }
+
+ async function attemptDeleteSelected() {
+ const id = _selectedEmbryoId;
+ if (!id) return;
+ const emb = embryoById(id);
+ const num = emb ? embryoNumberFor(emb) : id;
+ if (!window.confirm(`Remove embryo ${num}?`)) return;
+ try {
+ const res = await fetch(`/api/embryos/${encodeURIComponent(id)}`, {
+ method: 'DELETE',
+ });
+ if (!res.ok) {
+ window.alert(`Delete failed (${res.status}): ${await res.text()}`);
+ return;
+ }
+ // The embryo is gone from the server snapshot; EMBRYOS_UPDATE
+ // will arrive and drop it from _embryos. Clear locally too.
+ _selectedEmbryoId = null;
+ } catch (err) {
+ console.error('delete embryo:', err);
+ window.alert(`Delete failed: ${err.message}`);
+ }
+ }
+
+ function onMapPointerDown(event) {
+ // Ignore non-primary buttons so right-clicks etc. don't trigger UI.
+ if (event.button !== undefined && event.button !== 0) return;
+ const id = findEmbryoIdAt(event.target);
+ if (id) {
+ setSelectedEmbryo(id);
+ return;
+ }
+ // Empty-space click: drop the picked-up embryo here.
+ if (_selectedEmbryoId !== null) {
+ const stage = eventToStageXY(event);
+ if (stage) attemptMoveSelected(stage);
+ }
+ }
+
+ function onMapKeyDown(event) {
+ // Only honour keys when the operator is actually looking at the Map:
+ // not on another top-level tab, not on the Details subview, and not
+ // typing into an input / textarea / select / contenteditable.
+ if (typeof state !== 'undefined' && typeof TABS !== 'undefined'
+ && state.tab !== TABS.DEVICES) {
+ return;
+ }
+ if (_currentView !== 'map') return;
+ const a = document.activeElement;
+ if (a && (a.tagName === 'INPUT' || a.tagName === 'TEXTAREA' ||
+ a.tagName === 'SELECT' || a.isContentEditable)) {
+ return;
+ }
+ if (event.key === 'Escape') {
+ if (_selectedEmbryoId !== null) {
+ clearSelection();
+ event.preventDefault();
+ }
+ return;
+ }
+ if (_selectedEmbryoId === null) return;
+ if (event.key === 'Delete' || event.key === 'Backspace') {
+ event.preventDefault(); // Backspace would otherwise navigate back
+ attemptDeleteSelected();
+ }
+ }
+
function updateMapMarker() {
if (!_mapMarker || !_lastXY) return;
const sx = _lastXY.X;
@@ -820,6 +1099,9 @@ const DevicesManager = (function () {
if (_camPlaceholder) _camPlaceholder.hidden = false;
if (_camMeta) _camMeta.textContent = 'stream off';
if (_camStaleTimer) { clearTimeout(_camStaleTimer); _camStaleTimer = null; }
+ // Operator may have zoomed in; reset so the next stream session
+ // starts at 1× rather than inheriting a stale view.
+ resetCameraZoom();
} else {
_camFrameTimes = [];
if (_camMeta) _camMeta.textContent = 'waiting…';
@@ -881,6 +1163,116 @@ const DevicesManager = (function () {
}
}
+ // ---- Camera zoom / pan ---------------------------------------------
+ function applyCameraTransform() {
+ if (!_camImg) return;
+ _camImg.style.transform =
+ `translate(${_camTx}px, ${_camTy}px) scale(${_camZoom})`;
+ // Reticle uses an SVG transform attribute on the inner
Embryo
${cols.includes('stage') ? 'Stage' : ''}
- ${cols.includes('confidence') ? 'Conf' : ''}
- ${cols.includes('rate') ? 'Rate' : ''}
- ${cols.includes('eta') ? 'ETA' : ''}
+ ${cols.includes('clock') ? 'Clock' : ''}
+ ${cols.includes('stereo') ? 'Stereo' : ''}
+ ${cols.includes('pace') ? 'Pace' : ''}
+ ${cols.includes('eta') ? 'ETA' : ''}
${cols.includes('sparkline') ? 'Progression' : ''}
${cols.includes('alert') ? 'Alert' : ''}
@@ -412,54 +430,27 @@ const EmbryosManager = {
const latest = reasoning.length > 0 ? reasoning[reasoning.length - 1] : null;
const cols = this.dashboardConfig.board.columns;
- // Stage
const stage = latest?.stage || embryo.current_stage || '—';
const stageIcon = this.getStageIcon(stage);
const stageName = this.formatStageName(stage);
- // Confidence
- const conf = latest ? this.normalizeConfidence(latest.confidence) : 'unknown';
- const confDots = conf === 'high' ? '●●●' : conf === 'medium' ? '●●○' : conf === 'low' ? '●○○' : '○○○';
- const confClass = conf === 'high' ? 'conf-high' : conf === 'medium' ? 'conf-med' : 'conf-low';
+ const align = this._computeAlignment(latest);
+ const overtime = align?.overtime;
- // Rate
- const overtime = latest?.temporal_analysis?.overtime_ratio;
- let rateText = '—';
- let rateClass = '';
- if (overtime != null) {
- const rate = (1 / overtime).toFixed(1);
- rateText = overtime < 0.9 ? `${rate}x↑` : overtime > 1.1 ? `${rate}x↓` : `${rate}x→`;
- rateClass = overtime < 0.9 ? 'rate-fast' : overtime > 1.5 ? 'rate-slow' : 'rate-normal';
- }
+ const clockText = align ? this._formatMinutes(align.inStageClockMin) : '—';
+ const stereoText = align ? this._formatStereoLabel(align) : '—';
+ const pace = align ? this._formatPace(align) : { text: '—', className: '' };
+ const eta = align ? this._formatEta(align) : '—';
- // ETA
- let eta = '—';
- if (stage && this.STAGE_TIMING[stage] != null) {
- const stageMinutes = this.STAGE_TIMING[stage];
- const hatchMinutes = this.STAGE_TIMING['hatched'] || 570;
- const remaining = hatchMinutes - stageMinutes;
- if (remaining > 0) {
- const hours = (remaining / 60).toFixed(1);
- eta = `~${hours}h`;
- } else {
- eta = 'done';
- }
- }
-
- // Sparkline
const sparklineSvg = cols.includes('sparkline') ? this._renderBoardSparkline(reasoning) : '';
- // Alert
const arrested = latest?.temporal_analysis?.is_potentially_arrested;
const slow = overtime && overtime > (this.dashboardConfig.board.warnOvertimeRatio || 1.5);
- const lowConf = conf === 'low';
let alertHtml = '—';
if (arrested) {
alertHtml = '⚠ arrested';
} else if (slow) {
- alertHtml = `⚠ slow ${overtime.toFixed(1)}x`;
- } else if (lowConf) {
- alertHtml = '⚠ low conf';
+ alertHtml = `⚠ slow ${overtime.toFixed(1)}×`;
}
const status = embryo.isComplete ? 'complete' : embryo.lastError ? 'error' : 'running';
@@ -472,8 +463,9 @@ const EmbryosManager = {
${embryo.embryoId.replace(/embryo_?/i, 'E')}
${cols.includes('stage') ? `${stageIcon} ${stageName}` : ''}
- ${cols.includes('confidence') ? `${confDots}` : ''}
- ${cols.includes('rate') ? `${rateText}` : ''}
+ ${cols.includes('clock') ? `${clockText}` : ''}
+ ${cols.includes('stereo') ? `${stereoText}` : ''}
+ ${cols.includes('pace') ? `${pace.text}` : ''}
${cols.includes('eta') ? `${eta}` : ''}
${cols.includes('sparkline') ? `${sparklineSvg}` : ''}
${cols.includes('alert') ? `${alertHtml}` : ''}
@@ -481,6 +473,99 @@ const EmbryosManager = {
`;
},
+ /** Compute clock↔stereotypic alignment from perception temporal_analysis.
+ *
+ * Definitions:
+ * inStageClockMin — wall-clock minutes elapsed in current stage
+ * inStageStereoMin — stereotypic minutes "used" within the stage,
+ * capped at the stage's expected duration. An
+ * overdue embryo is stuck at the stage end in
+ * stereo time while clock keeps ticking.
+ * overtime — ratio inStageClockMin / expected_duration.
+ * >1 means the embryo has spent more clock time
+ * in the stage than the reference 20°C textbook
+ * duration. <1 just means "still within stage" —
+ * no slow/fast signal yet.
+ * stereoAgeMin — total stereotypic age, anchored at the start
+ * minute of the current stage in the reference
+ * table plus the (capped) in-stage stereo offset.
+ */
+ _computeAlignment(latest) {
+ const ta = latest?.temporal_analysis;
+ if (!ta || !ta.current_stage) return null;
+ const stage = ta.current_stage;
+ const stageStart = this.STAGE_TIMING[stage];
+ if (stageStart == null) return null;
+
+ const expDur = Number(ta.expected_duration_min) || 0;
+ const inClock = Number(ta.time_in_stage_min) || 0;
+ const overtime = Number(ta.overtime_ratio) || 0;
+
+ const inStereo = expDur > 0 ? Math.min(inClock, expDur) : inClock;
+ const stereoAge = stageStart + inStereo;
+
+ return {
+ stage,
+ stageStart,
+ expDur,
+ inStageClockMin: inClock,
+ inStageStereoMin: inStereo,
+ stereoAgeMin: stereoAge,
+ overtime,
+ };
+ },
+
+ /** Render the stereo cell: "≈early", "≈bean +12m", or "≈comma +88m ⚠"
+ * when overdue (stereo capped at stage end while clock keeps running). */
+ _formatStereoLabel(align) {
+ const stageName = this.formatStageName(align.stage);
+ const offsetMin = Math.round(align.inStageStereoMin);
+ const overdue = align.expDur > 0 && align.inStageClockMin > align.expDur + 1;
+ const offsetStr = offsetMin > 0 ? ` +${offsetMin}m` : '';
+ const overdueMark = overdue ? ' ⚠' : '';
+ return `≈${stageName}${offsetStr}${overdueMark}`;
+ },
+
+ _formatPace(align) {
+ // Only emit a pace signal once we have meaningful clock data.
+ // Within the first few minutes the ratio is tiny and noisy — show
+ // a dashed placeholder so the column doesn't lie about precision.
+ const NORMAL_BAND = 1.05;
+ const SLOW_BAND = 1.5;
+ if (align.inStageClockMin < 1 || align.expDur <= 0) {
+ return { text: '—', className: 'pace-unknown' };
+ }
+ const r = align.overtime;
+ if (r <= NORMAL_BAND) {
+ return { text: '1.0×', className: 'pace-normal' };
+ }
+ if (r <= SLOW_BAND) {
+ return { text: `${r.toFixed(1)}× slow`, className: 'pace-slow' };
+ }
+ return { text: `⚠ ${r.toFixed(1)}×`, className: 'pace-slow-bad' };
+ },
+
+ /** ETA in hours from current stereotypic position to hatched, scaled
+ * by observed pace when the embryo is demonstrably slow. */
+ _formatEta(align) {
+ const hatchStereo = this.STAGE_TIMING['hatched'] || 570;
+ const remainStereo = hatchStereo - align.stereoAgeMin;
+ if (remainStereo <= 0) return 'done';
+ const paceFactor = align.overtime > 1.05 ? align.overtime : 1.0;
+ const remainClockMin = remainStereo * paceFactor;
+ return `~${(remainClockMin / 60).toFixed(1)}h`;
+ },
+
+ /** Compact minute formatter: "45s" / "10m" / "1h 22m" / "3h". */
+ _formatMinutes(min) {
+ if (min == null || !isFinite(min)) return '—';
+ if (min < 1) return `${Math.round(min * 60)}s`;
+ if (min < 60) return `${Math.round(min)}m`;
+ const h = Math.floor(min / 60);
+ const m = Math.round(min - h * 60);
+ return m > 0 ? `${h}h ${m}m` : `${h}h`;
+ },
+
_renderBoardSparkline(reasoning) {
if (!reasoning.length) return '';
const sorted = [...reasoning].sort((a, b) => (a.timepoint ?? 0) - (b.timepoint ?? 0));
@@ -565,12 +650,24 @@ const EmbryosManager = {
const shortName = embryo.embryoId.replace(/embryo_?/i, 'E');
const latestStage = sorted.length > 0 ? this.formatStageName(sorted[sorted.length - 1].stage) : '—';
+ const isTerminated = !!embryo.isComplete;
+ const termReason = embryo.completionReason || '';
+ // Short label for the badge — humanise the no_object terminal
+ // reason, otherwise keep the first clause of whatever the
+ // backend sent so the user still gets a hint.
+ const termBadge = isTerminated
+ ? (termReason.includes('no_object') ? 'HATCHED?' : 'STOPPED')
+ : '';
+ const termTooltip = isTerminated
+ ? `Terminated — ${termReason || 'no reason given'}`
+ : '';
- html += ``;
+ html += `
`;
html += `
${shortName}
${latestStage}
${reasoning.length} eval
+ ${isTerminated ? `${termBadge}` : ''}
`;
html += ``;
@@ -1000,7 +1097,7 @@ const EmbryosManager = {
intervalSeconds: embryoData.interval_seconds || this.state.baseInterval,
timepoints: embryoData.timepoints || 0,
isComplete: embryoData.is_complete || false,
- completionReason: null,
+ completionReason: embryoData.completion_reason || null,
firstAcquired: embryoData.first_acquired ? new Date(embryoData.first_acquired) : null,
lastAcquired: embryoData.last_acquired ? new Date(embryoData.last_acquired) : null,
detections: embryoData.detections || {},
@@ -2726,10 +2823,17 @@ const EmbryosManager = {
`;
}
- // Format confidence display
- const confDisplay = typeof item.confidence === 'number'
- ? `${Math.round(item.confidence * 100)}%`
- : (item.confidence || 'Unknown');
+ // Format confidence display. Hide entirely when the detector
+ // doesn't emit a probabilistic confidence (e.g. dopaminergic_signal
+ // returns structured intensity/structure findings instead) — the
+ // string "Unknown confidence" was actively confusing.
+ const hasNumericConf = typeof item.confidence === 'number';
+ const hasTextConf = typeof item.confidence === 'string' && item.confidence.trim() !== '';
+ const confHtml = hasNumericConf
+ ? `${Math.round(item.confidence * 100)}% confidence`
+ : hasTextConf
+ ? `${item.confidence}`
+ : '';
return `
`
- : '';
-
- tr.innerHTML = `
- ${formatEventTime(event.timestamp)}
- ${imageIndicator}${event.event_type}
- ${event.source || '-'}
- ${thumbnailHtml}
- `;
-
- // Click to expand data
- tr.addEventListener('click', () => {
- const dataDiv = tr.querySelector('.event-data');
- dataDiv.classList.toggle('expanded');
- if (dataDiv.classList.contains('expanded')) {
- dataDiv.innerHTML = `${formatEventTime(event.timestamp)}
+ ${label}
+ ${event.source || '-'}
+ ${formatEventTime(event.timestamp)}
+ ${imageIndicator}${event.event_type}
+ ${event.source || '-'}
+ ${thumbnailHtml}
+ `;
+
+ // Click to expand data
+ tr.addEventListener('click', () => {
+ const dataDiv = tr.querySelector('.event-data');
+ dataDiv.classList.toggle('expanded');
+ if (dataDiv.classList.contains('expanded')) {
+ dataDiv.innerHTML = `
@@ -2748,7 +2852,7 @@ const EmbryosManager = {
${item.stage ? this.formatStageName(item.stage) : (item.detected ? 'DETECTED' : 'Not detected')}
- ${confDisplay} confidence
+ ${confHtml}
${transitionalHtml}
${detectorFindingsHtml}
@@ -2979,13 +3083,22 @@ const EmbryosManager = {
container.classList.remove('visible');
container.innerHTML = '';
}
+ // Filmstrip side panel — clearing innerHTML lets the :empty CSS
+ // rule collapse the panel and let the rows reclaim full width.
+ const filmstripDetail = document.getElementById('filmstrip-detail');
+ if (filmstripDetail) {
+ filmstripDetail.innerHTML = '';
+ }
this.detailPanelVisible = false;
this.currentDetailItem = null;
- // Clear eval dot highlight
+ // Clear eval dot + filmstrip cell highlight
document.querySelectorAll('.eval-dot.active').forEach(dot => {
dot.classList.remove('active');
});
+ document.querySelectorAll('.filmstrip-cell.active').forEach(cell => {
+ cell.classList.remove('active');
+ });
},
// Navigate to previous/next item in detail panel
diff --git a/gently/ui/web/static/js/events.js b/gently/ui/web/static/js/events.js
index 02365e40..998431a1 100644
--- a/gently/ui/web/static/js/events.js
+++ b/gently/ui/web/static/js/events.js
@@ -41,6 +41,40 @@ function getEventBadgeClass(eventType) {
return 'default';
}
+// Log-record helpers --------------------------------------------------
+// LOG_RECORD events come from the Python logging bridge. We collapse the
+// generic "LOG_RECORD" type into the actual level (DEBUG / INFO / WARN /
+// ERROR) so the table is readable -- otherwise every row in a busy
+// session reads the same string in the Type column.
+function isLogEvent(event) {
+ return event && event.event_type === 'LOG_RECORD';
+}
+
+function logLevelLabel(d) {
+ // levelname is fastest path; fall back to numeric mapping if missing.
+ const lvl = (d && (d.level_name || '')).toString().toUpperCase();
+ if (lvl) {
+ if (lvl === 'WARNING') return 'WARN';
+ if (lvl === 'CRITICAL') return 'CRIT';
+ return lvl;
+ }
+ const n = d && Number(d.level);
+ if (!isFinite(n)) return 'LOG';
+ if (n >= 50) return 'CRIT';
+ if (n >= 40) return 'ERROR';
+ if (n >= 30) return 'WARN';
+ if (n >= 20) return 'INFO';
+ return 'DEBUG';
+}
+
+function logBadgeClass(d) {
+ const label = logLevelLabel(d);
+ if (label === 'DEBUG') return 'log-debug';
+ if (label === 'INFO') return 'log-info';
+ if (label === 'WARN') return 'log-warn';
+ return 'log-error'; // ERROR / CRIT collapse together
+}
+
// Search helper functions
function escapeRegex(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -67,12 +101,17 @@ function eventMatchesSearch(event) {
}
function highlightSearchTerms(text) {
- if (!searchQuery || !text) return text;
+ // Escape first — event keys/values/messages are arbitrary text (perception
+ // prose, file paths, agent output) and are inserted via innerHTML by the
+ // callers. Escaping here closes the XSS hole at every call site; the
+ // injected tags are the only markup we add.
+ const safe = escapeHtml(text == null ? '' : String(text));
+ if (!searchQuery) return safe;
try {
const regex = new RegExp(`(${escapeRegex(searchQuery)})`, 'gi');
- return String(text).replace(regex, '$1');
+ return safe.replace(regex, '$1');
} catch (e) {
- return text;
+ return safe;
}
}
@@ -212,45 +251,81 @@ function addEventToTable(event, prepend = true) {
if (hasImage) tr.classList.add('has-image');
tr.dataset.eventId = event.event_id || '';
- const badgeClass = getEventBadgeClass(event.event_type);
-
- // Image indicator icon
- const imageIndicator = hasImage
- ? `
-
- `
- : '';
-
- // Thumbnail preview
- const thumbnailHtml = hasImage
- ? ``
- : '';
-
- tr.innerHTML = `
- ${formatEventData(event.data)}
${JSON.stringify(event.data, null, 2)}`;
- } else {
- dataDiv.innerHTML = formatEventData(event.data);
- }
- });
+ if (isLogEvent(event)) {
+ // Log rows have a compact, distinctive shape: level badge in the
+ // Type column, logger name + message in the Data column. Click to
+ // toggle a pre with the full payload (incl. exception trace).
+ tr.classList.add('log-row');
+ const d = event.data || {};
+ const badgeCls = logBadgeClass(d);
+ const label = logLevelLabel(d);
+ const message = highlightSearchTerms(d.message || '');
+ const loggerName = highlightSearchTerms(d.logger || '-');
+ const excTag = d.exc_text ? ' ⏎ trace…' : '';
+ tr.innerHTML = `
+
+ ${loggerName}${excTag}
+
${d.logger || ''} ${d.func || ''}:${d.line || ''}\n` +
+ `${(d.message || '')}${tracePart}`;
+ } else {
+ dataDiv.innerHTML =
+ `${loggerName}` +
+ `${excTag}`;
+ }
+ });
+ } else {
+ const badgeClass = getEventBadgeClass(event.event_type);
+
+ // Image indicator icon
+ const imageIndicator = hasImage
+ ? `
+
+ `
+ : '';
+
+ // Thumbnail preview
+ const thumbnailHtml = hasImage
+ ? ``
+ : '';
+
+ tr.innerHTML = `
+ ${formatEventData(event.data)}
${JSON.stringify(event.data, null, 2)}`;
+ } else {
+ dataDiv.innerHTML = formatEventData(event.data);
+ }
+ });
+ }
if (prepend) {
tbody.insertBefore(tr, tbody.firstChild);
diff --git a/gently/ui/web/static/js/gallery.js b/gently/ui/web/static/js/gallery.js
index 51ee4207..42159d18 100644
--- a/gently/ui/web/static/js/gallery.js
+++ b/gently/ui/web/static/js/gallery.js
@@ -422,13 +422,19 @@ const CalibrationProfileView = {
/** Compact SPIM live indicator used inside the metrics strip.
* Carries the same IDs as the old big preview so SpimLivePreview's
- * apply-on-render logic continues to work unchanged. */
+ * apply-on-render logic continues to work unchanged. The thumb is a
+ * button — click to open the floating popout for a larger view. */
_renderSpimIndicator() {
return `
SPIM
- ![]()
+
@@ -1329,21 +1335,33 @@ const SpimLivePreview = {
const placeholder = document.getElementById('cal-spim-placeholder');
const metaEl = document.getElementById('cal-spim-meta');
const led = document.getElementById('cal-spim-led');
- if (!img) return; // not in profile view
const latest = embryoId ? this._latestByEmbryo[embryoId] : null;
- if (latest) {
- img.src = `data:image/png;base64,${latest.base64_png}`;
- img.classList.add('has-frame');
- if (placeholder) placeholder.hidden = true;
- if (metaEl) metaEl.textContent = this._formatMeta(latest);
- if (led) led.classList.remove('idle');
- } else {
- img.removeAttribute('src');
- img.classList.remove('has-frame');
- if (placeholder) placeholder.hidden = false;
- if (metaEl) metaEl.textContent = '—';
- if (led) led.classList.add('idle');
+
+ if (img) {
+ if (latest) {
+ img.src = `data:image/png;base64,${latest.base64_png}`;
+ img.classList.add('has-frame');
+ if (placeholder) placeholder.hidden = true;
+ if (metaEl) metaEl.textContent = this._formatMeta(latest);
+ if (led) led.classList.remove('idle');
+ } else {
+ img.removeAttribute('src');
+ img.classList.remove('has-frame');
+ if (placeholder) placeholder.hidden = false;
+ if (metaEl) metaEl.textContent = '—';
+ if (led) led.classList.add('idle');
+ }
+ }
+
+ // Mirror into popout if it's open — the popout lives outside the
+ // calibration panel's innerHTML reset, so we paint it independently.
+ if (typeof SpimPopout !== 'undefined') {
+ SpimPopout.paint(latest ? {
+ base64_png: latest.base64_png,
+ meta: this._formatMeta(latest),
+ embryoId,
+ } : null);
}
},
@@ -1375,6 +1393,227 @@ const SpimLivePreview = {
document.addEventListener('DOMContentLoaded', () => SpimLivePreview.init());
+// ==========================================
+// SPIM live popout (floating draggable window)
+// ==========================================
+// Lazy-built floating window that mirrors SpimLivePreview at a larger
+// size. Draggable via the header bar, resizable from the bottom-right
+// corner. Position and size persist in localStorage so the window
+// re-opens where the operator last left it. Closes on Escape.
+const SpimPopout = {
+ _STORAGE_KEY: 'gently.spimPopout.v1',
+ _root: null,
+ _isOpen: false,
+
+ _ensureBuilt() {
+ if (this._root) return this._root;
+
+ const el = document.createElement('div');
+ el.className = 'cal-spim-popout';
+ el.id = 'cal-spim-popout';
+ el.hidden = true;
+ el.innerHTML = `
+
+
+ SPIM Live
+
+
+
+
+
+ ![]()
+
+
+ `;
+ document.body.appendChild(el);
+ this._root = el;
+
+ // Restore persisted geometry
+ const saved = this._loadGeometry();
+ if (saved) {
+ el.style.left = `${saved.left}px`;
+ el.style.top = `${saved.top}px`;
+ el.style.width = `${saved.width}px`;
+ el.style.height = `${saved.height}px`;
+ }
+
+ el.querySelector('#cal-spim-popout-close').addEventListener('click', () => this.close());
+ this._wireDrag(el);
+ this._wireResizeObserver(el);
+
+ return el;
+ },
+
+ open() {
+ const el = this._ensureBuilt();
+ if (this._isOpen) return;
+ el.hidden = false;
+ this._isOpen = true;
+
+ // Clamp into viewport in case window was resized while popout was hidden
+ this._clampIntoViewport(el);
+
+ // Paint current frame for the selected embryo
+ const selected = (typeof CalibrationManager !== 'undefined')
+ ? CalibrationManager.selectedEmbryoId : null;
+ if (selected && typeof SpimLivePreview !== 'undefined') {
+ const latest = SpimLivePreview._latestByEmbryo[selected];
+ this.paint(latest ? {
+ base64_png: latest.base64_png,
+ meta: SpimLivePreview._formatMeta(latest),
+ embryoId: selected,
+ } : null);
+ } else {
+ this.paint(null);
+ }
+
+ document.addEventListener('keydown', this._onKey);
+ },
+
+ close() {
+ if (!this._root || !this._isOpen) return;
+ this._root.hidden = true;
+ this._isOpen = false;
+ document.removeEventListener('keydown', this._onKey);
+ },
+
+ toggle() {
+ this._isOpen ? this.close() : this.open();
+ },
+
+ /** Called by SpimLivePreview whenever the current embryo's latest
+ * frame changes. Frame is {base64_png, meta, embryoId} or null. */
+ paint(frame) {
+ if (!this._root || !this._isOpen) return;
+ const img = this._root.querySelector('#cal-spim-popout-img');
+ const placeholder = this._root.querySelector('#cal-spim-popout-placeholder');
+ const meta = this._root.querySelector('#cal-spim-popout-meta');
+ const embryoEl = this._root.querySelector('#cal-spim-popout-embryo');
+ const led = this._root.querySelector('#cal-spim-popout-led');
+
+ if (frame) {
+ img.src = `data:image/png;base64,${frame.base64_png}`;
+ img.classList.add('has-frame');
+ placeholder.hidden = true;
+ meta.textContent = frame.meta || '—';
+ embryoEl.textContent = frame.embryoId || '';
+ led.classList.remove('idle');
+ } else {
+ img.removeAttribute('src');
+ img.classList.remove('has-frame');
+ placeholder.hidden = false;
+ meta.textContent = '—';
+ embryoEl.textContent = '';
+ led.classList.add('idle');
+ }
+ },
+
+ _onKey: (e) => {
+ if (e.key === 'Escape') SpimPopout.close();
+ },
+
+ _wireDrag(el) {
+ const header = el.querySelector('#cal-spim-popout-header');
+ let dragging = false;
+ let startX = 0, startY = 0, startLeft = 0, startTop = 0;
+
+ header.addEventListener('pointerdown', (e) => {
+ // Don't start drag on the close button
+ if (e.target.closest('.cal-spim-popout-close')) return;
+ dragging = true;
+ const rect = el.getBoundingClientRect();
+ startX = e.clientX;
+ startY = e.clientY;
+ startLeft = rect.left;
+ startTop = rect.top;
+ // Switch to absolute positioning if currently default
+ el.style.left = `${startLeft}px`;
+ el.style.top = `${startTop}px`;
+ el.style.right = 'auto';
+ el.style.bottom = 'auto';
+ header.setPointerCapture(e.pointerId);
+ el.classList.add('dragging');
+ });
+
+ header.addEventListener('pointermove', (e) => {
+ if (!dragging) return;
+ const dx = e.clientX - startX;
+ const dy = e.clientY - startY;
+ let nextLeft = startLeft + dx;
+ let nextTop = startTop + dy;
+ // Keep at least 40px of header on-screen
+ const w = el.offsetWidth;
+ const h = el.offsetHeight;
+ nextLeft = Math.max(-(w - 80), Math.min(window.innerWidth - 80, nextLeft));
+ nextTop = Math.max(0, Math.min(window.innerHeight - 40, nextTop));
+ el.style.left = `${nextLeft}px`;
+ el.style.top = `${nextTop}px`;
+ });
+
+ const endDrag = (e) => {
+ if (!dragging) return;
+ dragging = false;
+ el.classList.remove('dragging');
+ try { header.releasePointerCapture(e.pointerId); } catch (_) {}
+ this._saveGeometry(el);
+ };
+ header.addEventListener('pointerup', endDrag);
+ header.addEventListener('pointercancel', endDrag);
+ },
+
+ _wireResizeObserver(el) {
+ if (typeof ResizeObserver === 'undefined') return;
+ let saveTimer = null;
+ const ro = new ResizeObserver(() => {
+ if (!this._isOpen) return;
+ clearTimeout(saveTimer);
+ saveTimer = setTimeout(() => this._saveGeometry(el), 250);
+ });
+ ro.observe(el);
+ },
+
+ _clampIntoViewport(el) {
+ const rect = el.getBoundingClientRect();
+ if (rect.left + 80 > window.innerWidth || rect.top + 40 > window.innerHeight
+ || rect.left < -(rect.width - 80) || rect.top < 0) {
+ // Recenter
+ const w = Math.min(rect.width || 520, window.innerWidth - 40);
+ const h = Math.min(rect.height || 440, window.innerHeight - 40);
+ el.style.width = `${w}px`;
+ el.style.height = `${h}px`;
+ el.style.left = `${Math.max(20, (window.innerWidth - w) / 2)}px`;
+ el.style.top = `${Math.max(20, (window.innerHeight - h) / 2)}px`;
+ }
+ },
+
+ _saveGeometry(el) {
+ const rect = el.getBoundingClientRect();
+ const data = {
+ left: Math.round(rect.left),
+ top: Math.round(rect.top),
+ width: Math.round(rect.width),
+ height: Math.round(rect.height),
+ };
+ try { localStorage.setItem(this._STORAGE_KEY, JSON.stringify(data)); } catch (_) {}
+ },
+
+ _loadGeometry() {
+ try {
+ const raw = localStorage.getItem(this._STORAGE_KEY);
+ if (!raw) return null;
+ const data = JSON.parse(raw);
+ if (typeof data.left !== 'number') return null;
+ return data;
+ } catch (_) { return null; }
+ },
+};
+
// Legacy wrappers kept for backward compatibility
function renderCalibrationGallery() { CalibrationManager.render(); }
diff --git a/gently/ui/web/static/js/home.js b/gently/ui/web/static/js/home.js
new file mode 100644
index 00000000..089d7de3
--- /dev/null
+++ b/gently/ui/web/static/js/home.js
@@ -0,0 +1,177 @@
+/**
+ * HomeApp — the landing tab.
+ *
+ * A light at-a-glance landing surface: recent sessions, recent plans, recent
+ * images, a thin status line, and a "Start / continue an experiment" button
+ * that launches the setup flow (the wizard, which no longer auto-pops in chat).
+ *
+ * Read-only fetches against existing endpoints (/api/sessions, /api/campaigns,
+ * /api/home/recent-images); mirrors the ReviewApp/CampaignsApp module pattern.
+ */
+const HomeApp = (() => {
+ let _inited = false;
+ const SESSIONS_N = 5;
+ const CAMPAIGNS_N = 5;
+ const IMAGES_N = 8;
+ // Recent images are stable (latest projection per embryo). refresh() runs on
+ // every Home-tab entry, so guard against redundant disk-walking fetches:
+ // skip if one is in flight or the strip was loaded within IMAGES_TTL_MS.
+ const IMAGES_TTL_MS = 15000;
+ let _imgState = { at: 0, inflight: false };
+
+ function relTime(iso) {
+ if (!iso) return '';
+ const t = Date.parse(iso);
+ if (isNaN(t)) return '';
+ const s = Math.max(0, (Date.now() - t) / 1000);
+ if (s < 60) return 'just now';
+ if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+ if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+ const d = Math.floor(s / 86400);
+ return d < 30 ? `${d}d ago` : new Date(t).toLocaleDateString();
+ }
+
+ function empty(el, msg) {
+ el.innerHTML = `
+ Awaiting SPIM frame…
+
+ ${escapeHtml(msg)}
`;
+ }
+
+ function wireGoTab(scope) {
+ (scope || document).querySelectorAll('[data-go-tab]').forEach(el => {
+ if (el._goWired) return;
+ el._goWired = true;
+ el.addEventListener('click', (e) => {
+ e.preventDefault();
+ if (typeof switchTab === 'function') switchTab(el.dataset.goTab);
+ });
+ });
+ }
+
+ async function loadSessions() {
+ const el = document.getElementById('home-recent-sessions');
+ if (!el) return;
+ try {
+ const data = await (await fetch('/api/sessions')).json();
+ const sessions = (data.sessions || []).slice(0, SESSIONS_N);
+ if (!sessions.length) { empty(el, 'No sessions yet.'); return; }
+ el.innerHTML = sessions.map(s => {
+ const live = s.active ? 'live' : '';
+ const resume = s.active ? '' :
+ ``;
+ return `
+
`;
+ }).join('');
+ el.querySelectorAll('[data-resume]').forEach(b => b.addEventListener('click', async () => {
+ b.disabled = true;
+ b.textContent = 'Resuming…';
+ try {
+ await fetch(`/api/sessions/${encodeURIComponent(b.dataset.resume)}/resume`, { method: 'POST' });
+ } catch (_) { b.disabled = false; b.textContent = 'Resume'; }
+ }));
+ } catch (e) { empty(el, 'Could not load sessions.'); }
+ }
+
+ async function loadCampaigns() {
+ const el = document.getElementById('home-recent-campaigns');
+ if (!el) return;
+ try {
+ const data = await (await fetch('/api/campaigns')).json();
+ const items = (data.campaigns || []).slice(0, CAMPAIGNS_N);
+ if (!items.length) { empty(el, 'No plans yet.'); return; }
+ el.innerHTML = items.map(t => {
+ const c = t.campaign || {};
+ const st = t.status || {};
+ const name = c.shorthand || c.description || 'Untitled plan';
+ const total = st.total || 0;
+ const chip = total ? `${st.completed || 0}/${total} done` : '';
+ return `
+
${resume}
+ ${escapeHtml(s.name || s.session_id)}${live}
+
+
+ ${escapeHtml(name)}${chip}
+
`;
+ }).join('');
+ wireGoTab(el);
+ } catch (e) { empty(el, 'Could not load plans.'); }
+ }
+
+ async function loadImages(force) {
+ const el = document.getElementById('home-recent-images');
+ if (!el) return;
+ if (_imgState.inflight) return;
+ // _imgState.at is set only after a completed fetch (images or empty),
+ // never after an error — so failures still retry on the next entry.
+ if (!force && _imgState.at && (Date.now() - _imgState.at) < IMAGES_TTL_MS) return;
+ _imgState.inflight = true;
+ try {
+ const data = await (await fetch(`/api/home/recent-images?limit=${IMAGES_N}`)).json();
+ // Latest projection per embryo across recent sessions (server orders
+ // most-recent session first).
+ const recent = (data.images || []).slice(0, IMAGES_N);
+ if (!recent.length) {
+ empty(el, 'No images yet — they appear once a session has captured volumes.');
+ _imgState.at = Date.now();
+ return;
+ }
+ el.innerHTML = '' + recent.map(s => {
+ const tp = (s.timepoint != null) ? ` · t${s.timepoint}` : '';
+ const label = `${s.embryo_id || ''}${tp}`;
+ const sub = s.session_name && s.session_name !== s.session_id
+ ? ` (${s.session_name})` : '';
+ const src = `/api/sessions/${encodeURIComponent(s.session_id)}`
+ + `/projection?embryo=${encodeURIComponent(s.embryo_id)}`
+ + `&t=${encodeURIComponent(s.timepoint)}`;
+ return `
';
+ _imgState.at = Date.now();
+ } catch (e) {
+ empty(el, 'Could not load images.');
+ } finally {
+ _imgState.inflight = false;
+ }
+ }
+
+ function updateStatus() {
+ const el = document.getElementById('home-status');
+ if (!el) return;
+ const connected = (typeof state !== 'undefined' && state.connected);
+ const n = (typeof state !== 'undefined' && Array.isArray(state.embryos)) ? state.embryos.length : 0;
+ el.textContent = connected
+ ? `Connected · ${n} embryo${n === 1 ? '' : 's'} in view`
+ : 'Offline — start the agent to connect.';
+ }
+
+ function refresh() {
+ updateStatus();
+ loadSessions();
+ loadCampaigns();
+ loadImages();
+ }
+
+ function init() {
+ if (!_inited) {
+ _inited = true;
+ wireGoTab(document.getElementById('home-content'));
+ const start = document.getElementById('home-start-btn');
+ if (start) start.addEventListener('click', () => {
+ if (typeof AgentChat !== 'undefined' && AgentChat.togglePanel) {
+ AgentChat.togglePanel(true);
+ // Let the panel's WS connect before sending the command.
+ if (AgentChat.runCommand) setTimeout(() => AgentChat.runCommand('/wizard'), 250);
+ }
+ });
+ }
+ refresh(); // re-fetch on every entry to the tab
+ }
+
+ // Self-initialise on load when Home is the default-active tab (switchTab's
+ // lazy-init hook only fires on a tab click / hash route, not initial paint).
+ document.addEventListener('DOMContentLoaded', () => {
+ const home = document.getElementById('home-content');
+ if (home && home.classList.contains('active')) init();
+ });
+
+ return { init, refresh };
+})();
diff --git a/gently/ui/web/static/js/projection-viewer.js b/gently/ui/web/static/js/projection-viewer.js
index 1f5f530e..0e20b9fa 100644
--- a/gently/ui/web/static/js/projection-viewer.js
+++ b/gently/ui/web/static/js/projection-viewer.js
@@ -118,6 +118,10 @@ const ProjectionViewer = {
this.projections = [];
this.selectedMethod = null;
this.isOpen = true;
+ // Clear any volume from a previous open so a failed /api/volume-raw fetch
+ // can't leave the prior embryo/timepoint's 3D data bound (stale-render).
+ this.volumeData = null;
+ this.volumeShape = null;
const modal = document.getElementById('projection-viewer-modal');
const loading = document.getElementById('pv-loading');
@@ -280,6 +284,10 @@ const ProjectionViewer = {
},
selectMethod(method) {
+ // If the 3D view is requested but no volume loaded (e.g. /api/volume-raw
+ // failed while projections succeeded), fall back to the projections grid
+ // rather than showing an empty, never-initialized 3D panel.
+ if (method === '3d_viewer' && !this.volumeData) method = null;
this.selectedMethod = method;
this.renderProjections();
this.renderTabs();
@@ -298,6 +306,19 @@ const ProjectionViewer = {
this.updateViewerVisibility();
},
+ // Resize the WebGL canvas + camera to the container's current width.
+ // (Height is fixed at 400px; only width tracks the layout.) The animation
+ // loop handles re-rendering.
+ _resize3D() {
+ const container = document.getElementById('pv-3d-container');
+ if (!container || !this.renderer3d || !this.camera3d) return;
+ const w = container.clientWidth || 500;
+ const h = 400;
+ this.renderer3d.setSize(w, h);
+ this.camera3d.aspect = w / h;
+ this.camera3d.updateProjectionMatrix();
+ },
+
// 3D Viewer Methods
init3DViewer() {
const container = document.getElementById('pv-3d-container');
@@ -319,6 +340,22 @@ const ProjectionViewer = {
container.innerHTML = '';
container.appendChild(this.renderer3d.domElement);
+ // Keep the WebGL canvas in sync with its container width — the chat
+ // panel can dock/resize and the window can resize. The animation loop
+ // re-renders every frame, so on a size change we only need to resize the
+ // renderer + camera (coalesced to one rAF). Also listen for the explicit
+ // layout-change event the chat dock fires on pin/unpin.
+ if (this._resizeObserver) this._resizeObserver.disconnect();
+ this._resizeObserver = new ResizeObserver(() => {
+ if (this._resizeRaf) cancelAnimationFrame(this._resizeRaf);
+ this._resizeRaf = requestAnimationFrame(() => this._resize3D());
+ });
+ this._resizeObserver.observe(container);
+ if (!this._onLayoutChanged) {
+ this._onLayoutChanged = () => this._resize3D();
+ window.addEventListener('gently:layout-changed', this._onLayoutChanged);
+ }
+
// Root group is the object the user rotates. Raymarched volume
// mesh is added here. The group scale flips Y so the image
// orientation matches 2D projections.
@@ -609,6 +646,18 @@ const ProjectionViewer = {
cancelAnimationFrame(this.animationId);
this.animationId = null;
}
+ if (this._resizeObserver) {
+ this._resizeObserver.disconnect();
+ this._resizeObserver = null;
+ }
+ if (this._resizeRaf) {
+ cancelAnimationFrame(this._resizeRaf);
+ this._resizeRaf = null;
+ }
+ if (this._onLayoutChanged) {
+ window.removeEventListener('gently:layout-changed', this._onLayoutChanged);
+ this._onLayoutChanged = null;
+ }
// Dispose the volume cube's geometry, material, and 3D texture.
if (this.volumeMesh) {
this.volumeMesh.geometry?.dispose();
diff --git a/gently/ui/web/static/js/review.js b/gently/ui/web/static/js/review.js
index bd2c75fa..07dcf49e 100644
--- a/gently/ui/web/static/js/review.js
+++ b/gently/ui/web/static/js/review.js
@@ -86,17 +86,35 @@ const ReviewApp = {
}
list.innerHTML = filtered.map(s => `
-
+ 
+
`;
+ }).join('') + '
-
+
+
{% endif %}
diff --git a/gently/ui/web/templates/_navbar.html b/gently/ui/web/templates/_navbar.html
index 821c8710..33d5f675 100644
--- a/gently/ui/web/templates/_navbar.html
+++ b/gently/ui/web/templates/_navbar.html
@@ -2,7 +2,8 @@
${this.escapeHtml(s.name || s.session_id)}
+
+
`).join('');
},
+ async resumeSession(sessionId) {
+ if (!confirm('Switch the live agent to this session?\nThe current session is saved first.')) return;
+ try {
+ const resp = await fetch(`/api/sessions/${sessionId}/resume`, { method: 'POST' });
+ if (resp.ok) {
+ // Server broadcasts session_changed to reload all clients; we
+ // navigate home as well so the operator lands on the new session.
+ window.location.href = '/';
+ } else {
+ const d = await resp.json().catch(() => ({}));
+ alert('Resume failed: ' + (d.detail || ('HTTP ' + resp.status)));
+ }
+ } catch (e) {
+ alert('Resume failed: ' + e);
+ }
+ },
+
renderSessionContent() {
const content = document.getElementById('session-content');
const s = this.currentSession;
diff --git a/gently/ui/web/static/js/utils.js b/gently/ui/web/static/js/utils.js
index b0e6d2ac..4b8ff62b 100644
--- a/gently/ui/web/static/js/utils.js
+++ b/gently/ui/web/static/js/utils.js
@@ -3,7 +3,7 @@
// ══════════════════════════════════════════════════════════
// Tab and view name constants
-const TABS = { EMBRYOS: 'embryos', CALIBRATION: 'calibration', EVENTS: 'events', PLANS: 'plans', SESSIONS: 'sessions', DEVICES: 'devices', EXPERIMENT: 'experiment' };
+const TABS = { HOME: 'home', EMBRYOS: 'embryos', CALIBRATION: 'calibration', EVENTS: 'events', PLANS: 'plans', SESSIONS: 'sessions', DEVICES: 'devices', EXPERIMENT: 'experiment' };
/**
* HTML-escape a string (safe for insertion into innerHTML).
diff --git a/gently/ui/web/static/js/websocket.js b/gently/ui/web/static/js/websocket.js
index 38a2794c..069724a2 100644
--- a/gently/ui/web/static/js/websocket.js
+++ b/gently/ui/web/static/js/websocket.js
@@ -127,6 +127,24 @@ function handleMessage(msg) {
// Switch to embryos tab if not already there
if (state.tab !== 'embryos') switchTab('embryos');
}
+ } else if (msg.type === 'open_volume') {
+ // The agent asked us to open the in-browser volume viewer — the
+ // web-native replacement for the old desktop napari window.
+ if (typeof ProjectionViewer !== 'undefined' && msg.embryo_id != null) {
+ const view = msg.view || '3d_viewer';
+ Promise.resolve(ProjectionViewer.open(msg.embryo_id, msg.timepoint))
+ .then(() => {
+ // Default to the 3D viewer tab when the agent opens it.
+ if (view && typeof ProjectionViewer.selectMethod === 'function') {
+ ProjectionViewer.selectMethod(view);
+ }
+ })
+ .catch((e) => console.warn('open_volume failed', e));
+ }
+ } else if (msg.type === 'session_changed') {
+ // The live agent switched sessions (resume from the Sessions tab) —
+ // reload so every client picks up the new session's state + transcript.
+ window.location.href = '/';
} else if (msg.type === 'ping') {
state.ws.send(JSON.stringify({type: 'pong'}));
} else if (msg.type === 'presence') {
diff --git a/gently/ui/web/strategy_snapshot.py b/gently/ui/web/strategy_snapshot.py
index 46569758..91c560e7 100644
--- a/gently/ui/web/strategy_snapshot.py
+++ b/gently/ui/web/strategy_snapshot.py
@@ -22,7 +22,7 @@
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
import yaml
@@ -37,10 +37,10 @@
# ui_icon names but resolves them to actual unicode glyphs the swimlane SVG
# can render directly.
_ROLE_ICONS = {
- "star": "★", # ★
- "diamond": "◆", # ◆
- "circle": "●", # ●
- "triangle": "▲", # ▲
+ "star": "★", # ★
+ "diamond": "◆", # ◆
+ "circle": "●", # ●
+ "triangle": "▲", # ▲
}
# Default per-timepoint exposure when nothing on disk tells us otherwise.
@@ -60,9 +60,9 @@
# ---------------------------------------------------------------------------
-def _read_yaml(path: Path) -> Optional[dict]:
+def _read_yaml(path: Path) -> dict | None:
try:
- with open(path, "r", encoding="utf-8") as f:
+ with open(path, encoding="utf-8") as f:
return yaml.safe_load(f) or {}
except FileNotFoundError:
return None
@@ -80,7 +80,7 @@ def _pick_timelapse_yaml(session_dir: Path, legacy_session_dir: Path) -> dict:
orchestrator that hasn't yet been restarted (still writing to legacy)
isn't shadowed by a stale new-path file.
"""
- candidates: List[Path] = [
+ candidates: list[Path] = [
session_dir / "timelapse.yaml",
legacy_session_dir / "timelapse.yaml",
]
@@ -93,6 +93,7 @@ def _pick_timelapse_yaml(session_dir: Path, legacy_session_dir: Path) -> dict:
return {}
if len(docs) == 1:
return docs[0][1]
+
# Pick by saved_at if present, falling back to file mtime.
def _saved_at_key(item):
path, doc = item
@@ -105,11 +106,12 @@ def _saved_at_key(item):
return path.stat().st_mtime
except OSError:
return 0.0
+
docs.sort(key=_saved_at_key, reverse=True)
return docs[0][1]
-def _parse_iso(s: Optional[str]) -> Optional[datetime]:
+def _parse_iso(s: str | None) -> datetime | None:
if not s:
return None
try:
@@ -118,7 +120,7 @@ def _parse_iso(s: Optional[str]) -> Optional[datetime]:
return None
-def _elapsed_s(t: Optional[datetime], started_at: datetime) -> Optional[float]:
+def _elapsed_s(t: datetime | None, started_at: datetime) -> float | None:
if t is None:
return None
return (t - started_at).total_seconds()
@@ -132,19 +134,21 @@ def _elapsed_s(t: Optional[datetime], started_at: datetime) -> Optional[float]:
@dataclass
class _EmbryoAccum:
"""Mutable accumulator while replaying timeline events for one embryo."""
+
eid: str
- phases: List[dict]
- trigger_events: List[dict]
- power_history_488: List[dict]
+ phases: list[dict]
+ trigger_events: list[dict]
+ power_history_488: list[dict]
- def open_phase(self, mode: str, start_s: float, cadence_s: Optional[float] = None,
- **extra) -> None:
+ def open_phase(
+ self, mode: str, start_s: float, cadence_s: float | None = None, **extra
+ ) -> None:
# If the last phase has no end yet, close it at start_s.
if self.phases:
last = self.phases[-1]
if "end" not in last or last["end"] is None:
last["end"] = start_s
- ph: Dict[str, Any] = {"mode": mode, "start": start_s, "end": None}
+ ph: dict[str, Any] = {"mode": mode, "start": start_s, "end": None}
if cadence_s is not None:
ph["cadence_s"] = cadence_s
ph.update(extra)
@@ -167,7 +171,7 @@ def build_strategy_snapshot(
session_id: str,
*,
horizon_padding_s: float = 1800.0,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
"""Read the session folder and return the strategy dict the frontend wants.
Parameters
@@ -272,7 +276,9 @@ def build_strategy_snapshot(
"now_offset_s": now_offset_s,
"horizon_s": horizon_s,
"base_interval_s": base_interval_s,
- "dose_budget_base_ms": float(dose_budget_base_ms) if dose_budget_base_ms is not None else None,
+ "dose_budget_base_ms": float(dose_budget_base_ms)
+ if dose_budget_base_ms is not None
+ else None,
"per_timepoint_ms": per_timepoint_ms,
"monitoring_modes": monitoring_modes,
"triggers": triggers,
@@ -285,7 +291,7 @@ def build_strategy_snapshot(
# ---------------------------------------------------------------------------
-def _build_monitoring_modes(mode_names: List[str]) -> List[dict]:
+def _build_monitoring_modes(mode_names: list[str]) -> list[dict]:
"""Resolve each active monitoring mode name into a serialized dict.
The orchestrator persists only the names in ``timelapse.yaml``; we
@@ -300,16 +306,18 @@ def _build_monitoring_modes(mode_names: List[str]) -> List[dict]:
logger.debug("Could not import MONITORING_MODES; skipping mode resolution")
return []
- out: List[dict] = []
+ out: list[dict] = []
for name in mode_names:
factory = MONITORING_MODES.get(name)
if factory is None:
- out.append({
- "name": name,
- "description": "",
- "applies_to_roles": [],
- "params": {},
- })
+ out.append(
+ {
+ "name": name,
+ "description": "",
+ "applies_to_roles": [],
+ "params": {},
+ }
+ )
continue
try:
mode = factory()
@@ -319,15 +327,16 @@ def _build_monitoring_modes(mode_names: List[str]) -> List[dict]:
# Pull declarative knobs (fast_interval, rampdown_*) off the instance.
excluded = {"name", "description", "applies_to_roles"}
params = {
- k: v for k, v in vars(mode).items()
- if not k.startswith("_") and k not in excluded
+ k: v for k, v in vars(mode).items() if not k.startswith("_") and k not in excluded
}
- out.append({
- "name": mode.name,
- "description": mode.description,
- "applies_to_roles": list(mode.applies_to_roles),
- "params": params,
- })
+ out.append(
+ {
+ "name": mode.name,
+ "description": mode.description,
+ "applies_to_roles": list(mode.applies_to_roles),
+ "params": params,
+ }
+ )
return out
@@ -338,31 +347,35 @@ def _build_monitoring_modes(mode_names: List[str]) -> List[dict]:
def _build_triggers(
*,
- interval_rules: List[dict],
- power_rules: List[dict],
- embryo_roles: Dict[str, str],
-) -> List[dict]:
- triggers: List[dict] = []
+ interval_rules: list[dict],
+ power_rules: list[dict],
+ embryo_roles: dict[str, str],
+) -> list[dict]:
+ triggers: list[dict] = []
for r in interval_rules:
- triggers.append({
- "id": r["name"],
- "kind": "interval_rule",
- "label": _humanize_rule_name(r["name"]),
- "when_text": _interval_when_text(r),
- "then_text": _interval_then_text(r),
- "applies_to": _resolve_applies_to_roles(r.get("applies_to"), embryo_roles),
- "one_time": bool(r.get("one_time", True)),
- })
+ triggers.append(
+ {
+ "id": r["name"],
+ "kind": "interval_rule",
+ "label": _humanize_rule_name(r["name"]),
+ "when_text": _interval_when_text(r),
+ "then_text": _interval_then_text(r),
+ "applies_to": _resolve_applies_to_roles(r.get("applies_to"), embryo_roles),
+ "one_time": bool(r.get("one_time", True)),
+ }
+ )
for r in power_rules:
- triggers.append({
- "id": r["name"],
- "kind": "power_rule",
- "label": _humanize_rule_name(r["name"]),
- "when_text": _power_when_text(r),
- "then_text": _power_then_text(r),
- "applies_to": _resolve_applies_to_roles(r.get("applies_to"), embryo_roles),
- "one_time": bool(r.get("one_time", False)),
- })
+ triggers.append(
+ {
+ "id": r["name"],
+ "kind": "power_rule",
+ "label": _humanize_rule_name(r["name"]),
+ "when_text": _power_when_text(r),
+ "then_text": _power_then_text(r),
+ "applies_to": _resolve_applies_to_roles(r.get("applies_to"), embryo_roles),
+ "one_time": bool(r.get("one_time", False)),
+ }
+ )
return triggers
@@ -406,9 +419,9 @@ def _power_then_text(r: dict) -> str:
def _resolve_applies_to_roles(
- applies_to: Optional[List[str]],
- embryo_roles: Dict[str, str],
-) -> List[str]:
+ applies_to: list[str] | None,
+ embryo_roles: dict[str, str],
+) -> list[str]:
"""``applies_to`` is a list of embryo ids; resolve to a deduplicated
list of role names for the chips. ``None`` means "all roles in the
timelapse".
@@ -430,14 +443,14 @@ def _resolve_applies_to_roles(
# ---------------------------------------------------------------------------
-def _read_embryo_roles(session_dir: Path) -> Dict[str, str]:
+def _read_embryo_roles(session_dir: Path) -> dict[str, str]:
"""Map embryo_id -> role by scanning ``embryos/*/embryo.yaml``.
We read this from the durable per-embryo file rather than timelapse.yaml
so the role is correct even when the embryo isn't in the active
timelapse (yet).
"""
- out: Dict[str, str] = {}
+ out: dict[str, str] = {}
embryos_dir = session_dir / "embryos"
if not embryos_dir.is_dir():
return out
@@ -451,7 +464,7 @@ def _read_embryo_roles(session_dir: Path) -> Dict[str, str]:
return out
-def _stop_condition_from_serialized(d: Any) -> Tuple[str, str]:
+def _stop_condition_from_serialized(d: Any) -> tuple[str, str]:
"""Read the per-embryo stop_condition dict and return ``(spec, kind)``.
``kind`` is ``"bounded"`` when ANY component of the (possibly composite)
@@ -463,10 +476,10 @@ def _stop_condition_from_serialized(d: Any) -> Tuple[str, str]:
if not isinstance(d, dict):
return "manual", "open_ended"
spec = d.get("spec") or "manual"
- types: List[str] = []
+ types: list[str] = []
if d.get("condition_type"):
types.append(d["condition_type"])
- for ad in (d.get("additional") or []):
+ for ad in d.get("additional") or []:
if ad.get("condition_type"):
types.append(ad["condition_type"])
auto_stop = any(t != "manual" for t in types)
@@ -476,13 +489,13 @@ def _stop_condition_from_serialized(d: Any) -> Tuple[str, str]:
def _build_embryos_static(
*,
session_dir: Path,
- tl_embryos: Dict[str, dict],
- embryo_roles: Dict[str, str],
- dose_budget_base_ms: Optional[float],
+ tl_embryos: dict[str, dict],
+ embryo_roles: dict[str, str],
+ dose_budget_base_ms: float | None,
base_interval_s: float,
- started_at: Optional[datetime] = None,
- now_offset_s: Optional[float] = None,
-) -> List[dict]:
+ started_at: datetime | None = None,
+ now_offset_s: float | None = None,
+) -> list[dict]:
"""Build the per-embryo static portion of the snapshot.
Dynamic fields (phases, trigger_events, power_history_488) are seeded
@@ -493,7 +506,7 @@ def _build_embryos_static(
except Exception:
ROLE_REGISTRY = {}
- out: List[dict] = []
+ out: list[dict] = []
# Sort embryo ids so the snapshot is deterministic.
for eid in sorted(tl_embryos.keys()):
ed = tl_embryos[eid] or {}
@@ -503,9 +516,7 @@ def _build_embryos_static(
icon = _ROLE_ICONS.get(role_def.ui_icon if role_def else "circle", "●")
mult = role_def.photodose_budget_multiplier if role_def else 1.0
dose_budget_ms = (
- float(dose_budget_base_ms) * float(mult)
- if dose_budget_base_ms is not None
- else 0.0
+ float(dose_budget_base_ms) * float(mult) if dose_budget_base_ms is not None else 0.0
)
laser_488 = ed.get("laser_power_488_pct")
if laser_488 is None:
@@ -519,49 +530,47 @@ def _build_embryos_static(
stop_spec, stop_kind = _stop_condition_from_serialized(ed.get("stop_condition"))
# Seed: one base-cadence phase from t=0 until now (replay will
# split it as cadence_changed events come in).
- out.append({
- "id": eid,
- "role": role,
- "color": color,
- "icon": icon,
- "dose_used_ms": float(ed.get("total_exposure_ms") or 0.0),
- "dose_budget_ms": dose_budget_ms,
- "tp_acquired": int(ed.get("timepoints_acquired") or 0),
- "stop_condition": stop_spec,
- "stop_kind": stop_kind,
- "laser_488_pct_now": float(laser_488),
- "phases": [
- {
- "mode": "base",
- "start": 0.0,
- "end": None,
- "cadence_s": initial_cadence,
- }
- ],
- "trigger_events": [],
- "power_history_488": [
- {"at": 0.0, "pct": float(laser_488)}
- ],
- # Filled in by _project_forward.
- "projected_cadence_s": initial_cadence,
- "projected_end_s": None,
- # When the embryo was marked complete/terminated, as seconds
- # from session start. Null while still acquiring. The
- # frontend uses this to draw a TERMINATED cap and stop the
- # projection bar; without it, a finished embryo's row would
- # appear to still be acquiring forever.
- "terminated_at_s": _terminated_at_offset(
- ed, started_at, now_offset_s
- ),
- })
+ out.append(
+ {
+ "id": eid,
+ "role": role,
+ "color": color,
+ "icon": icon,
+ "dose_used_ms": float(ed.get("total_exposure_ms") or 0.0),
+ "dose_budget_ms": dose_budget_ms,
+ "tp_acquired": int(ed.get("timepoints_acquired") or 0),
+ "stop_condition": stop_spec,
+ "stop_kind": stop_kind,
+ "laser_488_pct_now": float(laser_488),
+ "phases": [
+ {
+ "mode": "base",
+ "start": 0.0,
+ "end": None,
+ "cadence_s": initial_cadence,
+ }
+ ],
+ "trigger_events": [],
+ "power_history_488": [{"at": 0.0, "pct": float(laser_488)}],
+ # Filled in by _project_forward.
+ "projected_cadence_s": initial_cadence,
+ "projected_end_s": None,
+ # When the embryo was marked complete/terminated, as seconds
+ # from session start. Null while still acquiring. The
+ # frontend uses this to draw a TERMINATED cap and stop the
+ # projection bar; without it, a finished embryo's row would
+ # appear to still be acquiring forever.
+ "terminated_at_s": _terminated_at_offset(ed, started_at, now_offset_s),
+ }
+ )
return out
def _terminated_at_offset(
ed: dict,
- started_at: Optional[datetime],
- now_offset_s: Optional[float],
-) -> Optional[float]:
+ started_at: datetime | None,
+ now_offset_s: float | None,
+) -> float | None:
"""Map an embryo's ``completed_at`` ISO timestamp into seconds-from-
session-start. Returns ``None`` if the embryo isn't complete yet or
we don't have the data to compute the offset.
@@ -590,14 +599,14 @@ def _terminated_at_offset(
def _resolve_timeline_paths(
session_dir: Path,
legacy_session_dir: Path,
-) -> List[Tuple[Path, bool]]:
+) -> list[tuple[Path, bool]]:
"""Return the timeline.jsonl paths to read, with a per-source flag.
The flag indicates whether the file is the global legacy timeline
(which mixes multiple sessions and must be filtered by session_id) or
a per-session file (no filtering needed).
"""
- paths: List[Tuple[Path, bool]] = []
+ paths: list[tuple[Path, bool]] = []
# Per-session (new) location.
p = session_dir / "timeline.jsonl"
if p.exists():
@@ -620,8 +629,8 @@ def _replay_timeline(
session_dir: Path,
legacy_session_dir: Path,
session_id: str,
- embryo_dicts: List[dict],
- triggers: List[dict],
+ embryo_dicts: list[dict],
+ triggers: list[dict],
started_at: datetime,
now_offset_s: float,
base_interval_s: float,
@@ -649,20 +658,19 @@ def _replay_timeline(
# We need to know each embryo's current cadence_s as we go (for the
# phase records). Seed from each embryo's initial phase.
- current_cadence: Dict[str, float] = {
- e["id"]: e["phases"][0].get("cadence_s", base_interval_s)
- for e in embryo_dicts
+ current_cadence: dict[str, float] = {
+ e["id"]: e["phases"][0].get("cadence_s", base_interval_s) for e in embryo_dicts
}
# Track last trigger_fired per (embryo, rule) so we can cluster
# consecutive fires into one event with a count.
- last_trigger: Dict[Tuple[str, str], dict] = {}
+ last_trigger: dict[tuple[str, str], dict] = {}
# Collect events from all sources, filtering global file by session_id.
- events: List[Tuple[datetime, dict]] = []
+ events: list[tuple[datetime, dict]] = []
seen_ids: set = set()
for path, is_global in paths:
try:
- with open(path, "r", encoding="utf-8") as f:
+ with open(path, encoding="utf-8") as f:
for line in f:
line = line.strip()
if not line or not line.startswith("{"):
@@ -711,12 +719,14 @@ def _replay_timeline(
pass
mode = _phase_mode_from_name(new_phase_name)
_close_open_phase(emb, at_s)
- emb["phases"].append({
- "mode": mode,
- "start": at_s,
- "end": None,
- "cadence_s": current_cadence.get(embryo_id, base_interval_s),
- })
+ emb["phases"].append(
+ {
+ "mode": mode,
+ "start": at_s,
+ "end": None,
+ "cadence_s": current_cadence.get(embryo_id, base_interval_s),
+ }
+ )
elif subtype == "power_changed" and embryo_id in by_id:
wavelength = data.get("wavelength")
@@ -726,10 +736,12 @@ def _replay_timeline(
if new_pct is None:
continue
emb = by_id[embryo_id]
- emb["power_history_488"].append({
- "at": at_s,
- "pct": float(new_pct),
- })
+ emb["power_history_488"].append(
+ {
+ "at": at_s,
+ "pct": float(new_pct),
+ }
+ )
emb["laser_488_pct_now"] = float(new_pct)
elif subtype == "trigger_fired" and embryo_id in by_id:
@@ -739,10 +751,7 @@ def _replay_timeline(
emb = by_id[embryo_id]
key = (embryo_id, rule_name)
prev = last_trigger.get(key)
- if (
- prev is not None
- and at_s - prev["at"] <= _TRIGGER_CLUSTER_GAP_S
- ):
+ if prev is not None and at_s - prev["at"] <= _TRIGGER_CLUSTER_GAP_S:
prev["count"] = prev.get("count", 1) + 1
prev["at"] = at_s # extend cluster to last fire
else:
@@ -755,13 +764,15 @@ def _replay_timeline(
mode = data.get("mode") or "1hz"
hz = 1.0 if mode == "1hz" else 20.0
_close_open_phase(emb, at_s)
- emb["phases"].append({
- "mode": "burst",
- "start": at_s,
- "end": None,
- "frames": int(data.get("frames") or 0),
- "hz": hz,
- })
+ emb["phases"].append(
+ {
+ "mode": "burst",
+ "start": at_s,
+ "end": None,
+ "frames": int(data.get("frames") or 0),
+ "hz": hz,
+ }
+ )
elif subtype == "burst_completed" and embryo_id in by_id:
emb = by_id[embryo_id]
@@ -795,7 +806,12 @@ def _ensure_tail_power(emb: dict, now_offset_s: float) -> None:
extends the steady segment to the right edge."""
hist = emb.get("power_history_488") or []
if not hist:
- emb["power_history_488"] = [{"at": now_offset_s, "pct": emb.get("laser_488_pct_now", _DEFAULT_INITIAL_POWER_PCT)}]
+ emb["power_history_488"] = [
+ {
+ "at": now_offset_s,
+ "pct": emb.get("laser_488_pct_now", _DEFAULT_INITIAL_POWER_PCT),
+ }
+ ]
return
if hist[-1]["at"] < now_offset_s:
hist.append({"at": now_offset_s, "pct": hist[-1]["pct"]})
@@ -820,7 +836,7 @@ def _phase_mode_from_name(name: str) -> str:
def _project_forward(
*,
- embryo_dicts: List[dict],
+ embryo_dicts: list[dict],
now_offset_s: float,
per_timepoint_ms: float,
) -> None:
@@ -851,7 +867,7 @@ def _project_forward(
def _compute_horizon(
now_offset_s: float,
- embryo_dicts: List[dict],
+ embryo_dicts: list[dict],
padding_s: float,
) -> float:
"""Pick a horizon that comfortably contains the past + projected future."""
diff --git a/gently/ui/web/templates/_header.html b/gently/ui/web/templates/_header.html
index d8f692e0..3f113590 100644
--- a/gently/ui/web/templates/_header.html
+++ b/gently/ui/web/templates/_header.html
@@ -25,6 +25,17 @@
${this.escapeHtml(s.name || s.session_id)}${s.active ? ' active' : ''}
${s.description ? `${this.escapeHtml(s.description)}
` : ''}
+ ${s.active ? '' : ``}
{% if is_live %}
{# SPA tabs — JS-driven via switchTab() in app.js #}
-
+
Home
+
Embryos
0
@@ -24,6 +25,7 @@
Sessions
{% else %}
{# Standalone pages — all tabs link back to the SPA #}
+ Home
Embryos
Calibration
System
diff --git a/gently/ui/web/templates/index.html b/gently/ui/web/templates/index.html
index dd3bbfb0..85a60345 100644
--- a/gently/ui/web/templates/index.html
+++ b/gently/ui/web/templates/index.html
@@ -14,12 +14,59 @@
+
{% include '_header.html' %}
{% include '_navbar.html' %}
+
+
+
+
+
+
+
+
-
+
Device
+
@@ -359,6 +432,20 @@
+
+ —
+
+
+
+
disconnected
Device
![bottom camera live frame]()
+
+
+
+
+
+
@@ -517,7 +632,9 @@ Properties
+
+
+
+
+
+
@@ -517,7 +632,9 @@