dls-dodal 1.65.0__py3-none-any.whl → 1.67.0__py3-none-any.whl

dodal/devices/insertion_device/lookup_table_models.py

@@ -0,0 +1,287 @@
+"""Apple2 lookup table utilities and CSV converter.
+
+This module provides helpers to read, validate and convert Apple2 insertion-device
+lookup tables (energy -> gap/phase polynomials) from CSV sources into an
+in-memory dictionary format used by the Apple2 controllers.
+
+Data format produced
+The lookup-table dictionary created by convert_csv_to_lookup() follows this
+structure:
+
+{
+  "POL_MODE": {
+    "energy_entries": [
+        {
+            "low": <float>,
+            "high": <float>,
+            "poly": <numpy.poly1d>
+        },
+      ...
+    ]
+  },
+  ...
+}
+"""
+
+import csv
+import io
+from collections.abc import Generator
+from typing import Annotated as A
+from typing import Any, NamedTuple, Self
+
+import numpy as np
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    RootModel,
+    field_serializer,
+    field_validator,
+)
+
+from dodal.devices.insertion_device.apple2_undulator import Pol
+
+DEFAULT_POLY_DEG = [
+    "7th-order",
+    "6th-order",
+    "5th-order",
+    "4th-order",
+    "3rd-order",
+    "2nd-order",
+    "1st-order",
+    "b",
+]
+
+MODE_NAME_CONVERT = {"cr": "pc", "cl": "nc"}
+DEFAULT_GAP_FILE = "IDEnergy2GapCalibrations.csv"
+DEFAULT_PHASE_FILE = "IDEnergy2PhaseCalibrations.csv"
+
+ROW_PHASE_MOTOR_TOLERANCE = 0.004
+ROW_PHASE_CIRCULAR = 15
+MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
+MAXIMUM_GAP_MOTOR_POSITION = 100
+
+DEFAULT_POLY1D_PARAMETERS = {
+    Pol.LH: [0],
+    Pol.LV: [MAXIMUM_ROW_PHASE_MOTOR_POSITION],
+    Pol.PC: [ROW_PHASE_CIRCULAR],
+    Pol.NC: [-ROW_PHASE_CIRCULAR],
+    Pol.LH3: [0],
+}
+
+
+class Source(NamedTuple):
+    column: str
+    value: str
+
+
+class LookupTableColumnConfig(BaseModel):
+    """Configuration on how to process a csv file columns into a LookupTable data model."""
+
+    source: A[
+        Source | None,
+        Field(
+            description="If not None, only process the row if the source column name match the value."
+        ),
+    ] = None
+    mode: A[str, Field(description="Polarisation mode column name.")] = "Mode"
+    min_energy: A[str, Field(description="Minimum energy column name.")] = "MinEnergy"
+    max_energy: A[str, Field(description="Maximum energy column name.")] = "MaxEnergy"
+    poly_deg: list[str] = Field(
+        description="Polynomial column names.", default_factory=lambda: DEFAULT_POLY_DEG
+    )
+    mode_name_convert: dict[str, str] = Field(
+        description="When processing polarisation mode values, map their alias values to a real value.",
+        default_factory=lambda: MODE_NAME_CONVERT,
+    )
+
+
+class EnergyCoverageEntry(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)  # So np.poly1d can be used.
+    min_energy: float
+    max_energy: float
+    poly: np.poly1d
+
+    @field_validator("poly", mode="before")
+    @classmethod
+    def validate_and_convert_poly(
+        cls: type[Self], value: np.poly1d | list
+    ) -> np.poly1d:
+        """If reading from serialized data, it will be using a list. Convert to np.poly1d"""
+        if isinstance(value, list):
+            return np.poly1d(value)
+        return value
+
+    @field_serializer("poly", mode="plain")
+    def serialize_poly(self, value: np.poly1d) -> list:
+        """Allow np.poly1d to work when serializing."""
+        return value.coefficients.tolist()
+
+
+class EnergyCoverage(BaseModel):
+    energy_entries: list[EnergyCoverageEntry]
+
+    @classmethod
+    def generate(
+        cls: type[Self],
+        min_energies: list[float],
+        max_energies: list[float],
+        poly1d_params: list[list[float]],
+    ) -> Self:
+        energy_entries = [
+            EnergyCoverageEntry(
+                min_energy=min_energy,
+                max_energy=max_energy,
+                poly=np.poly1d(poly_params),
+            )
+            for min_energy, max_energy, poly_params in zip(
+                min_energies, max_energies, poly1d_params, strict=True
+            )
+        ]
+        return cls(energy_entries=energy_entries)
+
+    @property
+    def min_energy(self) -> float:
+        return min(e.min_energy for e in self.energy_entries)
+
+    @property
+    def max_energy(self) -> float:
+        return max(e.max_energy for e in self.energy_entries)
+
+    def get_poly(self, energy: float) -> np.poly1d:
+        """
+        Return the numpy.poly1d polynomial applicable for the given energy.
+
+        Parameters:
+        -----------
+        energy:
+            Energy value in the same units used to create the lookup table.
+        """
+        # Cache initial values so don't do unnecessary work again
+        min_energy = self.min_energy
+        max_energy = self.max_energy
+        if energy < min_energy or energy > max_energy:
+            raise ValueError(
+                f"Demanding energy must lie between {min_energy} and {max_energy}!"
+            )
+        else:
+            for energy_coverage in self.energy_entries:
+                if (
+                    energy >= energy_coverage.min_energy
+                    and energy < energy_coverage.max_energy
+                ):
+                    return energy_coverage.poly
+        raise ValueError(
+            "Cannot find polynomial coefficients for your requested energy."
+            + " There might be gap in the calibration lookup table."
+        )
+
+
+class LookupTable(RootModel[dict[Pol, EnergyCoverage]]):
+    """
+    Specialised lookup table for insertion devices to relate the energy and polarisation
+    values to Apple2 motor positions.
+    """
+
+    # Allow to auto specify a dict if one not provided
+    def __init__(self, root: dict[Pol, EnergyCoverage] | None = None):
+        super().__init__(root=root or {})
+
+    @classmethod
+    def generate(
+        cls: type[Self],
+        pols: list[Pol],
+        energy_coverage: list[EnergyCoverage],
+    ) -> Self:
+        """Generate a LookupTable containing multiple EnergyCoverage
+        for provided polarisations."""
+        lut = cls()
+        for i in range(len(pols)):
+            lut.root[pols[i]] = energy_coverage[i]
+        return lut
+
+    def get_poly(
+        self,
+        energy: float,
+        pol: Pol,
+    ) -> np.poly1d:
+        """
+        Return the numpy.poly1d polynomial applicable for the given energy and polarisation.
+
+        Parameters:
+        -----------
+        energy:
+            Energy value in the same units used to create the lookup table.
+        pol:
+            Polarisation mode (Pol enum).
+        """
+        return self.root[pol].get_poly(energy)
+
+
+def convert_csv_to_lookup(
+    file_contents: str,
+    lut_config: LookupTableColumnConfig,
+    skip_line_start_with: str = "#",
+) -> LookupTable:
+    """
+    Convert CSV content into the Apple2 lookup-table dictionary.
+
+    Parameters:
+    -----------
+    file_contents:
+        The CSV file contents as string.
+    lut_config:
+        The configuration that how to process the file_contents into a LookupTable.
+    skip_line_start_with
+        Lines beginning with this prefix are skipped (default "#").
+
+    Returns:
+    -----------
+    LookupTable
+    """
+
+    def process_row(row: dict[str, Any], lut: LookupTable) -> None:
+        """Process a single row from the CSV file and update the lookup table."""
+        raw_mode_value = str(row[lut_config.mode]).lower()
+        mode_value = Pol(
+            lut_config.mode_name_convert.get(raw_mode_value, raw_mode_value)
+        )
+
+        # Create polynomial object for energy-to-gap/phase conversion
+        coefficients = np.poly1d([float(row[coef]) for coef in lut_config.poly_deg])
+
+        energy_entry = EnergyCoverageEntry(
+            min_energy=float(row[lut_config.min_energy]),
+            max_energy=float(row[lut_config.max_energy]),
+            poly=coefficients,
+        )
+        if mode_value not in lut.root:
+            lut.root[mode_value] = EnergyCoverage(energy_entries=[energy_entry])
+        else:
+            lut.root[mode_value].energy_entries.append(energy_entry)
+
+    reader = csv.DictReader(read_file_and_skip(file_contents, skip_line_start_with))
+    lut = LookupTable()
+
+    for row in reader:
+        source = lut_config.source
+        # If there are multiple source only convert requested.
+        if source is None or row[source.column] == source.value:
+            process_row(row=row, lut=lut)
+
+    # Check if our LookupTable is empty after processing, raise error if it is.
+    if not lut.root:
+        raise RuntimeError(
+            "LookupTable content is empty, failed to convert the file contents to "
+            "a LookupTable!"
+        )
+    return lut
+
+
+def read_file_and_skip(file: str, skip_line_start_with: str = "#") -> Generator[str]:
+    """Yield non-comment lines from the CSV content string."""
+    for line in io.StringIO(file):
+        if line.startswith(skip_line_start_with):
+            continue
+        else:
+            yield line

dodal/devices/ipin.py

@@ -1,5 +1,22 @@
-from ophyd_async.core import StandardReadable, StandardReadableFormat
-from ophyd_async.epics.core import epics_signal_r
+from ophyd_async.core import StandardReadable, StandardReadableFormat, SubsetEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+
+class IPinGain(SubsetEnum):
+    GAIN_10E3_LOW_NOISE = "10^3 low noise"
+    GAIN_10E4_LOW_NOISE = "10^4 low noise"
+    GAIN_10E5_LOW_NOISE = "10^5 low noise"
+    GAIN_10E6_LOW_NOISE = "10^6 low noise"
+    GAIN_10E7_LOW_NOISE = "10^7 low noise"
+    GAIN_10E8_LOW_NOISE = "10^8 low noise"
+    GAIN_10E9_LOW_NOISE = "10^9 low noise"
+    GAIN_10E5_HIGH_SPEED = "10^5 high speed"
+    GAIN_10E6_HIGH_SPEED = "10^6 high speed"
+    GAIN_10E7_HIGH_SPEED = "10^7 high speed"
+    GAIN_10E8_HIGH_SPEED = "10^8 high speed"
+    GAIN_10E9_HIGH_SPEED = "10^9 high speed"
+    GAIN_10E10_HIGH_SPEED = "10^10 high spd"
+    GAIN_10E11_HIGH_SPEED = "10^11 high spd"
 
 
 class IPin(StandardReadable):
@@ -10,4 +27,5 @@ class IPin(StandardReadable):
             format=StandardReadableFormat.HINTED_SIGNAL
         ):
             self.pin_readback = epics_signal_r(float, prefix + "I")
+            self.gain = epics_signal_rw(IPinGain, prefix + "GAIN")
         super().__init__(name)

dodal/devices/motors.py

@@ -7,6 +7,8 @@ from ophyd_async.epics.motor import Motor
 
 _X, _Y, _Z = "X", "Y", "Z"
 
+_OMEGA = "OMEGA"
+
 
 class Stage(StandardReadable, ABC):
     """
@@ -77,6 +79,21 @@ class XYZThetaStage(XYZStage):
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
 
+class XYZOmegaStage(XYZStage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        omega_infix: str = _OMEGA,
+    ) -> None:
+        with self.add_children_as_readables():
+            self.omega = Motor(prefix + omega_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
 class XYPhiStage(XYStage):
     def __init__(
         self,
@@ -105,6 +122,20 @@ class XYPitchStage(XYStage):
         super().__init__(prefix, name, x_infix, y_infix)
 
 
+class XYRollStage(XYStage):
+    def __init__(
+        self,
+        prefix: str,
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        roll_infix: str = "ROLL",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.roll = Motor(prefix + roll_infix)
+        super().__init__(prefix, name, x_infix, y_infix)
+
+
 class XYZPitchYawStage(XYZStage):
     def __init__(
         self,
@@ -141,7 +172,7 @@ class XYZPitchYawRollStage(XYZStage):
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
 
-class SixAxisGonio(XYZStage):
+class SixAxisGonio(XYZOmegaStage):
     def __init__(
         self,
         prefix: str,
@@ -151,7 +182,7 @@ class SixAxisGonio(XYZStage):
         z_infix: str = _Z,
         kappa_infix: str = "KAPPA",
         phi_infix: str = "PHI",
-        omega_infix: str = "OMEGA",
+        omega_infix: str = _OMEGA,
     ):
         """Six-axis goniometer with a standard xyz stage and three axes of rotation:
         kappa, phi and omega.
@@ -159,7 +190,6 @@ class SixAxisGonio(XYZStage):
         with self.add_children_as_readables():
             self.kappa = Motor(prefix + kappa_infix)
             self.phi = Motor(prefix + phi_infix)
-            self.omega = Motor(prefix + omega_infix)
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
         self.vertical_in_lab_space = create_axis_perp_to_rotation(

dodal/devices/mx_phase1/beamstop.py

@@ -10,6 +10,8 @@ from ophyd_async.epics.motor import Motor
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
 
+_BEAMSTOP_OUT_DELTA_Y_MM = -2
+
 
 class BeamstopPositions(StrictEnum):
     """
@@ -28,6 +30,7 @@ class BeamstopPositions(StrictEnum):
     """
 
     DATA_COLLECTION = "Data Collection"
+    OUT_OF_BEAM = "Out"
     UNKNOWN = "Unknown"
 
 
@@ -63,6 +66,10 @@ class Beamstop(StandardReadable):
             float(beamline_parameters[f"in_beam_{axis}_STANDARD"])
             for axis in ("x", "y", "z")
         ]
+
+        self._out_of_beam_xyz_mm = list(self._in_beam_xyz_mm)
+        self._out_of_beam_xyz_mm[1] += _BEAMSTOP_OUT_DELTA_Y_MM
+
         self._xyz_tolerance_mm = [
             float(beamline_parameters[f"bs_{axis}_tolerance"])
             for axis in ("x", "y", "z")
@@ -72,24 +79,36 @@ class Beamstop(StandardReadable):
 
     def _get_selected_position(self, x: float, y: float, z: float) -> BeamstopPositions:
         current_pos = [x, y, z]
-        if all(
-            isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
-            for axis_pos, axis_in_beam, axis_tolerance in zip(
-                current_pos, self._in_beam_xyz_mm, self._xyz_tolerance_mm, strict=False
-            )
-        ):
+        if self._is_near_position(current_pos, self._in_beam_xyz_mm):
             return BeamstopPositions.DATA_COLLECTION
+        elif self._is_near_position(current_pos, self._out_of_beam_xyz_mm):
+            return BeamstopPositions.OUT_OF_BEAM
         else:
             return BeamstopPositions.UNKNOWN
 
+    def _is_near_position(
+        self, current_pos: list[float], target_pos: list[float]
+    ) -> bool:
+        return all(
+            isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
+            for axis_pos, axis_in_beam, axis_tolerance in zip(
+                current_pos, target_pos, self._xyz_tolerance_mm, strict=False
+            )
+        )
+
     async def _set_selected_position(self, position: BeamstopPositions) -> None:
         match position:
             case BeamstopPositions.DATA_COLLECTION:
-                # Move z first as it could be under the table
-                await self.z_mm.set(self._in_beam_xyz_mm[2])
-                await asyncio.gather(
-                    self.x_mm.set(self._in_beam_xyz_mm[0]),
-                    self.y_mm.set(self._in_beam_xyz_mm[1]),
-                )
+                await self._safe_move_above_table(self._in_beam_xyz_mm)
+            case BeamstopPositions.OUT_OF_BEAM:
+                await self._safe_move_above_table(self._out_of_beam_xyz_mm)
             case _:
                 raise ValueError(f"Cannot set beamstop to position {position}")
+
+    async def _safe_move_above_table(self, pos: list[float]):
+        # Move z first as it could be under the table
+        await self.z_mm.set(pos[2])
+        await asyncio.gather(
+            self.x_mm.set(pos[0]),
+            self.y_mm.set(pos[1]),
+        )

dodal/devices/oav/oav_calculations.py

@@ -7,6 +7,9 @@ def camera_coordinates_to_xyz_mm(
     omega: float,
     microns_per_i_pixel: float,
     microns_per_j_pixel: float,
+    x_horizontal_sign: int,
+    y_vertical_sign: int,
+    z_vertical_sign: int,
 ) -> np.ndarray:
     """
     Converts from (horizontal,vertical) pixel measurements from the OAV camera into to (x, y, z) motor coordinates in millimetres.
@@ -18,13 +21,16 @@ def camera_coordinates_to_xyz_mm(
         omega (float): The omega angle of the smargon that the horizontal, vertical measurements were obtained at.
         microns_per_i_pixel (float): The number of microns per i pixel, adjusted for the zoom level horizontal was measured at.
         microns_per_j_pixel (float): The number of microns per j pixel, adjusted for the zoom level vertical was measured at.
+        x_horizontal_sign (int): Direction mapping for x, positive means the oav and motor are on same direction, default from hyperion
+        y_vertical_sign (int): Direction mapping for y
+        z_vertical_sign (int): Direction mapping for z
     """
     # Convert the vertical and horizontal into mm.
     horizontal *= microns_per_i_pixel * 1e-3
     vertical *= microns_per_j_pixel * 1e-3
 
     # +ve x in the OAV camera becomes -ve x in the smargon motors.
-    x = -horizontal
+    x = x_horizontal_sign * horizontal
 
     # Rotating the camera causes the position on the vertical horizontal to change by raising or lowering the centre.
     # We can negate this change by multiplying sin and cosine of the omega.
@@ -33,9 +39,8 @@ def camera_coordinates_to_xyz_mm(
     sine = np.sin(radians)
 
     # +ve y in the OAV camera becomes -ve y in the smargon motors/
-    y = -vertical * cosine
-
-    z = vertical * sine
+    y = y_vertical_sign * vertical * cosine
+    z = z_vertical_sign * vertical * sine
     return np.array([x, y, z], dtype=np.float64)
 
 

dodal/devices/oav/oav_detector.py

@@ -46,9 +46,14 @@ class NullZoomController(BaseZoomController):
     def __init__(self):
         self.level = soft_signal_rw(str, "1.0x")
         self.percentage = soft_signal_rw(float, 100)
+        super().__init__()
 
-    def set(self, value):
-        raise Exception("Attempting to set zoom level of a null zoom controller")
+    @AsyncStatus.wrap
+    async def set(self, value: str) -> None:
+        if value != "1.0x":
+            raise Exception("Attempting to set zoom level of a null zoom controller")
+        else:
+            await self.level.set(value, wait=True)
 
 
 class ZoomController(BaseZoomController):
@@ -74,6 +79,16 @@ class ZoomController(BaseZoomController):
 
 
 class OAV(StandardReadable):
+    """
+    Class for oav device
+
+    x_direction(int): Should only be 1 or -1, with 1 indicating the oav x direction is the same with motor x
+    y_direction(int): Same with x_direction but for motor y
+    z_direction(int): Same with x_direction but for motor z
+    mjpg_x_size_pv(str): PV infix for x_size in mjpg
+    mjpg_y_size_pv(str): PV infix for y_size in mjpg
+    """
+
     beam_centre_i: SignalR[int]
     beam_centre_j: SignalR[int]
 
@@ -82,7 +97,13 @@ class OAV(StandardReadable):
         prefix: str,
         config: OAVConfigBase,
         name: str = "",
+        mjpeg_prefix: str = "MJPG",
         zoom_controller: BaseZoomController | None = None,
+        x_direction: int = -1,
+        y_direction: int = -1,
+        z_direction: int = 1,
+        mjpg_x_size_pv: str = "ArraySize1_RBV",
+        mjpg_y_size_pv: str = "ArraySize2_RBV",
     ):
         self.oav_config = config
         self._prefix = prefix
@@ -98,9 +119,15 @@ class OAV(StandardReadable):
 
         self.cam = Cam(f"{prefix}CAM:", name=name)
         with self.add_children_as_readables():
-            self.grid_snapshot = SnapshotWithGrid(f"{prefix}MJPG:", name)
+            self.grid_snapshot = SnapshotWithGrid(
+                f"{prefix}{mjpeg_prefix}:", name, mjpg_x_size_pv, mjpg_y_size_pv
+            )
 
         self.sizes = [self.grid_snapshot.x_size, self.grid_snapshot.y_size]
+        with self.add_children_as_readables():
+            self.x_direction = soft_signal_rw(int, x_direction, name="x_direction")
+            self.y_direction = soft_signal_rw(int, y_direction, name="y_direction")
+            self.z_direction = soft_signal_rw(int, z_direction, name="z_direction")
 
         with self.add_children_as_readables():
             self.microns_per_pixel_x = derived_signal_r(
@@ -116,7 +143,7 @@ class OAV(StandardReadable):
                 coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
             )
             self.snapshot = Snapshot(
-                f"{self._prefix}MJPG:",
+                f"{self._prefix}{mjpeg_prefix}:",
                 self._name,
             )
 
@@ -143,9 +170,16 @@ class OAV(StandardReadable):
 
 
 class OAVBeamCentreFile(OAV):
-    """OAV device that reads its beam centre values from a file. The config parameter
+    """
+    OAV device that reads its beam centre values from a file. The config parameter
     must be a OAVConfigBeamCentre object, as this contains a filepath to where the beam
     centre values are stored.
+
+    x_direction(int): Should only be 1 or -1, with 1 indicating the oav x direction is the same with motor x
+    y_direction(int): Same with x_direction but for motor y
+    z_direction(int): Same with x_direction but for motor z
+    mjpg_x_size_pv(str): PV infix for x_size in mjpg
+    mjpg_y_size_pv(str): PV infix for y_size in mjpg
     """
 
     def __init__(
@@ -153,9 +187,26 @@ class OAVBeamCentreFile(OAV):
         prefix: str,
         config: OAVConfigBeamCentre,
         name: str = "",
+        mjpeg_prefix: str = "MJPG",
         zoom_controller: BaseZoomController | None = None,
+        mjpg_x_size_pv: str = "ArraySize1_RBV",
+        mjpg_y_size_pv: str = "ArraySize2_RBV",
+        x_direction: int = -1,
+        y_direction: int = -1,
+        z_direction: int = 1,
     ):
-        super().__init__(prefix, config, name, zoom_controller)
+        super().__init__(
+            prefix=prefix,
+            config=config,
+            name=name,
+            mjpeg_prefix=mjpeg_prefix,
+            zoom_controller=zoom_controller,
+            mjpg_x_size_pv=mjpg_x_size_pv,
+            mjpg_y_size_pv=mjpg_y_size_pv,
+            x_direction=x_direction,
+            y_direction=y_direction,
+            z_direction=z_direction,
+        )
 
         with self.add_children_as_readables():
             self.beam_centre_i = derived_signal_r(
@@ -189,6 +240,7 @@ class OAVBeamCentrePV(OAV):
         prefix: str,
         config: OAVConfig,
         name: str = "",
+        mjpeg_prefix: str = "MJPG",
         zoom_controller: BaseZoomController | None = None,
         overlay_channel: int = 1,
     ):
@@ -199,4 +251,10 @@ class OAVBeamCentrePV(OAV):
             self.beam_centre_j = epics_signal_r(
                 int, prefix + f"OVER:{overlay_channel}:CenterY"
             )
-        super().__init__(prefix, config, name, zoom_controller)
+        super().__init__(
+            prefix=prefix,
+            config=config,
+            name=name,
+            mjpeg_prefix=mjpeg_prefix,
+            zoom_controller=zoom_controller,
+        )

dodal/devices/oav/oav_parameters.py

@@ -92,8 +92,10 @@ class OAVParameters:
         self.preprocess_K_size: int = update(
             "preProcessKSize", int
         )  # length scale for blur preprocessing
+        self.preprocess_iter: int = update("preProcessIteration", int, default=5)
         self.detection_script_filename: str = update("filename", str)
-        self.close_ksize: int = update("close_ksize", int, default=11)
+        self.open_ksize: int = update("open_ksize", int, default=0)
+        self.close_ksize: int = update("close_ksize", int, default=5)
         self.min_callback_time: float = update("min_callback_time", float, default=0.08)
         self.direction: int = update("direction", int)
         self.max_tip_distance: float = update("max_tip_distance", float, default=300)