microEye v2.4.0a5

   ___   __     __
  / _ | / /__  / /  ___ _
 / __ |/ / _ \/ _ \/ _ `/
/_/ |_/_/ .__/_//_/\_,_/
       /_/

What's New:

-------------------------------------------------------------
IMPORTANT: Zarr V3 support now requires Python 3.11 or newer.
   Support for Python 3.9 and 3.10 has been discontinued.
-------------------------------------------------------------

-----------------
microEye v2.4.0a5
-----------------

- Focus Widget:
    - Previously, performance issues included GUI freezes caused by:
      - Expensive autorange operations and reliance on
        `pg.GraphicsLayoutWidget` for all plots.
      - Non-optimized plot update logic in `focusWidget` and
        `PyQtGraphDisplay` caused overlapping calls and race
        conditions.

    - The issue appears when acquisition display runs at high framerates
      (>30Hz) with one or more ROIs.
    - Issue has been resolved and tested with acquisition camera running
      at ~165Hz and focus plots and GUI were responsive.

    - Refactor `focusWidget` to use separate `pg.GraphicsView` and
      `pg.PlotWidget` for all plots instead of
      `GraphicsLayoutWidget`.
    - Implemented non-pyqtgraph-native logic to update plot ranges at
      less frequent intervals, reducing resource usage and
      improving responsiveness.
    - Added a boolean option in the GUI to enable or disable the
      non-pyqtgraph-native plot range updates.
    - Add async worker for plot updates to avoid GUI blocking.
    - Remove use of `HistogramBarItem` for histogram plots, as it is
      computationally heavy; instead, use histogram step plotting
      (drawing the histogram as a stepped line plot rather than
      bars) on a regular `pg.PlotWidget` for improved performance.
    - Fix ROI update logic after loading config; previously the GUI did
      not update accordingly.
    - Update plots visibility dynamically depending on the selected
      stabilization method:
        - For example, when reflection "Z-only" stabilization method is
          selected, only the Z histogram and Z time log plots
          are shown.
        - When beads or Hybrid "XYZ" stabilization methos is selected,
          XY scatter and X/Y time log plots are also
          displayed.
        - The GUI logic automatically hides or shows relevant plots
          based on the current stabilization mode.

- Display & Viewer:
    - Refactor `FrameCounter` to use monotonic nanosecond clock for FPS
      calculation (previously used `time.time()`).
    - Fix `PyQtGraphDisplay` update logic reducing resource usage and
      improving GUI responsiveness:
      - Refactor histogram and CDF updates to occur at less frequent
        intervals.
      - Add a flag in the `PyQtGraphDisplay` class to block overlapping
        update calls and prevent race conditions during rapid
        image updates.
      - Set `pg.GraphicsView(useOpenGL=True)` for improved rendering
        performance.

- Stage Adapters: (BUG)
    - Fix `PiezoConceptFOC` stage adapter to always cast Z position to
      integer before sending commands, preventing random jumps
      caused by `float`/`int` type mismatch.

- Device Manager: (BUG)
    - Fix `FocusStabilizer` signals to use `moveXYZ` (signal) and
      `StageManager.move_relative` (function), replacing legacy
      `moveStage` (signal) and `move_z` (function).

- Focus Stabilizer & Controller:
    - Fix controller attributes to use single underscore; double
      underscore caused them to be inaccessible to subclasses.
    - Add missing tau parameter to FocusStabilizer config and ensure it
      is loaded/saved. (reserved to be used later)
    - Fix loading of per-axis inverted flags in `FocusStabilizerView`.
    - Refactor `FocusStabilizer` worker logic to use correct per-axis
      stabilization and response inversion emitted through
      `moveXYZ`.
    - Fix method and rejection method enum handling in
      `FocusStabilizerView`.
    - Fix ROI activation signal emission after config load.
    - Add __str__ method to RejectionMethod enum.

- Other:
    - Update GitHub Actions workflow to use `Python 3.11.9`

-----------------
microEye v2.4.0a4
-----------------

- Images & Data IO
    - refactor: Move all image sequence and uImage classes from
      `microEye.utils.uImage` to new `microEye.images` subpackage
      (`handlers.py`, `uImage.py`, `zarr.py`)
    - refactor: Update all imports to use `microEye.images` instead of
      `microEye.utils.uImage`
    - feat: Add unified `ImageSequenceBase`, `TiffSeqHandler`,
      `ZarrImageSequence`, and `saveZarrImage` to
      microEye.images.handlers
    - feat: Add `ZarrAcquisition`, `create_array`, and
      `store_zarr_array` for streaming and saving Zarr V3 data
    - feat: Added `close_display(display_name)` method to
      `DisplayManager` to allow closing a specific display window
      by name
    - fix: Ensure Zarr handler support both zipped and directory stores

- Analysis & Viewer
    - refactor: Update all analysis modules to use new image handler
      imports
    - fix: Remove legacy `microEye.utils.uImage` import from all modules
    - feat: Add registration tool (`registration.py`) for image stack
      registration and transformation
    - feat: Add multi-channel stack merging and transformation
      export/import in registration tool
    - fix: Fixed channel display logic for multichannel data in
      `images.py` so channels are handled correctly in viewer.

- Multi Viewer Module
    - feat: Add "Opened Files" dock to `multi_viewer`, showing all
      currently opened files and allowing quick switching
    - feat: Add "Registration Tool" to Tools menu in `multi_viewer` for
      stack alignment
    - fix: Properly handle .zarr files in file system model and viewer
    - fix: Ensure opened files are tracked and closed correctly in
      `multi_viewer`

- Fitting & Filters
    - fix: Update all fitting and filter modules to use new image
      handler imports

- Hardware & Acquisition
    - Thorlabs Camera:
          - Fixed bugs in exposure range and pixel clock list handling.
          - Corrected driver string and status dictionary logic.
    - AcquisitionJob:
          - Refactored ROI extraction and frame writing logic for
            TIFF/Zarr.
          - Improved resource cleanup and metadata saving.
          - Ensured correct handling of Zarr array finalization and TIFF
            writer logic.
    - fix: Update all camera panels and acquisition logic to use new
      image handler imports
    - fix: Remove legacy `microEye.utils.uImage` import from hardware
      modules

------------------------------------
Focus Stabilizer Refactor (v2.4.0a3)
------------------------------------

- Major refactor of the Focus Stabilizer backend and frontend:
    - Modularized stabilization logic into `stabilization.controller`
      and `stabilization.methods` submodules.
    - Each axis (X, Y, Z) now has independent PID controller gains and
      calibration coefficients.
    - Outlier rejection for shift estimation is now configurable
      (Standard Deviation, MAD, or None).
    - Added support for XY stabilization and hybrid modalities (under
      development).
    - New data logging system for time, X/Y/Z shifts, and parameter
      values.
    - Visualization improvements:
        - Z histogram, time log of X/Y/Z, XY scatter, and localization
          overlays.
        - All plots update in real time with stabilization.
    - FocusStabilizerView and focusWidget updated for new parameter tree
      and ROI management.
    - Configuration save/load for all stabilizer and ROI parameters.
    - Improved thread safety and async handling for stabilization
      worker.
    - Refactored stage and device manager integration for stabilization
      toggling and lock state.
    - All stabilization methods now use unified interface for parameter
      fitting and shift calculation.

- Internal API changes:
    - `FocusStabilizer` and `FocusStabilizerView` now use enums for all
      axis and parameter references.
    - `StageManager` and `DeviceManager` updated to use new
      stabilization API.
    - Controller widget now supports toggling XY and Z stabilization
      independently.
    - Added `FocusPlot` enum and unified plotting logic in
      `focusWidget`.

- Camera/Acquisition/Stage:
    - All camera classes now implement a `snap_image()` method for
      single-frame acquisition (Basler, Vimba, uEye, Thorlabs,
      PCO, PycroManager, Dummy).
    - Improved dummy camera (`miDummy`) astigmatic fiducials pattern
      simulation and parameters.
    - `CameraManager` is now the singleton for all camera lists; all
      references to `CameraList.CAMERAS` replaced with
      `CameraManager.CAMERAS`.
    - Acquisition manager and scan/z-stack logic updated to use new
      focus stabilization API and per-axis calibration.
    - KinesisXY and AbstractStage now use unified async worker logic and
      busy checks.
    - PycroStageXY async move logic improved and now waits for hardware
      busy state.

- Spatial filter optimizations:
    - Difference of Gaussians (DoG) and PointGaussFilter now use
      `fftconvolve` for significantly improved filtering speed.
    - Radial coordinate calculations for Fourier filters are now
      Numba-accelerated for faster execution.

- General Refactoring:
    - Moved focus stabilization logic out of monolithic files into
      dedicated submodules under `stabilization/`.
    - Minor bugfixes for timeouts, async workers, and config
      serialization.
    - Replaced all delay and timeout time measurements to use
      `monotonic` clocks instead of `time` for improved reliability.

- Bugfixes:
    - Fixed config loading to ensure Pycro-Manager instances and bridges
      are started before device configuration is loaded, preventing
      initialization errors.

-----------------
microEye v2.4.0a2
-----------------

-------------
Slides Widget
-------------

- Add a new `SlideWidget` for visualizing and selecting slide channels
- Support multiple slide types and channel geometries (sticky-Slide VI
  0.4, μ-Slide VI 0.1, 8/18 Well)
- Implement interactive channel selection, highlight, and move-to-center
  logic in `SlideWidget`
- Show current stage position and delta in info bar
- Draw position cross and center cross overlays
- Emit signals for channel selection and move the stage to the channel
  center
- Add context menu for slide type, orientation (swap XY), and axis
  inversion
- Persist and restore slide widget configuration (`slide`, `swap_xy`,
  `invert_x`, `invert_y`) in `config.json`
- Add "Slides" dock to `miEye_module`

------------------------------------
Stage Metadata & Editable Parameters
------------------------------------

- Add editable X/Y/Z center and max parameters to `StageView` parameter
  tree
- Add `get_center`, `set_center`, `get_max` methods to `AbstractStage`
  for axis metadata
- Update `StageView` to support editing center/max for each axis
- Persist and restore center/max values in stage config

-------------
Stage Manager
-------------

- Implement `StageManager.center(axis)` to move X, Y, or Z stage to
  editable center position
- Refactor `StageManager.move_absolute` to accept optional coordinates
  and units

--------------
Device Manager
--------------

- Add unified `update_gui` methods to `DeviceManager` and `CameraList`
- Add `centerRequest` method which accepts `Axis` enum for stage
  centering.
- Refactor main window timer to call widget GUI updates

------------------------------
Other Refactors & Improvements
------------------------------

- refactor `miEye_module` to accommodate all the changes and new
  widgets.
- Add XY and Z "Center" buttons to the Controller widget for moving
  stages to center positions
- Fix mouse event handling in `TiledImageSelector' for Qt6 compatibility
- Update `config.json` to persist new dock and widget states

-----------------
microEye v2.4.0a1
-----------------

--------------------------------------------------
Unified Abstract Stage Class & Stage View Refactor
--------------------------------------------------

- The `AbstractStage` class was refactored to unify the interface for
  all stage types (Z, XY, multi-axis, etc.), supporting:
	- Consistent axis handling via the `axes` property.
	- Unified position, movement, and configuration methods for all axes.
	- Standardized unit conversion and metadata storage.
	- Improved signal handling for async operations.
- The new `StageView provides` a generic parameter tree UI for any
  stage, automatically adapting to supported axes and serial
  configuration.
- Legacy stage-specific views and controllers (e.g., PiezoConcept,
  Kinesis) are now replaced or wrapped by the unified view.

----------------------------------
Stage Manager & Stage Manager View
----------------------------------

- Added `StageManager` singleton class to manage all connected stages,
  their assignment to axes, and movement coordination.
	- Supports adding/removing stages, axis assignment, and step/jump
      configuration.
	- Handles open/close, busy state, and movement requests for all axes.
- Added `StageManagerView` for GUI management of stages, drivers, axis
  assignment, and step/jump sizes.
- Stages are now dynamically added/removed and assigned to axes via the
  manager, supporting multiple hardware backends.

--------------
Device Manager
--------------

- Removed support for legacy stages and related stage selection logic.
- Updated stage management to use the new unified `StageManager` and its
  API for adding/removing stages and axis assignment.
- Updated configuration loading/saving to use the new stage config
  format.

-----------------------------------------
SmarAct Stage Support (Under Development)
-----------------------------------------

- Initial implementation of `MCS2Stage` for SmarAct MCS2 controllers.
	- Device discovery, connection, and configuration support.
	- Not yet fully integrated into the main GUI, but ready for further
      development.

------------------------
Camera List Improvements
------------------------

- The `CameraList` now supports dynamic addition/removal of cameras,
  including PycroManager and hardware cameras.
- Improved support for saving/loading camera configuration in the main
  config file.
- Generalized population logic of available connected cameras.

-----------------
Base Camera Class
-----------------

- Added support for property trees and parameter updates for camera
  settings.
- Improved ROI handling: added `set_roi`, `get_roi`, and `reset_roi`
  methods.
- Added metadata retrieval with get_metadata.
- Implemented `update_cam` for dynamic parameter changes.
- Added class methods for available camera list enumeration.

------------
Camera Panel
------------

- Unified logic for exposure, framerate, ROI, and capture handling in
  `Camera_Panel`.
- Removed duplicated exposure/framerate/ROI logic from subclasses
  (Basler, Pycro, Dummy, IDS, Thorlabs, Vimba, PCO).
- Subclasses now delegate to base class for common parameter setup and
  signal connections.
- Capture and update methods standardized; device-specific logic moved
  to base class where possible.
- Clean up resources used by the camera panel using overrides of
  `Camera_Panel.dispose` if needed.
- Subclass panels now only implement device-specific overrides and
  minimal customizations.

---------------------
Basler Camera Support
---------------------

- Added full support for Basler cameras via the `Basler_Panel` and
  `basler_cam`.
- Camera options, ROI, exposure, and acquisition are integrated into the
  unified camera panel system.
- Basler cameras are now included in config save/load and dynamic camera
  list management.
- SDK seems to conflict with Vimba and Vimba X SDK transport layers.

-----------------------------------
Allied Vision (Vimba X SDK) Support
-----------------------------------

- Updated support for Allied Vision cameras to use the new Vimba X SDK
  (`vmbpy`), replacing legacy Vimba SDK.
- All Vimba-related panels and camera classes now use the new SDK and
  are compatible with the unified camera panel and camera list system.
- Refactored the `with` context from the main scope to `vimba_cam`.
- SDK seems to conflict with Basler Pylon SDK transport layers.

------------------------
PycroManager Refactoring
------------------------

- PycroManager camera and stage classes are now split into their own
  submodules:
	- `PycroCamera` in `microEye/hardware/cams/pycromanager/pycro_cam.py`.
	- `PycroStageZ` and `PycroStageXY` in
      `microEye/hardware/stages/pycromanager/core.py`.
	- `PycroPanel` in
      `microEye/hardware/cams/pycromanager/pycro_panel.py`.
- Stage selection and port management are now handled via dialogs and
  the stage manager.

-----------------------------
Save/Load Config Improvements
-----------------------------

- The config system now saves and loads all stages and cameras,
  including their assignment, configuration, and dynamic
  addition/removal.
- When loading a config, available stages and cameras are automatically
  added if detected.
- Dock widget positions, visibility, and floating state are still
  preserved in config.

------------------------------
Other Refactors & Improvements
------------------------------

- The miEye module has minor updates to accommodate the changes above.
- Updated controller and device views to use the new signal and
  parameter system.
- The controller signals now use the improved `Axis` enum type for move
  requests.

--------------
Future Updates
--------------

- Complete SmarAct MCS2 stage integration and testing.
- Develop the Focus Stabilization alternative modalities. (Under Dev)
- MacOS compatibility testing.
- Acquisition Experiments Designer tools.
- 3D Localization fitting from Experimental PSF.
- Introduction of 2D/3D Single-Particle Tracking.

Author: samhitech

.github/workflows/publish-to-pypi.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v4
         with:
-          python-version: "3.9.13" # Specify your Python version
+          python-version: "3.11.9" # Specify your Python version
 
       - name: Install dependencies
         run: |

README.md

@@ -8,9 +8,9 @@ This toolkit is compatible with the [hardware](#hardware) used in our microscope
 
 ```bash
    __  ____              ____                ___  ____  ___       ____
-  /  |/  (_)__________  / __/_ _____   _  __|_  |/ / / / _ \___ _/ / /
- / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __//_  _// // / _ `/_  _/
-/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)_/(_)___/\_,_/ /_/
+  /  |/  (_)__________  / __/_ _____   _  __|_  |/ / / / _ \___ _/ __/
+ / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __//_  _// // / _ `/__ \
+/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)_/(_)___/\_,_/____/
                           /___/
                          ___   __     __                         
                         / _ | / /__  / /  ___ _  

config.json

@@ -9,7 +9,23 @@
     "baudrate": 9600
   },
   "Stages": {
-    "PycroStage XY-f5d7fbaf": {
+    "PycroStage Z-6079a658": {
+      "class_name": "PycroStage Z",
+      "config": {
+        "Z": {
+          "max": 100,
+          "center": 50.0
+        },
+        "pycromanager": {
+          "label": "Z",
+          "port": 4827
+        }
+      },
+      "axis": [
+        "Z"
+      ]
+    },
+    "PycroStage XY-60e73acd": {
       "class_name": "PycroStage XY",
       "config": {
         "X": {
@@ -28,56 +44,87 @@
       "axis": [
         "X"
       ]
-    },
-    "PycroStage Z-6caf6b42": {
-      "class_name": "PycroStage Z",
-      "config": {
-        "Z": {
-          "max": 100,
-          "center": 50.0
-        },
-        "pycromanager": {
-          "label": "Z",
-          "port": 4827
-        }
-      },
-      "axis": [
-        "Z"
-      ]
     }
   },
   "FocusStabilizer": {
-    "ROI_x": 25.5,
-    "ROI_y": 25.5,
-    "ROI_length": 256.0,
-    "ROI_angle": 0,
-    "ROI_Width": 1,
-    "PID": [
-      6.45,
-      0.0,
-      0.0,
-      0.0,
-      0.001
-    ],
-    "PixelCalCoeff": 0.01,
-    "UseCal": false,
-    "Inverted": false
+    "ROIs": {
+      "z": {
+        "x1": 31.88696729382842,
+        "y1": 261.81778987165205,
+        "x2": 478.5634565421389,
+        "y2": 261.81778987165205,
+        "linewidth": 100
+      },
+      "xy": {
+        "x1": 50.5,
+        "y1": 25.5,
+        "x2": 150.5,
+        "y2": 150.5,
+        "linewidth": 1
+      }
+    },
+    "Stabilizer": {
+      "Kp": [
+        1.0,
+        4.0,
+        7.0
+      ],
+      "Ki": [
+        2.0,
+        5.0,
+        8.0
+      ],
+      "Kd": [
+        3.0,
+        6.0,
+        9.0
+      ],
+      "tau": 0.0,
+      "error_th": 0.001,
+      "cal_coeff": [
+        10.0,
+        10.0,
+        10.0
+      ],
+      "use_cal": false,
+      "inverted": [
+        true,
+        false,
+        true
+      ],
+      "method": "reflection",
+      "rejection_method": "Median Absolute Deviation",
+      "rejection_threshold": 1.5,
+      "rejection_min_points": 5
+    }
   },
   "Pycromanager": {
     "core_instances": [
       4827
     ],
     "headless_instances": {}
   },
-  "Cameras": [],
+  "Cameras": [
+    {
+      "Camera ID": "Cam 0",
+      "Device ID": 0,
+      "Model": "Dummy",
+      "Serial": "42023060",
+      "InUse": false,
+      "Status": "Ready",
+      "Sensor ID": "06032024",
+      "Driver": "miDummy",
+      "IR": true
+    }
+  ],
   "Lasers": [],
   "miEye_module": {
     "position": {
-      "x": 620,
-      "y": 396
+      "x": 878,
+      "y": 100
     },
     "size": {
-      "width": 1200,
+      "width": 1368,
       "height": 920
     },
     "is_maximized": false
@@ -86,37 +133,37 @@
     "slide": "sticky-Slide VI 0.4",
     "swap_xy": false,
     "invert_x": false,
-    "invert_y": true
+    "invert_y": false
   },
   "controller_dock": {
     "is_floating": true,
     "position": {
-      "x": 62,
-      "y": 397
+      "x": 108,
+      "y": 375
     },
     "size": {
-      "width": 392,
-      "height": 445
+      "width": 395,
+      "height": 494
     },
     "is_visible": true
   },
   "slides_dock": {
     "is_floating": true,
     "position": {
-      "x": 60,
-      "y": 64
+      "x": 93,
+      "y": 73
     },
     "size": {
-      "width": 762,
-      "height": 282
+      "width": 669,
+      "height": 256
     },
     "is_visible": true
   },
   "devices_dock": {
     "is_floating": false,
     "position": {
-      "x": -4,
-      "y": -230
+      "x": 254,
+      "y": -526
     },
     "size": {
       "width": 124,
@@ -125,22 +172,22 @@
     "is_visible": true
   },
   "stages_dock": {
-    "is_floating": false,
+    "is_floating": true,
     "position": {
-      "x": -230,
-      "y": -284
+      "x": 67,
+      "y": 909
     },
     "size": {
-      "width": 350,
-      "height": 180
+      "width": 767,
+      "height": 471
     },
     "is_visible": true
   },
   "pyscript_dock": {
     "is_floating": false,
     "position": {
-      "x": -89,
-      "y": -264
+      "x": 169,
+      "y": -560
     },
     "size": {
       "width": 209,
@@ -151,8 +198,8 @@
   "protocols_dock": {
     "is_floating": false,
     "position": {
-      "x": -72,
-      "y": -232
+      "x": 186,
+      "y": -528
     },
     "size": {
       "width": 192,
@@ -163,8 +210,8 @@
   "lasers_dock": {
     "is_floating": false,
     "position": {
-      "x": -93,
-      "y": -230
+      "x": 165,
+      "y": -526
     },
     "size": {
       "width": 213,
@@ -175,8 +222,8 @@
   "cameras_dock": {
     "is_floating": false,
     "position": {
-      "x": -151,
-      "y": -262
+      "x": 107,
+      "y": -558
     },
     "size": {
       "width": 271,
@@ -187,13 +234,25 @@
   "focus_dock": {
     "is_floating": false,
     "position": {
-      "x": 620,
-      "y": 452
+      "x": 878,
+      "y": 156
     },
     "size": {
-      "width": 1200,
+      "width": 1368,
       "height": 843
     },
     "is_visible": true
+  },
+  "focus_camera_dock": {
+    "is_floating": false,
+    "position": {
+      "x": 217,
+      "y": -574
+    },
+    "size": {
+      "width": 161,
+      "height": 174
+    },
+    "is_visible": true
   }
 }

src/microEye/_version.py

@@ -1,2 +1,2 @@
 version_info = (2, 4, 0)
-__version__ = '.'.join(map(str, version_info)) + 'a4'
+__version__ = '.'.join(map(str, version_info)) + 'a5'

src/microEye/hardware/cams/line_profiler.py

@@ -33,7 +33,7 @@ def __init__(self) -> None:
         #     self.average)
         self.data = np.random.normal(size=(512, 512))
         self.remote_view = pg.GraphicsView()
-        pg.setConfigOptions(antialias=True, imageAxisOrder='row-major')
+        pg.setConfigOptions(antialias=False, imageAxisOrder='row-major')
         self.remote_plt = pg.ViewBox(invertY=True)
         self.remote_view.setCentralItem(self.remote_plt)
         self.remote_plt.setAspectLocked()

src/microEye/hardware/mieye/devices_manager.py

@@ -138,7 +138,7 @@ def _init_hid_controller(self):
         self.widgetAdded.emit(DEVICES.HID_CONTROLLER, self.hid_controller)
 
     def _init_focus_stabilizer(self):
-        FocusStabilizer.instance().moveStage.connect(StageManager.instance().move_z)
+        FocusStabilizer.instance().moveXYZ.connect(StageManager.instance().move_relative)
         FocusStabilizer.instance().startWorker()
 
         self.focus = focusWidget()

src/microEye/hardware/misc/acquisition_view.py

@@ -11,7 +11,7 @@ def __init__(self) -> None:
 
         self.setWindowTitle('Image View (Snap/Live)')
 
-        pg.setConfigOption('imageAxisOrder', 'row-major')
+        pg.setConfigOptions(antialias=False, imageAxisOrder='row-major')
 
         size = QApplication.primaryScreen().availableGeometry()
         minDim = int(min(size.width(), size.height()) * 0.9)

src/microEye/hardware/stages/piezon_concept/foc.py

@@ -82,7 +82,7 @@ def get_z(self):
     @emit_after_signal('moveFinished')
     def move_absolute(self, x, y, z, **kwargs):
         if self.is_open():
-            self.z = min(max(z, 0), self.z_max)
+            self.z = int(min(max(z, 0), self.z_max))
             self.send_command(f'MOVEZ {z}n\n'.encode())
             self.last_command = 'MOVEZ'
 
@@ -95,7 +95,7 @@ def stop(self):
     @emit_after_signal('moveFinished')
     def move_relative(self, x, y, z, **kwargs):
         if self.is_open():
-            self.z = min(max(self.z + z, 0), self.z_max)
+            self.z = int(min(max(self.z + z, 0), self.z_max))
             self.send_command(f'MOVEZ {self.z}n\n'.encode())
             self.last_command = 'MOVEZ'