imswitchclient 0.1.8__tar.gz → 0.2.0__tar.gz

{imswitchclient-0.1.8/imswitchclient.egg-info → imswitchclient-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imswitchclient
-Version: 0.1.8
+Version: 0.2.0
 Summary: This is a package that connects ImSwitch's REST API to the rest of the world (e.g. jupyter lab)
 Home-page: https://github.com/openuc2/imswitchclient
 Author: Benedict Diederich
@@ -175,18 +175,30 @@ The ImSwitch API provides access to various components:
 - `getAllDeviceNames()` - Get all available positioners.
 - `getPositionerPositions()` - Get current position.
 - `movePositioner(name, axis, value, is_absolute, is_blocking)` - Move the stage.
+- `moveRelativeXY(dx, dy, positioner_name, is_blocking, speed)` - Relative X/Y move in µm.
+- `stop(name, axis)` / `stopAllAxes(name)` - Stop one axis / every axis.
 - `homeAxis(name, axis, is_blocking)` - Home the positioner.
 
 ### Lasers Manager
 - `getLaserNames()` - Get available lasers.
 - `setLaserActive(name, status)` - Turn laser on/off.
 - `setLaserValue(name, value)` - Set laser intensity.
+- `getLaserValueRanges(name)` / `getLaserValue(name)` / `getLaserActive(name)` - Read back.
+- `setLaserOn(name, value)` / `setLaserOff(name)` - Value and on/off in one call.
+- `runLaserFor(name, value, duration, on_tick, stop_event)` - Run a PWM channel (pump, valve)
+  for a fixed time; always switched off afterwards, also on errors or interruption.
 
 ### Recording Manager
 - `snapNumpyToFastAPI(resizeFactor)` - Capture an image as numpy array.
 - `startRecording(save_format)` - Begin recording with optional save format (SaveFormat enum).
 - `stopRecording()` - Stop recording.
-- `snapImageToPath(file_name)` - Snap image and save to specified path.
+- `snapImageToPath(file_name, save_format, return_preview)` - Snap image and save to specified path.
+- `snapAndWait(file_name, save_format, poll, timeout, on_progress, stop_event)` - Snap in the
+  background on the server and wait for it. Use for long exposures (minutes to hours); an
+  interrupt, `stop_event` or timeout cancels the exposure on the server.
+- `startSnap(...)` / `getSnapStatus(job_id)` / `cancelSnap(job_id)` - The same, step by step.
+- `previewToNumpy(result)` - 8-bit preview of a snap result as numpy array.
+- `downloadImage(relative_file_path)` / `downloadFile(...)` - Fetch the saved file (full bit depth).
 - `startVideoStream()` - Start MJPEG video stream.
 - `stopVideoStream()` - Stop MJPEG video stream.
 - `getVideoFrame()` - Get current frame from video stream.
@@ -199,6 +211,7 @@ The recording manager supports multiple save formats:
 - `SaveFormat.MP4` - MP4 video format
 - `SaveFormat.PNG` - PNG format
 - `SaveFormat.JPG` - JPEG format
+- `SaveFormat.OME_TIFF`, `SaveFormat.OME_ZARR`, `SaveFormat.STITCHED_TIFF`
 
 ### Settings Manager
 - `getDetectorNames()` - Get available detector names.
@@ -207,6 +220,25 @@ The recording manager supports multiple save formats:
 - `setDetectorGain(detector_name, gain)` - Set detector gain.
 - `setDetectorParameter(detector_name, parameter_name, value)` - Set generic detector parameter.
 - `setDetectorROI(detector_name, x, y, w, h)` - Set detector Region of Interest.
+- `getDetectorParameter(parameter_name, detector_name)` - Read one parameter from the camera.
+- `setDetectorMode(detector_name, is_auto)` / `setDetectorExposureOnce(detector_name)` - Auto exposure.
+- `getCameraTemperature(detector_name)` / `setCameraTargetTemperature(temperature_c)` - Cooled cameras.
+- `getDetectorParameterTree(detector_name)` / `setDetectorParameterValue(name, value)` - Typed access
+  to every camera parameter.
+
+### Live View Manager
+- `startLiveView(detector_name, protocol, params, force)` / `stopLiveView(detector_name)`
+- `getLiveViewActive()`, `getActiveStreams()`, `getLongExposureInfo(detector_name)`
+
+### UC2 Config Manager
+- `getBusStatus()` - CAN-bus power and emergency-stop state.
+- `setBusPower(enable)` / `setBusPowerAndWait(enable, settle)` - Switch the power of all CAN
+  slave boards (motors, LED/laser boards). Raises if the board refuses.
+- `isBoardConnected()`, `getBoardTemperature()`
+
+### Autofocus Manager
+- `autoFocusAndWait(rangez, resolutionz, ...)` - Server-side Z scan around the current focus,
+  waits for the result. `autoFocus`, `getAutofocusStatus`, `stopAutofocus` for manual control.
 
 ### View Manager
 - `setLiveViewActive(active)` - Enable/disable live view.
@@ -221,6 +253,30 @@ The recording manager supports multiple save formats:
 - `setLED(led_id, state)` - Set specific LED with ID and state.
 - `setSpecial(pattern, intensity, get_return)` - Set special LED pattern.
 
+### Smart microscopy helpers (`imswitchclient.smart`)
+Building blocks for closed-loop experiments; they work on numpy frames and plain callables and are
+tested without a microscope (`tests/test_smart.py`).
+
+```python
+from imswitchclient import smart
+snap = smart.make_snap(client)                    # -> float32 frame
+move = smart.make_relative_mover(client)          # move(dx_um, dy_um), blocking
+
+cal = smart.StageCameraCalibration.measure(snap, move, step_um=50)
+obj = smart.find_objects(snap())[0]               # largest blob
+move(*cal.move_to_center(*obj["offset"]))         # centre it - rotation and flips included
+```
+
+- `StageCameraCalibration` - pixel offsets <-> stage moves, measured on the live images.
+- `phase_correlate(a, b)` - sub-pixel image shift.
+- `find_objects(frame)` / `foreground_mask(frame)` - blob detection.
+- `EmptyFieldReference(empty_frame).coverage(frame)` - how much of a field is sample (0..1).
+- `SafetyBox` - limits closed-loop moves to a square around the start.
+- `Mosaic(frames, positions, cal)` - quick overview of frames placed by stage position.
+
+The ImSwitch notebooks `ImSwitch_Smart_ObjectTracking`, `ImSwitch_Smart_PathFollowing` and
+`ImSwitch_Smart_AdaptiveImaging` show them in use.
+
 ### Communication Manager
 - `acquireImage()` - Acquire an image through communication channel.
 - `getImage()` - Get an image from communication channel.

{imswitchclient-0.1.8 → imswitchclient-0.2.0}/README.md

@@ -136,18 +136,30 @@ The ImSwitch API provides access to various components:
 - `getAllDeviceNames()` - Get all available positioners.
 - `getPositionerPositions()` - Get current position.
 - `movePositioner(name, axis, value, is_absolute, is_blocking)` - Move the stage.
+- `moveRelativeXY(dx, dy, positioner_name, is_blocking, speed)` - Relative X/Y move in µm.
+- `stop(name, axis)` / `stopAllAxes(name)` - Stop one axis / every axis.
 - `homeAxis(name, axis, is_blocking)` - Home the positioner.
 
 ### Lasers Manager
 - `getLaserNames()` - Get available lasers.
 - `setLaserActive(name, status)` - Turn laser on/off.
 - `setLaserValue(name, value)` - Set laser intensity.
+- `getLaserValueRanges(name)` / `getLaserValue(name)` / `getLaserActive(name)` - Read back.
+- `setLaserOn(name, value)` / `setLaserOff(name)` - Value and on/off in one call.
+- `runLaserFor(name, value, duration, on_tick, stop_event)` - Run a PWM channel (pump, valve)
+  for a fixed time; always switched off afterwards, also on errors or interruption.
 
 ### Recording Manager
 - `snapNumpyToFastAPI(resizeFactor)` - Capture an image as numpy array.
 - `startRecording(save_format)` - Begin recording with optional save format (SaveFormat enum).
 - `stopRecording()` - Stop recording.
-- `snapImageToPath(file_name)` - Snap image and save to specified path.
+- `snapImageToPath(file_name, save_format, return_preview)` - Snap image and save to specified path.
+- `snapAndWait(file_name, save_format, poll, timeout, on_progress, stop_event)` - Snap in the
+  background on the server and wait for it. Use for long exposures (minutes to hours); an
+  interrupt, `stop_event` or timeout cancels the exposure on the server.
+- `startSnap(...)` / `getSnapStatus(job_id)` / `cancelSnap(job_id)` - The same, step by step.
+- `previewToNumpy(result)` - 8-bit preview of a snap result as numpy array.
+- `downloadImage(relative_file_path)` / `downloadFile(...)` - Fetch the saved file (full bit depth).
 - `startVideoStream()` - Start MJPEG video stream.
 - `stopVideoStream()` - Stop MJPEG video stream.
 - `getVideoFrame()` - Get current frame from video stream.
@@ -160,6 +172,7 @@ The recording manager supports multiple save formats:
 - `SaveFormat.MP4` - MP4 video format
 - `SaveFormat.PNG` - PNG format
 - `SaveFormat.JPG` - JPEG format
+- `SaveFormat.OME_TIFF`, `SaveFormat.OME_ZARR`, `SaveFormat.STITCHED_TIFF`
 
 ### Settings Manager
 - `getDetectorNames()` - Get available detector names.
@@ -168,6 +181,25 @@ The recording manager supports multiple save formats:
 - `setDetectorGain(detector_name, gain)` - Set detector gain.
 - `setDetectorParameter(detector_name, parameter_name, value)` - Set generic detector parameter.
 - `setDetectorROI(detector_name, x, y, w, h)` - Set detector Region of Interest.
+- `getDetectorParameter(parameter_name, detector_name)` - Read one parameter from the camera.
+- `setDetectorMode(detector_name, is_auto)` / `setDetectorExposureOnce(detector_name)` - Auto exposure.
+- `getCameraTemperature(detector_name)` / `setCameraTargetTemperature(temperature_c)` - Cooled cameras.
+- `getDetectorParameterTree(detector_name)` / `setDetectorParameterValue(name, value)` - Typed access
+  to every camera parameter.
+
+### Live View Manager
+- `startLiveView(detector_name, protocol, params, force)` / `stopLiveView(detector_name)`
+- `getLiveViewActive()`, `getActiveStreams()`, `getLongExposureInfo(detector_name)`
+
+### UC2 Config Manager
+- `getBusStatus()` - CAN-bus power and emergency-stop state.
+- `setBusPower(enable)` / `setBusPowerAndWait(enable, settle)` - Switch the power of all CAN
+  slave boards (motors, LED/laser boards). Raises if the board refuses.
+- `isBoardConnected()`, `getBoardTemperature()`
+
+### Autofocus Manager
+- `autoFocusAndWait(rangez, resolutionz, ...)` - Server-side Z scan around the current focus,
+  waits for the result. `autoFocus`, `getAutofocusStatus`, `stopAutofocus` for manual control.
 
 ### View Manager
 - `setLiveViewActive(active)` - Enable/disable live view.
@@ -182,6 +214,30 @@ The recording manager supports multiple save formats:
 - `setLED(led_id, state)` - Set specific LED with ID and state.
 - `setSpecial(pattern, intensity, get_return)` - Set special LED pattern.
 
+### Smart microscopy helpers (`imswitchclient.smart`)
+Building blocks for closed-loop experiments; they work on numpy frames and plain callables and are
+tested without a microscope (`tests/test_smart.py`).
+
+```python
+from imswitchclient import smart
+snap = smart.make_snap(client)                    # -> float32 frame
+move = smart.make_relative_mover(client)          # move(dx_um, dy_um), blocking
+
+cal = smart.StageCameraCalibration.measure(snap, move, step_um=50)
+obj = smart.find_objects(snap())[0]               # largest blob
+move(*cal.move_to_center(*obj["offset"]))         # centre it - rotation and flips included
+```
+
+- `StageCameraCalibration` - pixel offsets <-> stage moves, measured on the live images.
+- `phase_correlate(a, b)` - sub-pixel image shift.
+- `find_objects(frame)` / `foreground_mask(frame)` - blob detection.
+- `EmptyFieldReference(empty_frame).coverage(frame)` - how much of a field is sample (0..1).
+- `SafetyBox` - limits closed-loop moves to a square around the start.
+- `Mosaic(frames, positions, cal)` - quick overview of frames placed by stage position.
+
+The ImSwitch notebooks `ImSwitch_Smart_ObjectTracking`, `ImSwitch_Smart_PathFollowing` and
+`ImSwitch_Smart_AdaptiveImaging` show them in use.
+
 ### Communication Manager
 - `acquireImage()` - Acquire an image through communication channel.
 - `getImage()` - Get an image from communication channel.

{imswitchclient-0.1.8 → imswitchclient-0.2.0}/imswitchclient/ImSwitchClient.py

@@ -14,6 +14,9 @@ from .settingsManager import settingsManager
 from .readnoiseManager import readnoiseManager
 from .viewManager import viewManager
 from .communicationManager import communicationManager
+from .uc2ConfigManager import uc2ConfigManager
+from .liveViewManager import liveViewManager
+from .autofocusManager import autofocusManager
 from .socketClient import socketClient
 
 DEFAULT_ROUTE = "/imswitch/api"
@@ -86,6 +89,9 @@ class ImSwitchClient(object):
         self.readnoiseManager = readnoiseManager(self)
         self.viewManager = viewManager(self)
         self.communicationManager = communicationManager(self)
+        self.uc2ConfigManager = uc2ConfigManager(self)
+        self.liveViewManager = liveViewManager(self)
+        self.autofocusManager = autofocusManager(self)
 
         # initialize Socket.IO client
         try:

{imswitchclient-0.1.8 → imswitchclient-0.2.0}/imswitchclient/__init__.py

@@ -3,4 +3,4 @@ from imswitchclient import *
 
 __author__ = """Benedict Diederich"""
 __email__ = 'benedictdied@gmail.com'
-__version__ = "v0.1.8"#'0.1.7'
+__version__ = "v0.2.0"#'0.1.7'

imswitchclient-0.2.0/imswitchclient/autofocusManager.py

@@ -0,0 +1,51 @@
+import time
+
+
+class autofocusManager(object):
+    """Server-side autofocus (AutofocusController): a Z step scan around the
+    current position with a Gaussian fit of the focus metric. Runs on the
+    server; `autoFocusAndWait` polls it to completion."""
+
+    def __init__(self, parent):
+        self.parent = parent
+
+    def _url(self, func):
+        return f"{self.parent.base_uri}/AutofocusController/{func}"
+
+    def autoFocus(self, rangez=100, resolutionz=10, tSettle=0.1, focusAlgorithm="LAPE",
+                  nCropsize=2048, nGauss=0, twoStage=False):
+        """Start a scan of ±`rangez` µm in `resolutionz` µm steps; returns at once"""
+        payload = {'rangez': rangez, 'resolutionz': resolutionz, 'tSettle': tSettle,
+                   'focusAlgorithm': focusAlgorithm, 'nCropsize': nCropsize, 'nGauss': nGauss,
+                   'twoStage': twoStage}
+        return self.parent.get_json(self._url("autoFocus"), payload=payload)
+
+    def getAutofocusStatus(self):
+        """{'state': idle|starting|scanning|fitting|moving_to_focus|finished|aborted|error, ...}"""
+        return self.parent.get_json(self._url("getAutofocusStatus"))
+
+    def stopAutofocus(self):
+        return self.parent.get_json(self._url("stopAutofocus"))
+
+    def autoFocusAndWait(self, rangez=100, resolutionz=10, poll=0.5, timeout=300, **kwargs):
+        """`autoFocus` and wait for it; returns the final status dict.
+
+        Raises if the server refuses to start, the scan ends in error/aborted,
+        or `timeout` s pass (the scan is stopped then).
+        """
+        started = self.autoFocus(rangez=rangez, resolutionz=resolutionz, **kwargs)
+        if isinstance(started, dict) and started.get("status") == "error":
+            raise RuntimeError(f"autofocus refused: {started.get('message')}")
+        t0 = time.time()
+        time.sleep(poll)
+        while True:
+            status = self.getAutofocusStatus()
+            state = status.get("state")
+            if state in ("finished", "idle") and not status.get("isRunning"):
+                return status
+            if state in ("error", "aborted"):
+                raise RuntimeError(f"autofocus ended with state '{state}'")
+            if time.time() - t0 > timeout:
+                self.stopAutofocus()
+                raise TimeoutError(f"autofocus exceeded {timeout} s")
+            time.sleep(poll)

imswitchclient-0.2.0/imswitchclient/lasersManager.py

@@ -0,0 +1,76 @@
+import time
+
+
+class lasersManager(object):
+
+    def __init__(self, parent):
+        self.parent = parent
+
+    def getLaserNames(self):
+        url = f"{self.parent.base_uri}/LaserController/getLaserNames"
+        headers = {'accept': 'application/json'}
+
+        response = self.parent.get_json(url, headers=headers)
+        return response
+
+    def getLaserValueRanges(self, laser_name):
+        """(min, max) of the value `setLaserValue` accepts, e.g. (0, 1023) for a PWM channel"""
+        url = f"{self.parent.base_uri}/LaserController/getLaserValueRanges"
+        return self.parent.get_json(url, payload={'laserName': laser_name})
+
+    def getLaserValue(self, laser_name):
+        url = f"{self.parent.base_uri}/LaserController/getLaserValue"
+        return self.parent.get_json(url, payload={'laserName': laser_name})
+
+    def getLaserActive(self, laser_name):
+        url = f"{self.parent.base_uri}/LaserController/getLaserActive"
+        return self.parent.get_json(url, payload={'laserName': laser_name})
+
+    def setLaserValue(self, laser_name, value=0):
+        url = f"{self.parent.base_uri}/LaserController/setLaserValue"
+        payload = {
+            'laserName': laser_name,
+            'value': value
+        }
+        response = self.parent.get_json(url, payload=payload)
+        return response
+
+    def setLaserActive(self, laser_name, active=True):
+        url = f"{self.parent.base_uri}/LaserController/setLaserActive"
+        payload = {
+            "laserName": laser_name,
+            "active": active
+        }
+        response = self.parent.get_json(url, payload=payload)
+        return response
+
+    def setLaserOn(self, laser_name, value):
+        """Set the value and switch the channel on"""
+        self.setLaserValue(laser_name, value)
+        return self.setLaserActive(laser_name, True)
+
+    def setLaserOff(self, laser_name):
+        """Set the value to 0 and switch the channel off"""
+        self.setLaserValue(laser_name, 0)
+        return self.setLaserActive(laser_name, False)
+
+    def runLaserFor(self, laser_name, value, duration, on_tick=None, tick=1.0, stop_event=None):
+        """Drive a channel at `value` for `duration` seconds, then switch it off.
+
+        Meant for actuators wired to a laser/PWM output (pumps, valves). The
+        channel is switched off in a `finally`, so an interrupted notebook
+        cell (KeyboardInterrupt) or a failed request does not leave a pump
+        running. `on_tick(elapsed_s)` is called about every `tick` seconds.
+        Setting the `threading.Event` `stop_event` ends the run early.
+        """
+        self.setLaserOn(laser_name, value)
+        try:
+            t0 = time.time()
+            while (elapsed := time.time() - t0) < duration:
+                if stop_event is not None and stop_event.is_set():
+                    break
+                if on_tick:
+                    on_tick(elapsed)
+                time.sleep(min(tick, duration - elapsed))
+        finally:
+            self.setLaserOff(laser_name)

imswitchclient-0.2.0/imswitchclient/liveViewManager.py

@@ -0,0 +1,38 @@
+class liveViewManager(object):
+    """Server-side live stream (LiveViewController).
+
+    Long exposures stop the stream on the server; snaps arm the camera on
+    demand, so the stream only needs to run for things that converge on
+    streamed frames, such as auto exposure.
+    """
+
+    def __init__(self, parent):
+        self.parent = parent
+
+    def _url(self, func):
+        return f"{self.parent.base_uri}/LiveViewController/{func}"
+
+    def startLiveView(self, detector_name=None, protocol="jpeg", params=None, force=False):
+        """Start the stream. Refused with status 'long_exposure' above the
+        server's long-exposure threshold unless `force` is set."""
+        query = {'protocol': protocol, 'force': force}
+        if detector_name is not None:
+            query['detectorName'] = detector_name
+        return self.parent.post_json(self._url("startLiveView"), payload=params, params=query)
+
+    def stopLiveView(self, detector_name=None, stop_camera=True):
+        payload = {'stopCamera': stop_camera}
+        if detector_name is not None:
+            payload['detectorName'] = detector_name
+        return self.parent.get_json(self._url("stopLiveView"), payload=payload)
+
+    def getLiveViewActive(self):
+        return self.parent.get_json(self._url("getLiveViewActive"))
+
+    def getActiveStreams(self):
+        return self.parent.get_json(self._url("getActiveStreams"))
+
+    def getLongExposureInfo(self, detector_name=None):
+        """{'exposureMs', 'thresholdMs', 'isLongExposure'}"""
+        payload = {} if detector_name is None else {'detectorName': detector_name}
+        return self.parent.get_json(self._url("getLongExposureInfo"), payload=payload)

imswitchclient-0.2.0/imswitchclient/positionersManager.py

@@ -0,0 +1,153 @@
+import time
+
+import requests
+
+# Blocking moves keep the HTTP request open for the whole travel, which can be
+# minutes on a long stage. The server itself gives up after ~100 s.
+BLOCKING_MOVE_TIMEOUT = 300
+
+
+class positionersManager(object):
+    
+    def __init__(self, parent):
+        self.parent = parent
+        self.allStageNames = self.getAllDeviceNames()
+        
+    def getAllDeviceNames(self):
+        url = f"{self.parent.base_uri}/PositionerController/getPositionerNames"
+        headers = {'accept': 'application/json'}
+
+        response = self.parent.get_json(url, headers=headers)
+        return response
+
+    def stop(self, positioner_name, axis):
+        if positioner_name is None:
+            positioner_name = self.allStageNames[0]
+        
+        url = f"{self.parent.base_uri}/PositionerController/stopAxis"
+        payload = {
+            'positionerName': positioner_name,
+            'axis': axis
+        }
+        response = self.parent.get_json(url, payload=payload)
+        return response           
+
+    def movePositionerForever(self, positioner_name=None, axis="X", speed=0, is_stop=False):
+        if positioner_name is None:
+            positioner_name = self.allStageNames[0]
+        
+        url = f"{self.parent.base_uri}/PositionerController/movePositionerForever"
+        payload = {
+            'positionerName': positioner_name,
+            'axis': axis,
+            'speed': speed,
+            'is_stop': is_stop
+        }
+        response = self.parent.get_json(url, payload=payload)
+        return response       
+            
+    def setPositionerSpeed(self, positioner_name, axis, speed):
+        if positioner_name is None:
+            positioner_name = self.allStageNames[0]
+        
+        url = f"{self.parent.base_uri}/PositionerController/setPositionerSpeed"
+        payload = {
+            'positionerName': positioner_name,
+            'axis': axis,
+            'speed': speed
+        }
+        response = self.parent.get_json(url, payload=payload)
+        return response
+        
+    def movePositioner(self, positioner_name, axis, dist, is_absolute=True, is_blocking=True, speed=10000,
+                       timeout=None):
+        """Move one axis by/to `dist` µm. `timeout` (s) bounds the HTTP request;
+        the default allows long blocking moves (`BLOCKING_MOVE_TIMEOUT`)."""
+        if timeout is None:
+            timeout = BLOCKING_MOVE_TIMEOUT if is_blocking else 30
+        if positioner_name is None:
+            positioner_name = self.allStageNames[0]
+
+        url = f"{self.parent.base_uri}/PositionerController/movePositioner"
+        payload = {
+            'positionerName': positioner_name,
+            'axis': axis,
+            'dist': dist,
+            'isAbsolute': is_absolute,
+            'isBlocking': is_blocking, 
+            'speed': speed
+        }
+        #headers = {'accept': 'application/json'}
+
+        response = self.parent.get_json(url, payload=payload, timeout=timeout)
+        return response
+
+    def getPositionerPositions(self, id=None):       
+        url = f"{self.parent.base_uri}/PositionerController/getPositionerPositions"
+        payload = {
+        }
+        response = self.parent.get_json(url, payload=payload)
+        if type(id) == int:
+            return response[id]
+        return response
+    
+    def homeAxis(self, positioner_name, axis, is_blocking=False):
+        url = f"{self.parent.base_uri}/PositionerController/homeAxis"        
+        if positioner_name is None:
+            positioner_name = self.allStageNames[0]
+            
+        payload = {
+            'positionerName': positioner_name,
+            'axis': axis, 
+            'isBlocking': is_blocking
+        }
+        response = self.parent.get_json(url, payload=payload)
+        return response
+
+    def stopAllAxes(self, positioner_name=None):
+        """Immediately stop every axis of the positioner"""
+        if positioner_name is None:
+            positioner_name = self.allStageNames[0]
+        url = f"{self.parent.base_uri}/PositionerController/stopAllAxes"
+        return self.parent.get_json(url, payload={'positionerName': positioner_name})
+
+    def moveRelativeXY(self, dx, dy, positioner_name=None, is_blocking=True, speed=10000):
+        """Relative X then Y move in µm; zero components are skipped"""
+        if positioner_name is None:
+            positioner_name = self.allStageNames[0]
+        for axis, dist in (("X", dx), ("Y", dy)):
+            if dist:
+                self.movePositioner(positioner_name, axis, dist, is_absolute=False,
+                                    is_blocking=is_blocking, speed=speed)
+
+    def moveAbsoluteXY(self, x, y, positioner_name=None, speed=10000, tolerance_um=10.0,
+                       timeout=None, poll=0.5):
+        """Absolute X/Y move (µm, user frame) that returns once the stage *reports*
+        the target, within `tolerance_um`; returns the final positions.
+
+        `timeout` (s) defaults to twice the travel time at `speed` plus 30 s, so
+        a long travel is not cut off. Should an HTTP request time out anyway,
+        the move goes on on the server and this keeps polling the position
+        instead of failing. Raises TimeoutError if the target is not reached.
+        """
+        if positioner_name is None:
+            positioner_name = self.allStageNames[0]
+        pos = self.getPositionerPositions()[positioner_name]
+        travel = max(abs(x - pos["X"]), abs(y - pos["Y"]))
+        if timeout is None:
+            timeout = 2 * travel / max(float(speed), 1.0) + 30
+        t_end = time.time() + timeout
+        for axis, target in (("X", x), ("Y", y)):
+            try:
+                self.movePositioner(positioner_name, axis, target, is_absolute=True, is_blocking=True,
+                                    speed=speed, timeout=max(5.0, t_end - time.time()))
+            except requests.exceptions.ReadTimeout:
+                pass        # still travelling; the position poll below decides
+        while True:
+            pos = self.getPositionerPositions()[positioner_name]
+            if abs(pos["X"] - x) <= tolerance_um and abs(pos["Y"] - y) <= tolerance_um:
+                return pos
+            if time.time() > t_end:
+                raise TimeoutError(f"stage reports X={pos['X']:.1f} Y={pos['Y']:.1f} µm "
+                                   f"{timeout:.0f} s after moving to X={x:.1f} Y={y:.1f} µm")
+            time.sleep(poll)