microeye 2.4.1__tar.gz → 2.4.2__tar.gz

{microeye-2.4.1/src/microeye.egg-info → microeye-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microeye
-Version: 2.4.1
+Version: 2.4.2
 Summary: A python toolkit for fluorescence microscopy         that features hardware control, data analysis and vizualization         for super-resolution single-molecule localization microscopy and         single-partical tracking.
 Home-page: https://github.com/samhitech/microEye
 Author: Mohammad Nour Alsamsam
@@ -72,10 +72,10 @@ The **`microEye`** is a Python toolkit for fluorescence microscopy that supports
 This toolkit is compatible with the [hardware](#hardware) used in our microscope. For further details, refer to the [miEye microscope paper](https://doi.org/10.1016/j.ohx.2022.e00368) and [OSF project](http://doi.org/10.17605/osf.io/j2fqy).
 
 ```bash
-   __  ____              ____                ___  ____  ___
-  /  |/  (_)__________  / __/_ _____   _  __|_  |/ / / <  /
- / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __//_  _/ / /
-/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)_/(_)_/
+   __  ____              ____                ___  ____   ___
+  /  |/  (_)__________  / __/_ _____   _  __|_  |/ / /  |_  |
+ / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __//_  _/ / __/ 
+/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)_/(_)____/ 
                           /___/
 ```
 

{microeye-2.4.1 → microeye-2.4.2}/README.md

@@ -7,10 +7,10 @@ The **`microEye`** is a Python toolkit for fluorescence microscopy that supports
 This toolkit is compatible with the [hardware](#hardware) used in our microscope. For further details, refer to the [miEye microscope paper](https://doi.org/10.1016/j.ohx.2022.e00368) and [OSF project](http://doi.org/10.17605/osf.io/j2fqy).
 
 ```bash
-   __  ____              ____                ___  ____  ___
-  /  |/  (_)__________  / __/_ _____   _  __|_  |/ / / <  /
- / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __//_  _/ / /
-/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)_/(_)_/
+   __  ____              ____                ___  ____   ___
+  /  |/  (_)__________  / __/_ _____   _  __|_  |/ / /  |_  |
+ / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __//_  _/ / __/ 
+/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)_/(_)____/ 
                           /___/
 ```
 

{microeye-2.4.1 → microeye-2.4.2}/src/microEye/_version.py

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

{microeye-2.4.1 → microeye-2.4.2}/src/microEye/hardware/cams/micam.py

@@ -781,32 +781,48 @@ class miDummy(miCamera):
         '''
         noise = kwargs.get('noise', 0)  # noise to add to fiducial positions
         drift = kwargs.get('drift', [0, 0, 0])  # drift in x, y, z
+        psf_model = kwargs.get('psf_model', 'airy').lower()
+        airy_scale = kwargs.get('airy_scale', 1.22)
         kernel_size = int(6 * max(sigma_x, sigma_y)) | 1  # odd size, covers >99% of PSF
 
-        x = np.arange(self.width)
-        y = np.arange(self.height)
-        X, Y = np.meshgrid(x, y)
-
-        pattern = np.zeros((self.width, self.height), dtype=np.float64)
+        pattern = np.zeros((self.height, self.width), dtype=np.float64)
 
-        ax, ay = 1 / (2 * sigma_x**2), 1 / (2 * sigma_y**2)
+        eps = np.finfo(np.float64).eps
+        ax, ay = 1 / (2 * sigma_x**2 + eps), 1 / (2 * sigma_y**2 + eps)
         for fid in fiducials:
             x = fid[0]
             y = fid[1]
 
             x += drift[0] + (np.random.random_sample() - 0.5) * noise
             y += drift[1] + (np.random.random_sample() - 0.5) * noise
-            x_slice = slice(
-                int(max(x - kernel_size, 0)), int(min(x + kernel_size, self.width))
-            )
-            y_slice = slice(
-                int(max(y - kernel_size, 0)), int(min(y + kernel_size, self.height))
-            )
+            x0 = int(max(x - kernel_size, 0))
+            x1 = int(min(x + kernel_size, self.width))
+            y0 = int(max(y - kernel_size, 0))
+            y1 = int(min(y + kernel_size, self.height))
+
+            if x1 <= x0 or y1 <= y0:
+                continue
+
+            x_local = np.arange(x0, x1, dtype=np.float64) - x
+            y_local = np.arange(y0, y1, dtype=np.float64) - y
+
+            if psf_model == 'airy':
+                # Airy-like approximation using sinc^2 radial profile.
+                r = np.sqrt(
+                    np.add.outer(
+                        (y_local / (sigma_y + np.random.random_sample() * 0.1 + eps))
+                        ** 2,
+                        (x_local / (sigma_x + np.random.random_sample() * 0.1 + eps))
+                        ** 2,
+                    )
+                )
+                patch = np.sinc(r / (airy_scale + eps)) ** 2
+            else:
+                gx = np.exp(-(x_local**2) * ax)
+                gy = np.exp(-(y_local**2) * ay)
+                patch = np.multiply.outer(gy, gx)
 
-            pattern[y_slice, x_slice] += self.drift_amplitude * np.exp(
-                -((X[y_slice, x_slice] - x) ** 2) * ax
-                - ((Y[y_slice, x_slice] - y) ** 2) * ay
-            )
+            pattern[y0:y1, x0:x1] += self.drift_amplitude * patch
 
         if pattern.min() < 0:
             pattern += abs(pattern.min())

{microeye-2.4.1 → microeye-2.4.2}/src/microEye/hardware/mieye/acquisition_manager.py

@@ -366,9 +366,13 @@ def z_stack_acquisition(
 
                     if (
                         FocusStabilizer.instance().isFocusStabilized(Axis.Z)
-                        and FocusStabilizer.instance().useCal()
+                        and FocusStabilizer.instance().isAdjustSetPoint()
                     ):
-                        value = FocusStabilizer.instance().calCoeff(Axis.Z) * step_size
+                        value = step_size
+                        if not FocusStabilizer.instance().useCal():
+                            value /= FocusStabilizer.instance().calCoeff(
+                                Axis.Z
+                            )
                         if reverse:
                             value *= -1
                         FocusStabilizer.instance().setParameter(value, True)
@@ -463,9 +467,7 @@ def z_calibration(
                 QtCore.QThread.msleep(delay * nFrames)
                 positions[x, 0] = x * step_size
                 _, snapshot = FocusStabilizer.instance().tracker_snapshot
-                positions[x, 1] = np.mean(
-                    snapshot[-nFrames:, 2]
-                )
+                positions[x, 1] = np.mean(snapshot[-nFrames:, 2])
         else:
             logger.warning('Z-calibration failed!')
             info = [{'Z-Stage Open': stage_manager.z_stage().is_open()}]

{microeye-2.4.1 → microeye-2.4.2}/src/microEye/hardware/stages/kinesis/kinesis.py

@@ -1,3 +1,4 @@
+import logging
 import traceback
 from typing import Optional
 
@@ -16,6 +17,8 @@ from microEye.qt import QtCore, QtSerialPort, QtWidgets, Signal
 from microEye.utils.parameter_tree import Tree
 from microEye.utils.thread_worker import QThreadWorker
 
+logger = logging.getLogger(__name__)
+
 
 class KinesisXY(AbstractStage):
     '''Class for controlling Two Kinesis Devices as an XY Stage'''
@@ -125,18 +128,23 @@ class KinesisXY(AbstractStage):
         if not isinstance(config, dict):
             raise ValueError('Config must be a dictionary.')
 
-        super().load_config(config)
-
-        x_config = config.get('X', {})
-        y_config = config.get('Y', {})
-
-        if isinstance(x_config, dict):
-            self.X.setBaudRate(x_config.get('baudrate', 115200))
-            self.X.setPortName(x_config.get('port', 'COM12'))
-
-        if isinstance(y_config, dict):
-            self.Y.setBaudRate(y_config.get('baudrate', 115200))
-            self.Y.setPortName(y_config.get('port', 'COM13'))
+        try:
+            x_config = config.get('X', {})
+            y_config = config.get('Y', {})
+
+            if isinstance(x_config, dict):
+                self.X.setBaudRate(x_config.get('baudrate', 115200))
+                self.X.setPortName(x_config.get('port', 'COM12'))
+
+            if isinstance(y_config, dict):
+                self.Y.setBaudRate(y_config.get('baudrate', 115200))
+                self.Y.setPortName(y_config.get('port', 'COM13'))
+        except Exception as e:
+            logger.error(
+                f'Error loading KinesisXY config: {e}\n{traceback.format_exc()}'
+            )
+        finally:
+            super().load_config(config)
 
 
 if __name__ == '__main__':

{microeye-2.4.1 → microeye-2.4.2}/src/microEye/hardware/stages/manager.py

@@ -137,7 +137,7 @@ class StageManager(QtCore.QObject):
         Move the stage in a specified direction by a specified
         number of steps in nanometers. Optional boolean argument
         to specify jump or step move. If FocusStabilizer is stabilizing
-        and use calibration is set to True, moves the center pixel value
+        and adjust set point is set to True, moves the center pixel value
         instead of the Z position when `interface` is True.
 
         Parameters
@@ -171,13 +171,17 @@ class StageManager(QtCore.QObject):
         if (
             focusStabilizer is not None
             and focusStabilizer.isFocusStabilized(Axis.Z)
-            and focusStabilizer.useCal()
+            and focusStabilizer.isAdjustSetPoint()
             and interface
         ):
             sign = 1 if dir else -1
             step_nm = Units.convert(
                 step_arg, self.z_stage().get_unit(Axis.Z), Units.NANOMETERS
             )
+            if not FocusStabilizer.instance().useCal():
+                step_nm /= FocusStabilizer.instance().calCoeff(
+                    Axis.Z
+                )
             focusStabilizer.setParameter(
                 step_nm * sign, True
             )

{microeye-2.4.1 → microeye-2.4.2}/src/microEye/hardware/stages/pycromanager/core.py

@@ -1,3 +1,4 @@
+import logging
 import time
 import traceback
 
@@ -8,6 +9,8 @@ from microEye.hardware.stages.stage import AbstractStage, Axis, Units, emit_afte
 from microEye.qt import QtCore, QtWidgets
 from microEye.utils.thread_worker import QThreadWorker
 
+logger = logging.getLogger(__name__)
+
 
 class PycroStageZ(PycroDevice, AbstractStage):
     NAME = 'PycroStage Z'
@@ -105,13 +108,18 @@ class PycroStageZ(PycroDevice, AbstractStage):
         if not isinstance(config, dict):
             raise ValueError('Config must be a dictionary.')
 
-        super().load_config(config)
-
-        pycromanager_config = config.get('pycromanager', {})
+        try:
+            pycromanager_config = config.get('pycromanager', {})
 
-        if isinstance(pycromanager_config, dict):
-            self._label = pycromanager_config.get('label', self.label)
-            self._port = pycromanager_config.get('port', self._port)
+            if isinstance(pycromanager_config, dict):
+                self._label = pycromanager_config.get('label', self.label)
+                self._port = pycromanager_config.get('port', self._port)
+        except Exception as e:
+            logger.error(
+                f'Error loading PycroManager config: {e}\n{traceback.format_exc()}'
+            )
+        finally:
+            super().load_config(config)
 
 
 class PycroStageXY(PycroDevice, AbstractStage):
@@ -170,16 +178,24 @@ class PycroStageXY(PycroDevice, AbstractStage):
     def move_relative(self, x: float, y: float, z: float = 0, **kwargs):
         is_async = kwargs.get('is_async', True)
         self.run_async(
-            self._core.set_relative_xy_position, x, y, self.label, is_async=is_async,
-            wait_func=self.wait
+            self._core.set_relative_xy_position,
+            x,
+            y,
+            self.label,
+            is_async=is_async,
+            wait_func=self.wait,
         )
 
     @emit_after_signal('moveFinished')
     def move_absolute(self, x: float, y: float, z: float = 0, **kwargs):
         is_async = kwargs.get('is_async', True)
         self.run_async(
-            self._core.set_xy_position, x, y, self.label, is_async=is_async,
-            wait_func=self.wait
+            self._core.set_xy_position,
+            x,
+            y,
+            self.label,
+            is_async=is_async,
+            wait_func=self.wait,
         )
 
     def wait(self, timeout: float = 5.0):
@@ -243,10 +259,13 @@ class PycroStageXY(PycroDevice, AbstractStage):
         if not isinstance(config, dict):
             raise ValueError('Config must be a dictionary.')
 
-        super().load_config(config)
-
-        pycromanager_config = config.get('pycromanager', {})
+        try:
+            pycromanager_config = config.get('pycromanager', {})
 
-        if isinstance(pycromanager_config, dict):
-            self._label = pycromanager_config.get('label', self.label)
-            self._port = pycromanager_config.get('port', self._port)
+            if isinstance(pycromanager_config, dict):
+                self._label = pycromanager_config.get('label', self.label)
+                self._port = pycromanager_config.get('port', self._port)
+        except Exception as e:
+            logger.error(f'Error loading PycroManager config: {e}')
+        finally:
+            super().load_config(config)

{microeye-2.4.1 → microeye-2.4.2}/src/microEye/hardware/stages/smaract/mcs2.py

@@ -506,12 +506,15 @@ class MCS2Stage(AbstractStage):
         if not isinstance(config, dict):
             raise ValueError('Config must be a dictionary.')
 
-        super().load_config(config)
-
-        locator = config.get('locator')
-        if locator is not None:
-            self.close()
-            self.locator = locator
+        try:
+            locator = config.get('locator')
+            if locator is not None:
+                self.close()
+                self.locator = locator
+        except Exception as e:
+            logger.error(f'Error loading MCS2 config: {e}')
+        finally:
+            super().load_config(config)
 
     def _initialize_channels(self):
         if not self.is_open():

{microeye-2.4.1 → microeye-2.4.2}/src/microEye/hardware/stages/stabilization/methods.py

@@ -149,6 +149,16 @@ class CalibrationManager:
     def __init__(self):
         self.__cal_coeffs = np.ones((3,))  # nm/pixel
 
+        self.__use_calibration = False
+
+    def enable_calibration(self, enable: bool = True):
+        '''Enable or disable calibration'''
+        self.__use_calibration = enable
+
+    def is_calibration_enabled(self) -> bool:
+        '''Check if calibration is enabled'''
+        return self.__use_calibration
+
     def get_coefficient(self, axis: Axis = None) -> Union[float, np.ndarray]:
         '''Get calibration coefficient for axis'''
         if axis is None:
@@ -162,7 +172,9 @@ class CalibrationManager:
 
     def convert_to_physical(self, pixels: float, axis: Axis) -> float:
         '''Convert pixel measurement to physical units'''
-        return pixels * self.get_coefficient(axis)
+        if self.is_calibration_enabled():
+            return pixels * self.get_coefficient(axis)
+        return pixels
 
 
 class PositionTracker:
@@ -256,7 +268,7 @@ class StabilizationMethods(Enum):
 class StabilizationStrategy(ABC):
     '''Base class for stabilization method strategies'''
 
-    PARAMS : dict[str, dict] = {}
+    PARAMS: dict[str, dict] = {}
 
     def __init__(self):
         # Isolate mutable nested defaults between strategy instances.
@@ -388,7 +400,7 @@ class ReflectionStrategy(StabilizationStrategy):
         params = {'xy': None, 'z': None}
         if fit_params is not None:
             z_center = fit_params[1]  # x0 from GaussianOffSet
-            z_physical = z_center * calibration_manager.get_coefficient(Axis.Z)
+            z_physical = calibration_manager.convert_to_physical(z_center, Axis.Z)
             params['z'] = z_physical
 
         return {
@@ -697,7 +709,9 @@ class FiducialStrategy(StabilizationStrategy):
                 fit_params[:, 4] ** 2 - fit_params[:, 5] ** 2
                 if self.fit_method
                 else fit_params[:, 4]
-            ) * calibration_manager.get_coefficient(Axis.Z)
+            )
+
+            z_param = calibration_manager.convert_to_physical(z_param, Axis.Z)
 
             z_param = np.nanmean(controller.outlier_rejection(z_param))
 
@@ -734,12 +748,11 @@ class FiducialStrategy(StabilizationStrategy):
         if xy_shift is not None:
             x_shifts, y_shifts = xy_shift
 
-            x_shift = np.nanmean(
-                controller.outlier_rejection(x_shifts)
-            ) * calibration_manager.get_coefficient(Axis.X)
-            y_shift = np.nanmean(
-                controller.outlier_rejection(y_shifts)
-            ) * calibration_manager.get_coefficient(Axis.Y)
+            x_shift = np.nanmean(controller.outlier_rejection(x_shifts))
+            y_shift = np.nanmean(controller.outlier_rejection(y_shifts))
+
+            x_shift = calibration_manager.convert_to_physical(x_shift, Axis.X)
+            y_shift = calibration_manager.convert_to_physical(y_shift, Axis.Y)
 
             shifts[Axis.X] = x_shift
             shifts[Axis.Y] = y_shift
@@ -835,6 +848,7 @@ class HybridStrategy(StabilizationStrategy):
     - Z from ReflectionStrategy
     - XY from FiducialStrategy
     '''
+
     PARAMS = {
         **ReflectionStrategy.PARAMS,
         **FiducialStrategy.PARAMS,

{microeye-2.4.1 → microeye-2.4.2}/src/microEye/hardware/stages/stabilizer.py

@@ -48,6 +48,7 @@ class FocusStabilizerParams(Enum):
     N_FRAMES = 'Number of Frames'
     FRAMES_STATS = 'Frames Statistics'
     LINE_WIDTH = 'Line ROI Width'
+    EXTERNAL_PREVIEW = 'External Preview'
     SAVE = 'Save'
     LOAD = 'Load'
 
@@ -59,10 +60,13 @@ class FocusStabilizerParams(Enum):
     STABILIZATION_METHOD = 'Method'
     METHOD_PARAMS = 'Method Parameters'
 
-    USE_CAL = 'Use Calibration'
-    X_CALIBRATION = 'Calibration (X) [nm/pixel]'
-    Y_CALIBRATION = 'Calibration (Y) [nm/pixel]'
-    Z_CALIBRATION = 'Calibration (Z) [nm/pixel]'
+    CALIBRATION = 'Calibration'
+
+    USE_CAL = 'Calibration.Active'
+    X_CALIBRATION = 'Calibration.(X) [nm/pixel]'
+    Y_CALIBRATION = 'Calibration.(Y) [nm/pixel]'
+    Z_CALIBRATION = 'Calibration.(Z) [nm/pixel]'
+    ADJUST_SET_POINT = 'Calibration.Adjust Set Point'
 
     XY_OUTLIER_REJECTION = 'XY Outlier Rejection'
     XY_OUTLIER_REJECTION_METHOD = 'XY Outlier Rejection.Method'
@@ -167,7 +171,9 @@ class FocusStabilizer(QtCore.QObject):
         # Calibration manager
         self.__cal_manager = CalibrationManager()
 
-        self.__use_cal = False
+        # Adjust set point flag
+        self.__adjust_set_point = False
+
         self.__inverted = np.zeros((3,), dtype=bool)
 
         self.__n_frames = 1
@@ -330,7 +336,7 @@ class FocusStabilizer(QtCore.QObject):
         bool
             True if pixel calibration coefficient is used, False otherwise.
         '''
-        return self.__use_cal
+        return self.__cal_manager.is_calibration_enabled()
 
     def setUseCal(self, use_cal: bool):
         '''
@@ -341,7 +347,29 @@ class FocusStabilizer(QtCore.QObject):
         use_cal : bool
             The flag value.
         '''
-        self.__use_cal = use_cal
+        self.__cal_manager.enable_calibration(use_cal)
+
+    def isAdjustSetPoint(self):
+        '''
+        Check if adjust set point option is enabled.
+
+        Returns
+        -------
+        bool
+            True if adjust set point option is enabled, False otherwise.
+        '''
+        return self.__adjust_set_point
+
+    def setAdjustSetPoint(self, adjust: bool):
+        '''
+        Set the flag indicating whether to adjust the set point.
+
+        Parameters
+        ----------
+        adjust : bool
+            The flag value.
+        '''
+        self.__adjust_set_point = adjust
 
     def isInverted(self, axis: Optional[Axis]):
         '''
@@ -626,7 +654,8 @@ class FocusStabilizer(QtCore.QObject):
             'tau': self.__tau,
             'error_th': self.__err_th,
             'cal_coeff': self.__cal_manager.get_coefficient().tolist(),
-            'use_cal': self.__use_cal,
+            'use_cal': self.useCal(),
+            'adjust_set_point': self.isAdjustSetPoint(),
             'inverted': self.__inverted.tolist(),
             'method': str(self.__method),
             'strategy_params': self.get_current_strategy_param_values(),
@@ -848,6 +877,7 @@ class FocusStabilizer(QtCore.QObject):
 class FocusStabilizerView(Tree):
     PARAMS = FocusStabilizerParams
     setRoiActivated = Signal()
+    actionActivated = Signal(str)
     saveActivated = Signal()
     loadActivated = Signal()
     methodChanged = Signal(StabilizationMethods)
@@ -926,6 +956,7 @@ class FocusStabilizerView(Tree):
                 'limits': [1, 100],
                 'step': 1,
             },
+            {'name': str(FocusStabilizerParams.EXTERNAL_PREVIEW), 'type': 'action'},
             {'name': str(FocusStabilizerParams.SAVE), 'type': 'action'},
             {'name': str(FocusStabilizerParams.LOAD), 'type': 'action'},
             {
@@ -960,40 +991,54 @@ class FocusStabilizerView(Tree):
             {
                 'name': str(FocusStabilizerParams.METHOD_PARAMS),
                 'type': 'group',
+                'expanded': False,
                 'children': [],
             },
             {
-                'name': str(FocusStabilizerParams.USE_CAL),
-                'type': 'bool',
-                'value': False,
-            },
-            {
-                'name': str(FocusStabilizerParams.X_CALIBRATION),
-                'type': 'float',
-                'value': 1.0,
-                'step': 0.01,
-                'dec': False,
-                'decimals': 6,
-            },
-            {
-                'name': str(FocusStabilizerParams.Y_CALIBRATION),
-                'type': 'float',
-                'value': 1.0,
-                'step': 0.01,
-                'dec': False,
-                'decimals': 6,
-            },
-            {
-                'name': str(FocusStabilizerParams.Z_CALIBRATION),
-                'type': 'float',
-                'value': 1.0,
-                'step': 0.01,
-                'dec': False,
-                'decimals': 6,
+                'name': str(FocusStabilizerParams.CALIBRATION),
+                'type': 'group',
+                'expanded': False,
+                'children': [
+                    {
+                        'name': str(FocusStabilizerParams.USE_CAL),
+                        'type': 'bool',
+                        'value': False,
+                    },
+                    {
+                        'name': str(FocusStabilizerParams.X_CALIBRATION),
+                        'type': 'float',
+                        'value': 1.0,
+                        'step': 0.01,
+                        'dec': False,
+                        'decimals': 6,
+                    },
+                    {
+                        'name': str(FocusStabilizerParams.Y_CALIBRATION),
+                        'type': 'float',
+                        'value': 1.0,
+                        'step': 0.01,
+                        'dec': False,
+                        'decimals': 6,
+                    },
+                    {
+                        'name': str(FocusStabilizerParams.Z_CALIBRATION),
+                        'type': 'float',
+                        'value': 1.0,
+                        'step': 0.01,
+                        'dec': False,
+                        'decimals': 6,
+                    },
+                    {
+                        'name': str(FocusStabilizerParams.ADJUST_SET_POINT),
+                        'type': 'bool',
+                        'value': False,
+                    },
+                ],
             },
             {
                 'name': str(FocusStabilizerParams.XY_OUTLIER_REJECTION),
                 'type': 'group',
+                'expanded': False,
                 'children': [
                     {
                         'name': str(FocusStabilizerParams.XY_OUTLIER_REJECTION_METHOD),
@@ -1022,6 +1067,7 @@ class FocusStabilizerView(Tree):
             {
                 'name': str(FocusStabilizerParams.X),
                 'type': 'group',
+                'expanded': False,
                 'children': [
                     {
                         'name': str(FocusStabilizerParams.X_INVERTED),
@@ -1057,6 +1103,7 @@ class FocusStabilizerView(Tree):
             {
                 'name': str(FocusStabilizerParams.Y),
                 'type': 'group',
+                'expanded': False,
                 'children': [
                     {
                         'name': str(FocusStabilizerParams.Y_INVERTED),
@@ -1092,6 +1139,7 @@ class FocusStabilizerView(Tree):
             {
                 'name': str(FocusStabilizerParams.Z),
                 'type': 'group',
+                'expanded': False,
                 'children': [
                     {
                         'name': str(FocusStabilizerParams.Z_INVERTED),
@@ -1150,6 +1198,11 @@ class FocusStabilizerView(Tree):
             QtWidgets.QHeaderView.ResizeMode.ResizeToContents
         )
 
+        self.get_param(FocusStabilizerParams.EXTERNAL_PREVIEW).sigActivated.connect(
+            lambda: self.actionActivated.emit(
+                FocusStabilizerParams.EXTERNAL_PREVIEW.value
+            )
+        )
         self.get_param(FocusStabilizerParams.SAVE).sigActivated.connect(
             self.export_config
         )
@@ -1286,6 +1339,8 @@ class FocusStabilizerView(Tree):
                 FocusStabilizer.instance().setInverted(data, Axis.Z)
             if fsParam == FocusStabilizerParams.USE_CAL:
                 FocusStabilizer.instance().setUseCal(data)
+            if fsParam == FocusStabilizerParams.ADJUST_SET_POINT:
+                FocusStabilizer.instance().setAdjustSetPoint(data)
             if fsParam == FocusStabilizerParams.FOCUS_PARAMETER:
                 FocusStabilizer.instance().setParameter(data)
 
@@ -1452,6 +1507,10 @@ class FocusStabilizerView(Tree):
             self.set_param_value(
                 FocusStabilizerParams.USE_CAL, bool(stabilizer.get('use_cal'))
             )
+            self.set_param_value(
+                FocusStabilizerParams.ADJUST_SET_POINT,
+                bool(stabilizer.get('adjust_set_point')),
+            )
             self.set_param_value(FocusStabilizerParams.FT_TAU, float(tau))
             self.set_param_value(FocusStabilizerParams.FT_ERROR_TH, float(error_th))
             self.set_param_value(FocusStabilizerParams.STABILIZATION_METHOD, method)