From fafb126814799cbcdd6780143625e689a1c5fafe Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 7 Sep 2025 19:15:50 +0000
Subject: [PATCH 1/8] Initial plan
From 9507b8bed7c8512a79aa5e99093235e9e1e0d5ea Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 7 Sep 2025 19:24:10 +0000
Subject: [PATCH 2/8] Implement enhanced stage calibration features with
calibration target support
Co-authored-by: beniroquai <4345528+beniroquai@users.noreply.github.com>
---
.../_test/api/test_stage_calibration.py | 251 +++++++
.../StageCenterCalibrationController.py | 617 +++++++++++++++++-
2 files changed, 867 insertions(+), 1 deletion(-)
create mode 100644 imswitch/imcontrol/_test/api/test_stage_calibration.py
diff --git a/imswitch/imcontrol/_test/api/test_stage_calibration.py b/imswitch/imcontrol/_test/api/test_stage_calibration.py
new file mode 100644
index 000000000..c47d08a33
--- /dev/null
+++ b/imswitch/imcontrol/_test/api/test_stage_calibration.py
@@ -0,0 +1,251 @@
+"""
+API tests for enhanced Stage Center Calibration functionality.
+Tests the new calibration target features including manual, automatic,
+maze navigation, stepsize and wellplate calibrations.
+"""
+import pytest
+import requests
+import time
+import json
+from typing import Dict, List, Any
+from ..api import api_server, base_url
+
+
+def test_stage_calibration_discovery(api_server):
+ """Test discovery of stage calibration endpoints."""
+ response = api_server.get("/openapi.json")
+ assert response.status_code == 200
+ spec = response.json()
+
+ # Find stage calibration related endpoints
+ paths = spec.get("paths", {})
+ calibration_endpoints = [p for p in paths.keys() if "StageCenterCalibration" in p]
+
+ if not calibration_endpoints:
+ pytest.skip("No stage calibration endpoints found in API")
+
+ print(f"Found {len(calibration_endpoints)} stage calibration endpoints")
+
+ # Test required endpoints are present
+ required_endpoints = [
+ "/StageCenterCalibrationController/setKnownPosition",
+ "/StageCenterCalibrationController/getCalibrationTargetInfo",
+ "/StageCenterCalibrationController/performAutomaticCalibration",
+ "/StageCenterCalibrationController/startMaze",
+ "/StageCenterCalibrationController/stopMaze",
+ "/StageCenterCalibrationController/performStepsizeCalibration",
+ "/StageCenterCalibrationController/perform384WellplateCalibration"
+ ]
+
+ for required in required_endpoints:
+ if required in calibration_endpoints:
+ print(f"✓ Required endpoint found: {required}")
+ else:
+ print(f"? Required endpoint missing: {required}")
+
+
+def test_calibration_target_info(api_server):
+ """Test calibration target information endpoint."""
+ endpoint = "/StageCenterCalibrationController/getCalibrationTargetInfo"
+
+ try:
+ response = api_server.get(endpoint)
+ if response.status_code == 200:
+ data = response.json()
+
+ # Check required fields
+ required_fields = [
+ "width_mm", "height_mm", "frontside_svg", "backside_svg",
+ "calibration_center", "maze_start", "stepsize_grid", "wellplate_start"
+ ]
+
+ for field in required_fields:
+ assert field in data, f"Missing required field: {field}"
+ print(f"✓ Found field: {field}")
+
+ # Validate SVG content
+ assert ".
\ No newline at end of file
diff --git a/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py b/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py
index 5559f8170..d03c9ffca 100644
--- a/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py
+++ b/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py
@@ -5,6 +5,7 @@
import numpy as np
import tifffile as tif
+import cv2
from imswitch import IS_HEADLESS
from imswitch.imcommon.framework import Signal, Mutex
@@ -34,12 +35,30 @@ def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._logger = initLogger(self)
-
# state
self._task = None
self._is_running = False
self._positions: list[tuple[float, float]] = []
self._run_mutex = Mutex()
+
+ # Calibration target constants (in mm)
+ self.CALIBRATION_CENTER_X = 63.81
+ self.CALIBRATION_CENTER_Y = 42.06
+ self.MAZE_START_X = 9.5
+ self.MAZE_START_Y = 11.5
+ self.STEPSIZE_GRID_X = 105.0
+ self.STEPSIZE_GRID_Y = 16.0
+ self.WELLPLATE_START_X = 12.2
+ self.WELLPLATE_START_Y = 9.0
+ self.WELLPLATE_SPACING = 4.5 # mm
+
+ # Calibration target dimensions (in mm)
+ self.TARGET_WIDTH = 127.76
+ self.TARGET_HEIGHT = 85.48
+
+ # Maze navigation state
+ self._maze_running = False
+ self._maze_positions = []
# ───────────────────────────── API ──────────────────────────────────────
def getDetector(self):
@@ -163,6 +182,602 @@ def stopCalibration(self):
self._task.join()
self._task = None
self._logger.info("Calibration stopped.")
+
+ @APIExport()
+ def setKnownPosition(self, x_mm: float = None, y_mm: float = None):
+ """
+ Manually set the stage offset to a known position.
+ If no coordinates provided, uses the calibration center (63.81, 42.06).
+ """
+ if x_mm is None:
+ x_mm = self.CALIBRATION_CENTER_X
+ if y_mm is None:
+ y_mm = self.CALIBRATION_CENTER_Y
+
+ stage = self.getStage()
+ current_pos = stage.getPosition()
+
+ # Set stage offset for both axes
+ stage.setStageOffsetAxis(knownPosition=x_mm * 1000, currentPosition=current_pos["X"], axis="X") # Convert mm to µm
+ stage.setStageOffsetAxis(knownPosition=y_mm * 1000, currentPosition=current_pos["Y"], axis="Y") # Convert mm to µm
+
+ self._logger.info(f"Stage offset set to known position: X={x_mm}mm, Y={y_mm}mm")
+ return {"status": "success", "x_mm": x_mm, "y_mm": y_mm}
+
+ @APIExport()
+ def performAutomaticCalibration(self, laser_name: str = None, laser_intensity: float = 50.0) -> dict:
+ """
+ Automatic calibration using line detection with Hough transform.
+ Homes the stage, moves to 30mm offset, searches for white lines, then finds center ring.
+ """
+ if self._is_running:
+ return {"status": "error", "message": "Calibration already running"}
+
+ self._is_running = True
+ try:
+ stage = self.getStage()
+
+ # Home the stage in X and Y
+ self._logger.info("Homing stage...")
+ stage.home("X")
+ stage.home("Y")
+
+ # Move to 30mm offset position
+ self._logger.info("Moving to 30mm offset position...")
+ stage.move("X", 30000, True, True) # 30mm in µm
+ stage.move("Y", 30000, True, True)
+
+ # Turn on laser if specified
+ if laser_name:
+ try:
+ laser_controller = self._master.lasersManager.get(laser_name)
+ if laser_controller:
+ laser_controller.setLaserValue(laser_intensity)
+ laser_controller.setLaserActive(True)
+ self._logger.info(f"Laser {laser_name} activated at {laser_intensity}")
+ except Exception as e:
+ self._logger.warning(f"Could not activate laser {laser_name}: {e}")
+
+ # Search for white lines
+ center_position = self._findCalibrationCenter()
+
+ if center_position:
+ # Set the known position offset
+ self.setKnownPosition(self.CALIBRATION_CENTER_X, self.CALIBRATION_CENTER_Y)
+ return {"status": "success", "center": center_position}
+ else:
+ return {"status": "error", "message": "Could not find calibration center"}
+
+ except Exception as e:
+ self._logger.error(f"Automatic calibration failed: {e}")
+ return {"status": "error", "message": str(e)}
+ finally:
+ self._is_running = False
+ # Turn off laser if it was turned on
+ if laser_name:
+ try:
+ laser_controller = self._master.lasersManager.get(laser_name)
+ if laser_controller:
+ laser_controller.setLaserActive(False)
+ except Exception:
+ pass
+
+ @APIExport()
+ def getCalibrationTargetInfo(self) -> dict:
+ """
+ Returns information about the calibration target including SVG representation.
+ """
+ frontside_svg = f'''
+
+ '''
+
+ backside_svg = f'''
+
+ '''
+
+ return {
+ "width_mm": self.TARGET_WIDTH,
+ "height_mm": self.TARGET_HEIGHT,
+ "frontside_svg": frontside_svg,
+ "backside_svg": backside_svg,
+ "calibration_center": {"x": self.CALIBRATION_CENTER_X, "y": self.CALIBRATION_CENTER_Y},
+ "maze_start": {"x": self.MAZE_START_X, "y": self.MAZE_START_Y},
+ "stepsize_grid": {"x": self.STEPSIZE_GRID_X, "y": self.STEPSIZE_GRID_Y},
+ "wellplate_start": {"x": self.WELLPLATE_START_X, "y": self.WELLPLATE_START_Y, "spacing": self.WELLPLATE_SPACING}
+ }
+
+ @APIExport()
+ def startMaze(self, custom_path: list = None) -> dict:
+ """
+ Start maze navigation from position (9.5, 11.5) with 1000µm steps.
+ Saves images as TIFF stack during navigation.
+ """
+ if self._maze_running:
+ return {"status": "error", "message": "Maze already running"}
+
+ self._maze_running = True
+ self._maze_positions = []
+
+ # Default maze path (can be customized)
+ if custom_path is None:
+ custom_path = [
+ (0, 0), (1, 0), (2, 0), (2, 1), (2, 2), (1, 2), (0, 2), (0, 1), # Simple square path
+ (1, 1) # End at center
+ ]
+
+ try:
+ stage = self.getStage()
+
+ # Move to maze start position
+ start_x_um = self.MAZE_START_X * 1000 # Convert mm to µm
+ start_y_um = self.MAZE_START_Y * 1000
+ stage.move("X", start_x_um, True, True)
+ stage.move("Y", start_y_um, True, True)
+
+ # Start maze navigation in separate thread
+ self._task = threading.Thread(target=self._navigateMaze, args=(custom_path,), daemon=True)
+ self._task.start()
+
+ return {"status": "started", "path_length": len(custom_path)}
+
+ except Exception as e:
+ self._maze_running = False
+ self._logger.error(f"Failed to start maze navigation: {e}")
+ return {"status": "error", "message": str(e)}
+
+ @APIExport()
+ def stopMaze(self) -> dict:
+ """Stop maze navigation."""
+ self._maze_running = False
+ if self._task is not None:
+ self._task.join()
+ self._task = None
+ self._logger.info("Maze navigation stopped.")
+ return {"status": "stopped", "positions_visited": len(self._maze_positions)}
+
+ @APIExport()
+ def getMazeStatus(self) -> dict:
+ """Get current maze navigation status."""
+ return {
+ "running": self._maze_running,
+ "positions_visited": len(self._maze_positions),
+ "current_position": self._maze_positions[-1] if self._maze_positions else None
+ }
+
+ @APIExport()
+ def performStepsizeCalibration(self) -> dict:
+ """
+ Perform stepsize calibration using 7x7 hole lattice at (105, 16) with 1mm spacing.
+ Captures images at each hole position and saves as TIFF stack.
+ """
+ if self._is_running:
+ return {"status": "error", "message": "Another calibration is running"}
+
+ self._is_running = True
+ try:
+ stage = self.getStage()
+ detector = self.getDetector()
+
+ # Move to starting position
+ start_x_um = self.STEPSIZE_GRID_X * 1000 # Convert mm to µm
+ start_y_um = self.STEPSIZE_GRID_Y * 1000
+
+ images = []
+ positions = []
+
+ # Scan 7x7 grid
+ for i in range(7):
+ for j in range(7):
+ if not self._is_running:
+ break
+
+ # Calculate position (1mm = 1000µm spacing)
+ x_pos = start_x_um + (i * 1000)
+ y_pos = start_y_um + (j * 1000)
+
+ # Move to position
+ stage.move("X", x_pos, True, True)
+ stage.move("Y", y_pos, True, True)
+
+ # Capture image
+ time.sleep(0.1) # Allow settling
+ frame = detector.getLatestFrame()
+ if frame is not None:
+ images.append(frame)
+ positions.append((x_pos, y_pos))
+ self._logger.debug(f"Captured image at grid position ({i}, {j})")
+
+ # Save TIFF stack
+ if images:
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ dir_path = os.path.join(os.path.expanduser("~"), "imswitch_calibrations", timestamp)
+ os.makedirs(dir_path, exist_ok=True)
+
+ stack_path = os.path.join(dir_path, "stepsize_calibration_stack.tiff")
+ tif.imwrite(stack_path, np.array(images))
+
+ positions_path = os.path.join(dir_path, "stepsize_positions.csv")
+ np.savetxt(positions_path, np.array(positions), delimiter=",", header="X(µm),Y(µm)")
+
+ self._logger.info(f"Stepsize calibration completed. {len(images)} images saved to {stack_path}")
+ return {
+ "status": "success",
+ "images_captured": len(images),
+ "tiff_stack_path": stack_path,
+ "positions_path": positions_path
+ }
+ else:
+ return {"status": "error", "message": "No images captured"}
+
+ except Exception as e:
+ self._logger.error(f"Stepsize calibration failed: {e}")
+ return {"status": "error", "message": str(e)}
+ finally:
+ self._is_running = False
+
+ @APIExport()
+ def perform384WellplateCalibration(self, sample_wells: list = None) -> dict:
+ """
+ Perform 384 wellplate calibration on backside pattern.
+ Scans random positions of wells A1-P24 and compares center positions.
+ """
+ if self._is_running:
+ return {"status": "error", "message": "Another calibration is running"}
+
+ self._is_running = True
+ try:
+ stage = self.getStage()
+ detector = self.getDetector()
+
+ # Default sample wells if none provided
+ if sample_wells is None:
+ # Sample some wells across the plate
+ sample_wells = ["A1", "A12", "A24", "H1", "H12", "H24", "P1", "P12", "P24"]
+
+ images = []
+ positions = []
+ well_info = []
+
+ for well in sample_wells:
+ if not self._is_running:
+ break
+
+ # Parse well coordinate (e.g., "A1" -> row=0, col=0)
+ row = ord(well[0]) - ord('A') # A=0, B=1, ..., P=15
+ col = int(well[1:]) - 1 # 1=0, 2=1, ..., 24=23
+
+ if row > 15 or col > 23: # Validate well coordinates
+ self._logger.warning(f"Invalid well coordinate: {well}")
+ continue
+
+ # Calculate position
+ x_pos = (self.WELLPLATE_START_X + col * self.WELLPLATE_SPACING) * 1000 # Convert to µm
+ y_pos = (self.WELLPLATE_START_Y + row * self.WELLPLATE_SPACING) * 1000
+
+ # Move to position
+ stage.move("X", x_pos, True, True)
+ stage.move("Y", y_pos, True, True)
+
+ # Capture image
+ time.sleep(0.1) # Allow settling
+ frame = detector.getLatestFrame()
+ if frame is not None:
+ images.append(frame)
+ positions.append((x_pos, y_pos))
+ well_info.append({"well": well, "row": row, "col": col, "x": x_pos, "y": y_pos})
+ self._logger.debug(f"Captured image at well {well}")
+
+ # Save TIFF stack and data
+ if images:
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ dir_path = os.path.join(os.path.expanduser("~"), "imswitch_calibrations", timestamp)
+ os.makedirs(dir_path, exist_ok=True)
+
+ stack_path = os.path.join(dir_path, "wellplate_384_calibration_stack.tiff")
+ tif.imwrite(stack_path, np.array(images))
+
+ positions_path = os.path.join(dir_path, "wellplate_positions.csv")
+ np.savetxt(positions_path, np.array(positions), delimiter=",", header="X(µm),Y(µm)")
+
+ # Save well information as JSON
+ import json
+ wells_path = os.path.join(dir_path, "wellplate_wells.json")
+ with open(wells_path, 'w') as f:
+ json.dump(well_info, f, indent=2)
+
+ self._logger.info(f"384 wellplate calibration completed. {len(images)} wells scanned.")
+ return {
+ "status": "success",
+ "wells_scanned": len(images),
+ "tiff_stack_path": stack_path,
+ "positions_path": positions_path,
+ "wells_info_path": wells_path,
+ "wells": well_info
+ }
+ else:
+ return {"status": "error", "message": "No images captured"}
+
+ except Exception as e:
+ self._logger.error(f"384 wellplate calibration failed: {e}")
+ return {"status": "error", "message": str(e)}
+ finally:
+ self._is_running = False
+
+ # ─────────────────────── new calibration helpers ───────────────────────
+
+ def _findCalibrationCenter(self) -> tuple:
+ """
+ Find calibration center using line detection and ring positioning.
+ Returns (x, y) coordinates in micrometers or None if not found.
+ """
+ stage = self.getStage()
+ detector = self.getDetector()
+
+ # Step 1: Search for white lines in X direction
+ self._logger.info("Searching for white lines in X direction...")
+ line_found_x = None
+
+ for i in range(50): # Max 50 steps of 1000µm = 50mm search
+ if not self._is_running:
+ return None
+
+ # Move 1000µm in X direction
+ current_pos = stage.getPosition()
+ new_x = current_pos["X"] + 1000
+ stage.move("X", new_x, True, True)
+
+ # Take image and check for lines
+ time.sleep(0.1)
+ frame = detector.getLatestFrame()
+ if frame is not None and self._detectWhiteLine(frame):
+ line_found_x = new_x
+ self._logger.info(f"White line found in X at position {new_x}")
+ break
+
+ if line_found_x is None:
+ self._logger.error("No white line found in X direction")
+ return None
+
+ # Step 2: Search for white lines in Y direction
+ self._logger.info("Searching for white lines in Y direction...")
+ line_found_y = None
+
+ for i in range(50): # Max 50 steps
+ if not self._is_running:
+ return None
+
+ # Move 1000µm in Y direction
+ current_pos = stage.getPosition()
+ new_y = current_pos["Y"] + 1000
+ stage.move("Y", new_y, True, True)
+
+ # Take image and check for lines
+ time.sleep(0.1)
+ frame = detector.getLatestFrame()
+ if frame is not None and self._detectWhiteLine(frame):
+ line_found_y = new_y
+ self._logger.info(f"White line found in Y at position {new_y}")
+ break
+
+ if line_found_y is None:
+ self._logger.error("No white line found in Y direction")
+ return None
+
+ # Step 3: Continue alternating until center is bright
+ self._logger.info("Searching for bright center...")
+ baseline_intensity = self._grabMeanFrame()
+
+ for iteration in range(20): # Max iterations to find center
+ if not self._is_running:
+ return None
+
+ # Move in X direction and check intensity
+ current_pos = stage.getPosition()
+ stage.move("X", current_pos["X"] + 1000, True, True)
+ time.sleep(0.1)
+
+ intensity = self._grabMeanFrame()
+ if intensity and baseline_intensity and intensity > baseline_intensity * 2.0:
+ self._logger.info("High intensity detected - near center")
+
+ # Step 4: Look for rings and center on them
+ center_pos = self._findRingCenter()
+ if center_pos:
+ return center_pos
+
+ # Move in Y direction and check intensity
+ current_pos = stage.getPosition()
+ stage.move("Y", current_pos["Y"] + 1000, True, True)
+ time.sleep(0.1)
+
+ intensity = self._grabMeanFrame()
+ if intensity and baseline_intensity and intensity > baseline_intensity * 2.0:
+ self._logger.info("High intensity detected - near center")
+
+ # Look for rings and center on them
+ center_pos = self._findRingCenter()
+ if center_pos:
+ return center_pos
+
+ # If we reach here, return current position as best guess
+ final_pos = stage.getPosition()
+ return (final_pos["X"], final_pos["Y"])
+
+ def _detectWhiteLine(self, image: np.ndarray) -> bool:
+ """
+ Detect white lines in image using Hough transform.
+ Returns True if lines are detected.
+ """
+ try:
+ # Convert to grayscale if needed
+ if len(image.shape) == 3:
+ gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+ else:
+ gray = image.astype(np.uint8)
+
+ # Apply edge detection
+ edges = cv2.Canny(gray, 50, 150, apertureSize=3)
+
+ # Apply Hough line transform
+ lines = cv2.HoughLines(edges, 1, np.pi/180, threshold=100)
+
+ return lines is not None and len(lines) > 0
+
+ except Exception as e:
+ self._logger.error(f"Line detection failed: {e}")
+ return False
+
+ def _findRingCenter(self) -> tuple:
+ """
+ Find center of rings using Hough circle transform.
+ Returns (x, y) stage coordinates or None if not found.
+ """
+ try:
+ detector = self.getDetector()
+ frame = detector.getLatestFrame()
+ if frame is None:
+ return None
+
+ # Convert to grayscale if needed
+ if len(frame.shape) == 3:
+ gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+ else:
+ gray = frame.astype(np.uint8)
+
+ # Apply Gaussian blur
+ blurred = cv2.GaussianBlur(gray, (9, 9), 2)
+
+ # Detect circles using Hough transform
+ circles = cv2.HoughCircles(
+ blurred,
+ cv2.HOUGH_GRADIENT,
+ dp=1,
+ minDist=30,
+ param1=50,
+ param2=30,
+ minRadius=10,
+ maxRadius=100
+ )
+
+ if circles is not None and len(circles[0]) > 0:
+ # Find the largest circle (assuming it's the calibration ring)
+ circles = np.round(circles[0, :]).astype("int")
+ largest_circle = max(circles, key=lambda c: c[2]) # Max by radius
+
+ center_x, center_y, radius = largest_circle
+ self._logger.info(f"Ring found at image coordinates ({center_x}, {center_y}) with radius {radius}")
+
+ # Convert image coordinates to stage offset
+ # This is a simplified approach - in practice, you'd need proper calibration
+ stage = self.getStage()
+ current_pos = stage.getPosition()
+
+ # Calculate offset needed to center the ring (simplified pixel-to-micron conversion)
+ image_center_x = gray.shape[1] // 2
+ image_center_y = gray.shape[0] // 2
+
+ # Assume 1 pixel = 1 micrometer (this should be calibrated properly)
+ offset_x = (center_x - image_center_x) * 1.0 # Adjust this scaling factor
+ offset_y = (center_y - image_center_y) * 1.0
+
+ # Move stage to center the ring
+ target_x = current_pos["X"] - offset_x # Negative because stage moves opposite to image
+ target_y = current_pos["Y"] - offset_y
+
+ stage.move("X", target_x, True, True)
+ stage.move("Y", target_y, True, True)
+
+ final_pos = stage.getPosition()
+ return (final_pos["X"], final_pos["Y"])
+
+ return None
+
+ except Exception as e:
+ self._logger.error(f"Ring detection failed: {e}")
+ return None
+
+ def _navigateMaze(self, path: list):
+ """
+ Navigate through maze path, capturing images at each position.
+ """
+ stage = self.getStage()
+ detector = self.getDetector()
+
+ images = []
+ positions = []
+
+ try:
+ for step_idx, (dx, dy) in enumerate(path):
+ if not self._maze_running:
+ break
+
+ # Calculate target position (1000µm steps)
+ start_x = self.MAZE_START_X * 1000
+ start_y = self.MAZE_START_Y * 1000
+ target_x = start_x + (dx * 1000)
+ target_y = start_y + (dy * 1000)
+
+ # Move to position
+ stage.move("X", target_x, True, True)
+ stage.move("Y", target_y, True, True)
+
+ # Capture image
+ time.sleep(0.1) # Allow settling
+ frame = detector.getLatestFrame()
+ if frame is not None:
+ images.append(frame)
+ positions.append((target_x, target_y))
+ self._maze_positions.append((target_x, target_y))
+ self._logger.debug(f"Maze step {step_idx + 1}/{len(path)}: moved to ({target_x}, {target_y})")
+
+ # Save TIFF stack
+ if images:
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ dir_path = os.path.join(os.path.expanduser("~"), "imswitch_calibrations", timestamp)
+ os.makedirs(dir_path, exist_ok=True)
+
+ stack_path = os.path.join(dir_path, "maze_navigation_stack.tiff")
+ tif.imwrite(stack_path, np.array(images))
+
+ positions_path = os.path.join(dir_path, "maze_positions.csv")
+ np.savetxt(positions_path, np.array(positions), delimiter=",", header="X(µm),Y(µm)")
+
+ self._logger.info(f"Maze navigation completed. {len(images)} images saved to {stack_path}")
+
+ except Exception as e:
+ self._logger.error(f"Maze navigation failed: {e}")
+ finally:
+ self._maze_running = False
+
# ─────────────────────── helpers ────────────────────────────────────────
def _grabMeanFrame(self):
From fc7003c8c0aba26a84c5e1c6e21005bbab40a821 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 7 Sep 2025 19:27:22 +0000
Subject: [PATCH 3/8] Add robust error handling and documentation for enhanced
stage calibration
Co-authored-by: beniroquai <4345528+beniroquai@users.noreply.github.com>
---
.../StageCenterCalibrationController.py | 20 +++++++++++--------
1 file changed, 12 insertions(+), 8 deletions(-)
diff --git a/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py b/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py
index d03c9ffca..4befd81e4 100644
--- a/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py
+++ b/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py
@@ -230,11 +230,14 @@ def performAutomaticCalibration(self, laser_name: str = None, laser_intensity: f
# Turn on laser if specified
if laser_name:
try:
- laser_controller = self._master.lasersManager.get(laser_name)
- if laser_controller:
- laser_controller.setLaserValue(laser_intensity)
- laser_controller.setLaserActive(True)
- self._logger.info(f"Laser {laser_name} activated at {laser_intensity}")
+ if hasattr(self._master, 'lasersManager'):
+ laser_controller = self._master.lasersManager.get(laser_name)
+ if laser_controller:
+ laser_controller.setLaserValue(laser_intensity)
+ laser_controller.setLaserActive(True)
+ self._logger.info(f"Laser {laser_name} activated at {laser_intensity}")
+ else:
+ self._logger.warning("Laser manager not available")
except Exception as e:
self._logger.warning(f"Could not activate laser {laser_name}: {e}")
@@ -256,9 +259,10 @@ def performAutomaticCalibration(self, laser_name: str = None, laser_intensity: f
# Turn off laser if it was turned on
if laser_name:
try:
- laser_controller = self._master.lasersManager.get(laser_name)
- if laser_controller:
- laser_controller.setLaserActive(False)
+ if hasattr(self._master, 'lasersManager'):
+ laser_controller = self._master.lasersManager.get(laser_name)
+ if laser_controller:
+ laser_controller.setLaserActive(False)
except Exception:
pass
From ad058dd3cc95cd230a1d648d93392295dd2d98c9 Mon Sep 17 00:00:00 2001
From: beniroquai
Date: Mon, 8 Sep 2025 13:21:24 +0200
Subject: [PATCH 4/8] Add calibration SVGs and update controllers
Added calibration_back.svg and calibration_front.svg images. Updated HistoScanController, StageCenterCalibrationController, and VirtualStageManager to support new calibration features and image references.
---
imswitch/_data/images/calibration_back.svg | 7330 +++++++++
imswitch/_data/images/calibration_front.svg | 13533 ++++++++++++++++
.../controllers/HistoScanController.py | 2 +-
.../StageCenterCalibrationController.py | 108 +-
.../positioners/VirtualStageManager.py | 29 +-
5 files changed, 20965 insertions(+), 37 deletions(-)
create mode 100644 imswitch/_data/images/calibration_back.svg
create mode 100644 imswitch/_data/images/calibration_front.svg
diff --git a/imswitch/_data/images/calibration_back.svg b/imswitch/_data/images/calibration_back.svg
new file mode 100644
index 000000000..51a9c9208
--- /dev/null
+++ b/imswitch/_data/images/calibration_back.svg
@@ -0,0 +1,7330 @@
+
+
+
+
diff --git a/imswitch/_data/images/calibration_front.svg b/imswitch/_data/images/calibration_front.svg
new file mode 100644
index 000000000..f1ae5a38a
--- /dev/null
+++ b/imswitch/_data/images/calibration_front.svg
@@ -0,0 +1,13533 @@
+
+
+
+
diff --git a/imswitch/imcontrol/controller/controllers/HistoScanController.py b/imswitch/imcontrol/controller/controllers/HistoScanController.py
index d6e3960b9..d2791e202 100644
--- a/imswitch/imcontrol/controller/controllers/HistoScanController.py
+++ b/imswitch/imcontrol/controller/controllers/HistoScanController.py
@@ -494,7 +494,7 @@ def fetchStageMap(self, resizeFactor:float=1, mapID:int=0):
return Response(im_bytes, headers=headers, media_type='image/png')
@APIExport(runOnUIThread=False)
- def getSampleLayoutFilePaths(self):
+ def getSampleLayoutFilePaths(self) -> list:
# return the paths of the sample layouts
# images are provided via imswitchserver
_baseDataFilesDir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '_data')
diff --git a/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py b/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py
index 4befd81e4..1d2196fc7 100644
--- a/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py
+++ b/imswitch/imcontrol/controller/controllers/StageCenterCalibrationController.py
@@ -114,8 +114,8 @@ def getIsCalibrationRunning(self):
# ──────────────────────────── worker ────────────────────────────────────
def _worker(self, cx, cy, speed, step_um, max_r, bf):
- self.getStage().move("X", cx, True, True)
- self.getStage().move("Y", cy, True, True)
+ self.getStage().move(axis="X", value=cx, is_absolute=True, is_blocking=True)
+ self.getStage().move(axis="Y", value=cy, is_absolute=True, is_blocking=True)
baseline = self._grabMeanFrame()
if baseline is None:
@@ -210,6 +210,15 @@ def performAutomaticCalibration(self, laser_name: str = None, laser_intensity: f
Automatic calibration using line detection with Hough transform.
Homes the stage, moves to 30mm offset, searches for white lines, then finds center ring.
"""
+ self.performAutomaticCalibrationInThread = threading.Thread(
+ target=self._performAutomaticCalibrationForThread,
+ args=(laser_name, laser_intensity),
+ daemon=True,
+ )
+ self.performAutomaticCalibrationInThread.start()
+ return {"status": "started"}
+
+ def _performAutomaticCalibrationForThread(self, laser_name: str = None, laser_intensity: float = 50.0) -> dict:
if self._is_running:
return {"status": "error", "message": "Calibration already running"}
@@ -217,15 +226,19 @@ def performAutomaticCalibration(self, laser_name: str = None, laser_intensity: f
try:
stage = self.getStage()
+
# Home the stage in X and Y
+ self.getStage().resetStageOffsetAxis(axis="X")
+ self.getStage().resetStageOffsetAxis(axis="Y")
+
self._logger.info("Homing stage...")
- stage.home("X")
- stage.home("Y")
+ stage.home_x()
+ stage.home_y()
# Move to 30mm offset position
self._logger.info("Moving to 30mm offset position...")
- stage.move("X", 30000, True, True) # 30mm in µm
- stage.move("Y", 30000, True, True)
+ stage.move(axis="X", value=30000, is_absolute=True, is_blocking=True) # 30mm in µm
+ stage.move(axis="Y", value=30000, is_absolute=True, is_blocking=True)
# Turn on laser if specified
if laser_name:
@@ -270,7 +283,12 @@ def performAutomaticCalibration(self, laser_name: str = None, laser_intensity: f
def getCalibrationTargetInfo(self) -> dict:
"""
Returns information about the calibration target including SVG representation.
+ SVG files are served from disk via the ImSwitch server.
"""
+ # Get SVG files from disk
+ svg_files = self._getCalibrationSVGFiles()
+
+ # Generate fallback SVG content if files are not found
frontside_svg = f'''