opticalib 2.2.0__tar.gz → 2.3.1__tar.gz

{opticalib-2.2.0/opticalib.egg-info → opticalib-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opticalib
-Version: 2.2.0
+Version: 2.3.1
 Summary: This package is a python interface for laboratory adaptive optics systems, with a focus on the calibration of deformable mirrors (DMs) and the acquisition of wavefront data using wavefront sensors.
 Author-email: Adaptive Optics Group - INAF - Osservatorio Astrofisico di Arcetri <pietro.ferraiuolo@inaf.it>
 Maintainer-email: Pietro Ferraiuolo <pietro.ferraiuolo@inaf.it>
@@ -9,10 +9,14 @@ Project-URL: Homepage, https://github.com/ArcetriAdaptiveOptics/opticalib
 Project-URL: Repository, https://github.com/ArcetriAdaptiveOptics/opticalib
 Project-URL: Issues, https://github.com/ArcetriAdaptiveOptics/opticalib/issues
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: arte

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/__version__.py

@@ -9,7 +9,7 @@ Pietro Ferraiuolo
 __title__ = "opticalib"
 __long_title__ = "OPTICALIB : python framework for OPTIcal CALIBration of deformable mirrors and adaptive optics experimentation"
 __description__ = "This package is a python interface for laboratory adaptive optics systems, with a focus on the calibration of deformable mirrors (DMs) and the acquisition of wavefront data using wavefront sensors."
-__version__ = "2.2.0"
+__version__ = "2.3.1"
 __author__ = "Adaptive Optics Group - INAF - Osservatorio Astrofisico di Arcetri"
 __maintainer__ = "Pietro Ferraiuolo"
 __author_email__ = "pietro.ferraiuolo@inaf.it"

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/analyzer/image_processing.py

@@ -45,11 +45,27 @@ def pad_image_to_shape(
     padded_img : _ot.ImageData
         The padded image.
     """
-    padded_img = _np.full(shape, fill_value)
-    y, x = offset
-    h, w = _np.shape(img)
-    padded_img[y : y + h, x : x + w] = img.data
-    return padded_img
+    y, x, Y, X, h, w = [*offset, *shape, *img.shape]
+    if any(p < 0 for p in [y, x, Y - h - y, X - w - x]):
+        raise ValueError("Invalid padding dimensions")
+    pad_width = ((y, Y - h - y), (x, X - w - x))
+    pimg = _np.pad(
+        img.data,
+        pad_width=pad_width,
+        mode='constant',
+        constant_values=fill_value
+    )
+    mask = _np.pad(
+        _np.ma.getmaskarray(img),
+        pad_width=pad_width,
+        mode='constant',
+        constant_values=True
+    )
+    if hasattr(img, 'header'):
+        header = img.header
+    else:
+        header = None
+    return _fa.fits_array(pimg, mask=mask, header=header)
 
 
 def frame(idx: int, mylist: list[_ot.ImageData] | _ot.CubeData) -> _ot.ImageData:
@@ -301,13 +317,18 @@ def create_cube(fl_or_il: list[str], register: bool = False) -> _ot.CubeData:
     cube : ndarray
         Data cube containing the images/frames stacked, with shape (npx, npy, nframes).
     """
+    memmap = True
     # check it is a list
     if not isinstance(fl_or_il, list):
         raise TypeError("filelist must be a list of strings or images")
 
     # check if it is composed of file paths to load
     if all([isinstance(item, str) for item in fl_or_il]):
-        fl_or_il = [osu.read_phasemap(f) for f in fl_or_il]
+        N = len(fl_or_il)  # Number of files
+        if N > 1000:
+            memmap = False
+            print("Disabling memory mapping for large file list: N =", N)
+        fl_or_il = [osu.read_phasemap(f, memmap=memmap) for f in fl_or_il]
 
         # Is the list now full of images?
         if not any(

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/core/config.py

@@ -15,6 +15,7 @@ Most accessors also accept an explicit ``bpath`` to point at a specific
 
 import os as _os
 import re as _re
+from collections.abc import Mapping as _Mapping
 from ast import literal_eval as _literal_eval
 
 import numpy as _np
@@ -276,6 +277,52 @@ def get_section_config(section: str, sub_section: str | None = None) -> dict[str
     return _get_section_config(section=section, sub_section=sub_section, path=_cfile)
 
 
+class LazySection(_Mapping):
+    """
+    A section of ``configuration.yaml``, read when it is used.
+
+    Modules that need a section at import time use it instead of reading the
+    file immediately, so that an experiment that does not define the
+    section (or sets it to ``null``) can still import opticalib.  A missing
+    section reads as empty; ``section[key]`` then raises a ``KeyError``
+    naming the section.  The file is read on every access, so the values
+    follow :func:`opticalib.set_configuration_file`.
+
+    Parameters
+    ----------
+    section : str
+        Top-level section name.
+    """
+
+    def __init__(self, section: str) -> None:
+        """Remember the section; nothing is read yet."""
+        self._section = section
+
+    def _load(self) -> dict[str, _Any]:
+        try:
+            data = get_section_config(self._section)
+        except KeyError:
+            data = None
+        return dict(data) if isinstance(data, dict) else {}
+
+    def __getitem__(self, key: str) -> _Any:
+        data = self._load()
+        if key not in data:
+            raise KeyError(
+                f"`{key}` not found in the `{self._section}` section of the configuration file"
+            )
+        return data[key]
+
+    def __iter__(self):
+        return iter(self._load())
+
+    def __len__(self) -> int:
+        return len(self._load())
+
+    def __repr__(self) -> str:
+        return f"LazySection({self._section!r})"
+
+
 def get_device_config(device_type: str, device_name: str | None = None):
     """
     Retrieves the device configuration from the YAML configuration file.
@@ -696,6 +743,10 @@ def get_alignment_config():
         The alignment configuration as a class, for backwards compatibility.
     """
     config = get_section_config("SYSTEM.ALIGNMENT")
+    if not isinstance(config, dict):
+        raise KeyError(
+            "The `SYSTEM.ALIGNMENT` section of the configuration file is empty."
+        )
     config["slices"] = [slice(item["start"], item["stop"]) for item in config["slices"]]
 
     class AlignmentConfig:

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/devices/_API/alpaoAPI.py

@@ -355,12 +355,12 @@ class BaseAlpaoMirror:
         The serial number is resolved in the following priority order:
 
         1. The *serial_number* argument, if not ``None``.
-        2. The ``serialNumber`` key in the device configuration file
+        2. The ``serial_number`` key in the device configuration file
            (looked up by *nacts*).
 
         When *nacts* is provided the device configuration block
         ``Alpao{nacts}`` is read from the configuration file, allowing
-        ``serialNumber``, ``sdk_folder_path``, and ``acfg_path`` to be
+        ``serial_number``, ``sdk_folder_path``, and ``acfg_path`` to be
         set there instead of being passed as arguments.  When only
         *serial_number* is given the configuration lookup is skipped and
         the caller is responsible for having ``ACECFG`` set in the

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/devices/_API/base_devices.py

@@ -43,7 +43,7 @@ class BaseDeformableMirror(ABC):
     @property
     def border_ids(self):
         return self._borderIds
-    
+
     @property
     def cmd_history(self) -> _ot.Optional[_ot.MatrixLike]:
         """
@@ -117,7 +117,9 @@ class BaseDeformableMirror(ABC):
             return None
         return "minimum-rms" if (s and b) else "zero-force"
 
-    def _apply_slaving(self, cmd: _ot.ArrayLike|_ot.MatrixLike, slave: bool | str) -> _ot.ArrayLike|_ot.MatrixLike:
+    def _apply_slaving(
+        self, cmd: _ot.ArrayLike | _ot.MatrixLike, slave: bool | str
+    ) -> _ot.ArrayLike | _ot.MatrixLike:
         """
         Apply actuator slaving to a command when requested.
         """

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/devices/_API/piAPI.py

@@ -7,8 +7,8 @@ from opticalib.core.exceptions import CommandError
 
 _CMDLIMITS = {  # temporary limits to overcome the hardware connection refusal
     0: [0, 12],
-    1: [-200, 200],
-    2: [-200, 200],
+    1: [-230, 230],
+    2: [-230, 230],
 }
 
 
@@ -199,7 +199,7 @@ class BasePetalMirror:
             self._had_error = True
             raise RuntimeError("Failed to send mirror command") from err
 
-    def _check_cmd_integrity(self, cmd: _ot.ArrayLike) -> None:
+    def _check_cmd_integrity(self, cmd: _ot.ArrayLike) -> bool:
         """
         Check the integrity of the command array.
 
@@ -217,6 +217,7 @@ class BasePetalMirror:
             for ax, c in enumerate(cmd[k * 3 : k * 3 + 3]):
                 if not (_CMDLIMITS[ax][0] <= c <= _CMDLIMITS[ax][1]):
                     raise CommandError(f"Command for actuator {ax} out of bounds: {c}")
+        return True
 
     def _morning_routine(self) -> None:
         """
@@ -227,6 +228,14 @@ class BasePetalMirror:
         import time
 
         pos = self._read_act_position()
+        if not self._check_cmd_integrity(pos):
+            self._logger.warning(
+                "Initial actuator positions are not within command limits. "
+                "Setting to mid-range.")
+            midpoint = lambda v: (v[0] + v[1]) / 2
+            pos = np.asarray(
+                [midpoint(_CMDLIMITS[ax]) for ax in range(3)] * self.n_segments
+            )
         try:
             if not self._had_morning_routine:
                 self._logger.info(f"Warming up the segments piezos.")

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/devices/deformable_mirrors.py

@@ -30,6 +30,7 @@ from opticalib.ground.logger import SystemLogger as _SL
 
 from ._API.piAPI import BasePetalMirror
 
+
 class PetalMirror(BasePetalMirror, BaseDeformableMirror):
     """
     Petal Deformable Mirror interface.
@@ -186,6 +187,7 @@ class PetalMirror(BasePetalMirror, BaseDeformableMirror):
 
 from ._API.micAPI import BaseAdOpticaDm
 
+
 class AdOpticaDm(BaseAdOpticaDm, BaseDeformableMirror):
     """
     AdOptica Deformable Mirror interface.
@@ -443,6 +445,7 @@ class AdOpticaDm(BaseAdOpticaDm, BaseDeformableMirror):
     def __repr__(self):
         return f"{self._name}(n_segments={self.n_segments}, n_acts_per_segment={self.n_acts_per_segment})"
 
+
 class DP(AdOpticaDm):
     """
     Deformable Mirror interface for the Deformable Platform (DP) of the ELT.
@@ -586,6 +589,7 @@ class DP(AdOpticaDm):
             # Store in both the yielded dict and class attribute
             self.bufferData = result.copy()
 
+
 class M4AU(AdOpticaDm):
     """
     Deformable Mirror interface for the M4 Auxiliary Unit (M4AU) of the ELT.
@@ -611,6 +615,7 @@ class M4AU(AdOpticaDm):
 
 from ._API.alpaoAPI import BaseAlpaoMirror
 
+
 class AlpaoDm(BaseAlpaoMirror, BaseDeformableMirror):
     """
     Alpao Deformable Mirror interface.
@@ -757,7 +762,7 @@ class AlpaoDm(BaseAlpaoMirror, BaseDeformableMirror):
         if not _ot.isinstance_(tcmdhist, "MatrixLike"):
             raise _oe.MatrixError(
                 f"Expecting a 2D Matrix of shape (nacts, nmodes), got instead: {tcmdhist.shape}"
-            )    
+            )
         tcmdhist = self._apply_slaving(cmd=tcmdhist, slave=slaving)
         self._cmd_history = tcmdhist
 
@@ -889,6 +894,7 @@ class AlpaoDm(BaseAlpaoMirror, BaseDeformableMirror):
 
 from ._API.splattAPI import SPLATTEngine
 
+
 class SplattDm(BaseDeformableMirror):
     """
     SPLATT deformable mirror interface.

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/dmutils/_misc.py

@@ -4,9 +4,10 @@ from ..core import _types as _ot
 
 
 def make_modal_base(
-    rm: _ot.MatrixLike,
     modes: int | list[int],
     mask: _ot.MaskData,
+    im: _ot.MatrixLike|None = None,
+    rm: _ot.MatrixLike|None = None,
     basis: str = "zernike",
 ) -> _ot.MatrixLike:
     """
@@ -14,8 +15,10 @@ def make_modal_base(
 
     Parameters
     ----------
-    RM : MatrixLike
-        The reconstruction matrix.
+    im : MatrixLike
+        The Interaction Matrix (nacts, npix).
+    rm : MatrixLike
+        The reconstruction matrix (npix, nacts).
     modes : int or list of int
         The number of modes to compute, or the list of mode indices to compute.
     mask : MaskData
@@ -30,7 +33,7 @@ def make_modal_base(
 
     Returns
     -------
-    array_like
+    m2c : MatrixLike
         The modal base.
 
     """
@@ -64,8 +67,13 @@ def make_modal_base(
         masked_data = surf[~mask]
         mat[i, :] = masked_data
 
-    MB = (mat @ rm).T
-    return MB
+    if rm is not None:
+        m2c = (mat @ rm).T
+    elif im is not None:
+        m2c = (mat @ im.T).T
+    else:
+        raise ValueError("Either `rm` or `im` must be provided.")
+    return m2c
 
 
 __all__ = ["make_modal_base"]

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/ground/osutils.py

@@ -457,7 +457,7 @@ def load_cube_from_filelist(
     return cube
 
 
-def read_phasemap(file_path: str) -> _ot.ImageData:
+def read_phasemap(file_path: str, **kwargs: dict[str, _ot.Any]) -> _ot.ImageData:
     """
     Function to read interferometric data, in the three possible formats
     (FITS, 4D, H5)
@@ -474,13 +474,15 @@ def read_phasemap(file_path: str) -> _ot.ImageData:
     """
     ext = file_path.split(".")[-1]
     if ext in ["fits", "4Ds"]:
-        image = load_fits(file_path)
+        image = load_fits(file_path, **kwargs)
     elif ext in ["4D", "h5"]:
         image = _InterferometerConverter.from_phase_cam6110(file_path)
     return image
 
 
-def load_fits(filepath: str, on_gpu: bool = False) -> _ot.FitsData | list[_ot.FitsData]:
+def load_fits(
+    filepath: str, on_gpu: bool = False, **kwargs: dict[str, _ot.Any]
+) -> _ot.FitsData | list[_ot.FitsData]:
     """
     Loads a FITS file.
 
@@ -505,7 +507,12 @@ def load_fits(filepath: str, on_gpu: bool = False) -> _ot.FitsData | list[_ot.Fi
         filepath += ".fits"
 
     multi_hdu = False
-    with _fits.open(filepath) as hdul:
+    # memmap=False: with memory mapping (astropy's default) the returned arrays
+    # are views on the mmap, which keeps a file descriptor open for as long as
+    # the data is alive, even after the `with` block exits. Loading many files
+    # (e.g. in `load_cube_from_filelist`) would then hit "Too many open files".
+    memmap = kwargs.pop("memmap", True)
+    with _fits.open(filepath, memmap=memmap, **kwargs) as hdul:
         H = len(hdul)
 
         # Simple HDU case

{opticalib-2.2.0 → opticalib-2.3.1}/opticalib/gui/__init__.py

@@ -20,6 +20,11 @@ From Python::
 Via the CLI::
 
     calpy -f /path/to/experiment --gui
+
+Packages building on opticalib subclass :class:`CalpyGUI` to add their own
+procedures (:class:`~opticalib.gui.plugins.Procedure`, windows built on
+:class:`~opticalib.gui.procedures.base.ProcedureWindow`) and startup
+scripts, then call ``launch_gui(config_path, window_class=MyGUI)``.
 """
 
 import os as _os
@@ -38,7 +43,7 @@ if _os.environ["QT_API"].lower() in _PYQTGRAPH_LIBS:
         "PYQTGRAPH_QT_LIB", _PYQTGRAPH_LIBS[_os.environ["QT_API"].lower()]
     )
 
-__all__ = ["CalpyGUI", "launch_gui"]
+__all__ = ["CalpyGUI", "launch_gui", "Procedure", "PROCEDURES"]
 
 
 def __getattr__(name: str):
@@ -49,6 +54,10 @@ def __getattr__(name: str):
     inside the IPython kernel, which must not pay for (or require) a Qt
     import; the main window is therefore only loaded on first access.
     """
+    if name in ("Procedure", "PROCEDURES"):
+        from . import plugins
+
+        return getattr(plugins, name)
     if name in __all__:
         from . import app