pymodaq_plugins_beam_shaping 5.3.0__tar.gz → 5.3.2__tar.gz

{pymodaq_plugins_beam_shaping-5.3.0 → pymodaq_plugins_beam_shaping-5.3.2}/AGENTS.md

@@ -4,6 +4,10 @@ Guidance for AI coding assistants (and humans) building on **PyMoDAQ 5.3.x** fro
 PyMoDAQ is a Qt framework that drives lab experiments: hardware is added through small *plugins*, and PyMoDAQ
 provides the GUI, threading, data model, scans and HDF5 saving. Python 3.10 to 3.13.
 
+> **This repository has specific guidance in [AGENTS_BEAM_SHAPING.md](AGENTS_BEAM_SHAPING.md)** (where the field loaders,
+> algorithms, Field Tool, shapers, tests and docs are, branch conventions). Read it first; the rest of this file is the
+> generic PyMoDAQ plugin guidance from the template.
+
 This repository is a plugin package named `pymodaq_plugins_<name>`. Rename everything that still says `template`
 before publishing.
 
@@ -203,4 +207,8 @@ extensions already does the job and only the conversion of the measurements or o
 - [ ] Tests added for new behaviour using a mock controller (no real hardware in CI).
 - [ ] Docstring of each plugin class states: compatible devices, what was tested, PyMoDAQ and OS versions,
       drivers to install.
-- [ ] `README.rst` updated; target PyMoDAQ version stated.
+- [ ] `README.rst` updated; target PyMoDAQ version stated. Keep its section order: a short description, then `Authors`
+      (then `Contributors` if needed), then `Instruments` (`Actuators`, `Viewer0D`...). `pymodaq_plugin_manager` reads the
+      README from `Authors` to `Instruments` (`extract_authors_from_description` in its `validate.py`), so write nothing
+      else before these sections or between them: requirements, installation, hardware notes or differences with
+      another branch come after the `Instruments` list.

pymodaq_plugins_beam_shaping-5.3.2/AGENTS_BEAM_SHAPING.md

@@ -0,0 +1,108 @@
+# AGENTS_BEAM_SHAPING.md: `pymodaq_plugins_beam_shaping`
+
+A PyMoDAQ extension that computes masks for spatial light modulators (SLM, DMD...) from an input field and a target
+field, sends them to a **Shaper** actuator of the Dashboard and optionally optimizes them with a camera feedback.
+Source in `src/pymodaq_plugins_beam_shaping/`. The generic PyMoDAQ guidance is in [AGENTS.md](AGENTS.md) (copied from the plugin template, keep it
+close to the template so that it can be updated); this file is what is specific to this repository.
+
+## Branches and PRs
+
+- Target PyMoDAQ is **5.3.x** (`pymodaq>=5.3.2,<5.4`). `5.3.x` is the default and integration branch: branch from it
+  (`feature/<topic>`) and open PRs against it. Never push to it directly.
+- A feature in several steps is a stack of PRs: the second PR is based on the branch of the first and is retargeted to
+  `5.3.x` once the first is merged (the binary holograms are #82, then the superpixel one in #83).
+- Do not use the word "preset" (obsolete): say *experiment* and *state* (see section 4 of AGENTS.md).
+- The version comes from git tags (`hatch-vcs`); do not edit it. Entry points are generated at build time by
+  `hatch_build.py` from the `[features]` flags and the folders.
+
+## Map of the code
+
+| Where | What |
+|---|---|
+| `extensions/spatial_beam_shaping.py` | The Dashboard extension (`beam_shaping` script). Hosts the algorithm app, the field loaders, the Shaper actuator and the camera. |
+| `field/field.py` | `Field`: the data class (a `DataRaw` with amplitude and phase, FFT helpers, pixel sizes) passed everywhere. |
+| `field/utils.py`, `field/factory.py` | `FieldLoader` base class and `LoaderFactory`. |
+| `field/loaders/` | The **field loaders**: `from_functions_loader.py` (Gaussian, Laguerre-Gauss, Hermite-Gauss, vortex...), `image_loader.py`, `save_field_loader.py` (h5), `dashboard_loader.py` (from a detector). |
+| `field/field_loader_app.py` | The widget that lets the user choose and parametrize a loader (input field, target field). |
+| `field/field_tool_app.py` | The standalone **Field Tool** (`field_tool` script): loads a Field and applies a chain of operations. |
+| `field/operations/` | Field Tool operations: `base.py` (`FieldOperation`, `OperationFactory`), `linear_phase.py`, `unwrap.py`, `zernike.py`. The numerical helpers they use are in `compute.py` (centered grid, support mask, unwrap, linear phase fit, Zernike fit, wrap...). |
+| `algorithms/algo_base.py` | `AlgoBase`: base of every algorithm (see below). |
+| `algorithms/factory.py` | `AlgorithmFactory`, `register_algorithms()` and the entry point group `pymodaq_plugins_beam_shaping.algorithms` for third party algorithms. |
+| `algorithms/algorithms/` | The **algorithms**, one module per family (see below). |
+| `algorithms/ini_phases/`, `stoppings/`, `loss.py` | Initial phases, stopping criteria and loss functions used by iterative algorithms. |
+| `algorithms/compensation.py`, `compensations/` | Compensation of the input beam profile (factory like the initial phases, chosen in the AlgoApp settings); an algorithm sets `INPUT_COMPENSATION` to the `Compensations` (StrEnum, add a member for a new compensation) member of its default compensation (None: none) and calls `compensate_target`. |
+| `algorithms/algorithm_app.py` | `AlgoApp`: the widget running an algorithm, owning the masks, the shaper and the fields. |
+| `algorithms/utils.py` | Enums (`AlgoStatus`, `AlgoType`, `ApplyMaskTo`, `LensSetup`). |
+| `utilities/shaper.py` | `Shaper` and `ModulatorType` (phase, amplitude, both), defined in `pymodaq_plugins_utils`; `get_default_shaper()` reads the config. |
+| `utilities/` | Corrections, calibration (`calibrating.py`), `sizing.py` (needed field size), `regions.py`, h5 saving, and `headless_algorithms.py` (see "Testing"). |
+| `daq_move_plugins/`, `daq_viewer_plugins/`, `hardware/` | Mock shaper, mock camera and autofocus instruments used for tests and demos; real shapers live in other packages. |
+| `scanners/calibration.py` | Scan scheme for the SLM calibration. |
+| `models/` | Optimizer / data mixer models (autofocus). |
+| `scripts/` | `algorithm_playground.py` (see "Testing"), SLM calibration scripts. |
+| `resources/` | `config_template.toml` (defaults, incl. `default_shaper`), sample fields. |
+
+## Field loaders
+
+A loader derives from `FieldLoader`, sets `LOADER_NAME`, declares its settings in `params`, implements the loading of
+`self.field` and is registered with `@LoaderFactory.register_loader()`. `register_loaders()` imports every module of
+`field/loaders/`, so **adding a loader = adding a file there** (or a class in an existing module); no other
+registration is needed. Parameters of the needed size (pixel counts and sizes) come from the parent app
+(`pixel_width`, `n_pixel_width`...).
+
+## Algorithms
+
+- A class derived from `AlgoBase` in a module of `algorithms/algorithms/`, registered with
+  `@AlgorithmFactory.register_algorithm()`. Modules are discovered automatically: no import to add elsewhere.
+- Class attributes to set: `ALGO_NAME` (unique, shown in the app), `MODULATOR_TYPES` (default phase only; amplitude
+  modulators such as a DMD need `ModulatorType.AMPLITUDE`; an algorithm is only offered when it supports the shaper,
+  and a shaper modulating both accepts all), `STATUS` / `STATUS_NOTE` (`AlgoStatus`, written by hand and honest: say
+  what was verified and on what), `ITERATIVE`, `INI_PHASE`, `params`.
+- Families: iterative/projection (`projections.py`: Gerchberg-Saxton, Projections), `direct.py`, `diffractive.py`
+  (broken, see its status), `checker_board.py`, optimizers on PyTorch (`optim.py`, `minimizer.py`, `torch_base.py`,
+  optional `pytorch` extra), and the **amplitude modulation** family for DMDs.
+- Amplitude modulation / binary holograms: on 5.3.x today `dmd_lee.py` (`DMD Lee`) and `super_pixel.py`
+  (`SuperPixels`). **PR #82 replaces both by `binary_holograms.py`** (base class `BinaryHologram` with the carrier
+  grating `px`, `py` and the carrier removal; `Binary Threshold` phase only, `Parallel Lee` amplitude and phase), and
+  PR #83 adds `Superpixel` to it. If those PRs are merged, the module is `binary_holograms.py` and the two old files
+  are gone; check which state the branch you are on is in before editing.
+- User documentation of an algorithm: `docs/src/user_guide/algorithm_reference.rst` (reference, overview table),
+  `algorithms.rst`, `custom_algorithm.rst` (how to write one, including from another package through the entry
+  point group) and `theory.rst`.
+
+## Shapers
+
+The extension asks the **Shaper** actuator for its geometry and properties (read only settings groups
+`shaper_geometry` and `shaper_properties`, defined in `pymodaq_plugins_utils.hardware.shaper`). Without such an
+actuator the `default_shaper` section of the config is used. Do not hardcode a shaper size or modulator type.
+Mock instruments for tests: `daq_move_MockShaper`, `daq_2Dviewer_MockShaperCamera`.
+
+## Testing
+
+```bash
+pytest tests/                                   # whole suite (Qt is needed: tests use the qapp fixture)
+pytest tests/test_algorithms_by_modulator_type.py
+```
+
+- `tests/conftest.py` imports `cv2` first and removes the Qt plugin path variables it sets; keep that.
+- Tests by topic: algorithms (`test_algo_helpers.py`, `test_algorithm_status.py`, `test_algorithms_by_modulator_type.py`,
+  `algorithm_entry_points_test.py`, `test_dmd_lee.py` or `test_binary_holograms.py` after #82), fields (`field_test.py`,
+  `test_field_tool.py`), shapers and calibration (`test_shaper_interface.py`, `test_calibration.py`), apps
+  (`test_custom_apps.py`), package structure (`test_plugin_package_structure.py`).
+- On 5.3.x two tests of `test_shaper_interface.py` already fail; mention it instead of hiding it, and do not
+  disable tests.
+- **Script to try an algorithm without the GUI**: `scripts/algorithm_playground.py`, cells delimited by `# %%`, run
+  in an IDE or Jupyter. It uses `utilities/headless_algorithms.py` (`list_available`, `make_shaper`, `HeadlessApp`,
+  `load_field`, `create_algorithm`, `run_algorithm`, `plot_field`, `plot`...), the same helpers the tests use, and
+  calls the algorithm as `AlgoApp` does. Prefer it, and tests built on `headless_algorithms`, to launching the
+  Dashboard. It validates the code path only, not the hardware.
+
+## Documentation (Sphinx)
+
+- Sources in `docs/src/` (`index.rst`, `theory.rst`, `quick_start.rst`, `user_guide/*.rst`: interface, fields,
+  field_tool, algorithms, algorithm_reference, custom_algorithm, shapers, slmsuite, calibration, corrections,
+  data_management), bibliography in `docs/src/bibtex.bib`, figures in `docs/src/_images/`.
+- Figures are generated by scripts in `docs/scripts/` (e.g. the binary holograms snapshots after #82); update the
+  script and the image together.
+- Build: `pip install -r docs/requirements.txt && make -C docs html` (config in `docs/src/conf.py`, Read the Docs in
+  `readthedocs.yml`). A new algorithm, loader or operation needs its doc page entry in the same PR.
+- Write the docs in the voice of the existing pages; cite papers through `bibtex.bib`.

pymodaq_plugins_beam_shaping-5.3.2/CLAUDE.md

@@ -0,0 +1,3 @@
+# CLAUDE.md
+
+Read and follow [AGENTS.md](AGENTS.md) and [AGENTS_BEAM_SHAPING.md](AGENTS_BEAM_SHAPING.md): they hold all the guidance for AI coding assistants working in this repository.

{pymodaq_plugins_beam_shaping-5.3.0 → pymodaq_plugins_beam_shaping-5.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pymodaq_plugins_beam_shaping
-Version: 5.3.0
+Version: 5.3.2
 Summary: PyMoDAQ's extension plugin to run optical shaping from various shapers (focusing on amplitude and phase shaping) and the image propagation
 Project-URL: Homepage, https://pymodaq.cnrs.fr
 Project-URL: Documentation , https://pymodaq.cnrs.fr
@@ -47,6 +47,7 @@ Requires-Dist: opencv-python
 Requires-Dist: pyfftw
 Requires-Dist: pymodaq-data<5.4,>=5.3.0
 Requires-Dist: pymodaq-gui<5.4,>=5.3.0
+Requires-Dist: pymodaq-plugins-utils>=5.3.4
 Requires-Dist: pymodaq-utils<5.4,>=5.3.1
 Requires-Dist: pymodaq<5.4,>=5.3.2
 Requires-Dist: scikit-image

pymodaq_plugins_beam_shaping-5.3.2/docs/scripts/binary_holograms_snapshots.py

@@ -0,0 +1,93 @@
+"""Makes the figure of the binary holograms of the documentation (docs/src/_images/binary_holograms.png)
+
+The same target (the default *ImageFiles* loader: its image as amplitude and its associated phase) is computed with
+each algorithm of the family (Binary Threshold, Parallel Lee, Superpixel), with the helpers of the script
+``scripts/algorithm_playground.py``, and the part of the pattern sent to the modulator is shown. Run it with
+``python binary_holograms_snapshots.py`` (the figure is written next to the other images of the documentation).
+"""
+from pathlib import Path
+
+import matplotlib
+matplotlib.use('Agg')
+from matplotlib import pyplot as plt
+import numpy as np
+
+from pymodaq_plugins_beam_shaping.algorithms.utils import ApplyMaskTo, AlgoType
+from pymodaq_plugins_beam_shaping.utilities import headless_algorithms as pg, regions
+
+OUTPUT = Path(__file__).parent.parent / 'src' / '_images' / 'binary_holograms.png'
+ALGORITHMS = ('Binary Threshold', 'Parallel Lee', 'Superpixel')
+# the periods of the grating, in pixels: wide for the amplitude levels of Parallel Lee, the superpixels are 4 x 4
+PARAMS = {'Binary Threshold': {'px': 8, 'py': 64}, 'Parallel Lee': {'px': 8, 'py': 64}, 'Superpixel': {'px': 4}}
+MASK_HALF_SIZE = 150.  # um, half size of the elliptical mask of the intermediate plane around the selected order
+
+pg.ensure_qapp()
+app = pg.HeadlessApp(pg.make_shaper(modulator_type='amplitude'))
+input_field = pg.load_field('GaussianIntensity', None, app)
+target_field = pg.load_field('ImageFiles', None, app)  # the default image and its associated phase
+
+results = {}
+for name in ALGORITHMS:
+    algo = pg.create_algorithm(pg.reload_algorithm(name), app, PARAMS[name])
+    pg.set_fields(algo, input_field, target_field)
+    # the order to filter, as given by the algorithm, in um from the center of the intermediate plane
+    y, x = np.array(algo.order_frequency()) * regions.pixel_sizes_in_um(algo.intermediate_pixel_sizes)
+    center_y, center_x = np.array(algo.shape) * regions.pixel_sizes_in_um(algo.intermediate_pixel_sizes) / 2
+    # in the frame of the extension: the origin is the corner of the field
+    mask = ((center_y + y - MASK_HALF_SIZE, center_y + y + MASK_HALF_SIZE),
+            (center_x + x - MASK_HALF_SIZE, center_x + x + MASK_HALF_SIZE))
+    pg.set_mask(app, ApplyMaskTo.INTERMEDIATE, mask, 'elliptical')
+    pg.run_algorithm(algo)
+    output = algo.output_field
+    results[name] = (output.amplitude, output.phase, algo.modulator_field.amplitude, algo.ALGOTYPE)
+    reference = pg.get_target_field(algo).amplitude  # the same for both
+    reference_phase = pg.get_target_field(algo).phase
+    pixel_size = output.pixels_sizes[1].m_as('um')
+
+
+def correlation(a, b):
+    a, b = a - a.mean(), b - b.mean()
+    return float((a * b).sum() / np.sqrt((a * a).sum() * (b * b).sum()))
+
+
+# the region of the output plane holding the target, with some margin
+rows, columns = np.nonzero(reference > 0.05 * reference.max())
+margin = 30
+window = (slice(max(rows.min() - margin, 0), rows.max() + margin), slice(max(columns.min() - margin, 0),
+                                                                           columns.max() + margin))
+target_region = (slice(rows.min(), rows.max()), slice(columns.min(), columns.max()))
+ny, nx = reference.shape
+extent = np.array([window[1].start - nx / 2, window[1].stop - nx / 2,
+                   window[0].start - ny / 2, window[0].stop - ny / 2]) * pixel_size / 1000  # mm
+
+figure, axes = plt.subplots(len(ALGORITHMS), 3, figsize=(11, 3.3 * len(ALGORITHMS)), constrained_layout=True)
+for row, name in enumerate(ALGORITHMS):
+    amplitude, phase, pattern, algotype = results[name]
+    amplitude = amplitude / amplitude[window].max()
+    axes[row, 0].imshow(amplitude[window], extent=extent, origin='lower', cmap='viridis', vmin=0, vmax=1)
+    if algotype == AlgoType.PHASE:  # the amplitude of the target is not encoded
+        axes[row, 0].set_title(f'{name}\nAmplitude (phase only: the amplitude of the target is not encoded)',
+                               fontsize=9)
+    else:
+        axes[row, 0].set_title(f'{name}\nAmplitude (correlation with the target image: '
+                               f'{correlation(results[name][0][target_region], reference[target_region]):.2f})',
+                               fontsize=9)
+    shown_phase = np.where(amplitude > 0.1, phase, np.nan)  # the phase only where there is light
+    image = axes[row, 1].imshow(shown_phase[window], extent=extent, origin='lower', cmap='twilight', vmin=-np.pi,
+                                vmax=np.pi)
+    axes[row, 1].set_title('Phase (where the amplitude is above 10 %)', fontsize=9)
+    centre = np.array(pattern.shape) // 2
+    zoom = (slice(centre[0], centre[0] + 40), slice(centre[1], centre[1] + 40))
+    axes[row, 2].imshow(pattern[zoom], cmap='gray', vmin=0, vmax=1, interpolation='nearest', origin='lower')
+    axes[row, 2].set_title('Pattern on the modulator (40 x 40 pixels)', fontsize=9)
+    for ax in axes[row, :2]:
+        ax.set_xlabel('mm')
+        ax.set_ylabel('mm')
+    axes[row, 2].axis('off')
+figure.colorbar(image, ax=axes[:, 1], label='rad', shrink=0.6, pad=0.02)
+figure.savefig(OUTPUT, dpi=110)
+print(f'written: {OUTPUT}')
+for name in ALGORITHMS:
+    if results[name][3] != AlgoType.PHASE:
+        print(f'{name}: correlation of the amplitude with the target image = '
+              f'{correlation(results[name][0][target_region], reference[target_region]):.3f}')

pymodaq_plugins_beam_shaping-5.3.2/docs/src/_static/css/layout.css

@@ -0,0 +1,61 @@
+/* Let the page content use the whole browser width instead of the
+   theme's fixed 800px column. */
+.wy-nav-content {
+    max-width: none;
+}
+
+/* Table cells wrap their text instead of pushing the table out of the page. */
+.rst-content table.docutils td,
+.rst-content table.docutils th,
+.wy-table-responsive table td,
+.wy-table-responsive table th {
+    white-space: normal;
+}
+
+/* Button showing/hiding the navigation sidebar (see sidebar_toggle.js). */
+.pmq-sidebar-toggle {
+    position: fixed;
+    top: 8px;
+    left: 308px;
+    z-index: 300;
+    width: 32px;
+    height: 32px;
+    padding: 0;
+    border: 1px solid #c9c9c9;
+    border-radius: 4px;
+    background: #fcfcfc;
+    color: #404040;
+    font-size: 18px;
+    line-height: 30px;
+    text-align: center;
+    cursor: pointer;
+    opacity: 0.8;
+}
+.pmq-sidebar-toggle:hover {
+    opacity: 1;
+    background: #e7f2fa;
+}
+
+body.pmq-sidebar-hidden .wy-nav-side {
+    display: none;
+}
+body.pmq-sidebar-hidden .wy-nav-content-wrap {
+    margin-left: 0;
+}
+body.pmq-sidebar-hidden .pmq-sidebar-toggle {
+    left: 8px;
+}
+
+/* On small screens the theme already has its own menu button. */
+@media screen and (max-width: 768px) {
+    .pmq-sidebar-toggle {
+        display: none;
+    }
+}
+
+/* Keep the breadcrumbs clear of the toggle button. */
+@media screen and (min-width: 769px) {
+    .wy-breadcrumbs {
+        padding-left: 36px;
+    }
+}

pymodaq_plugins_beam_shaping-5.3.2/docs/src/_static/css/overflow.css

@@ -0,0 +1,11 @@
+.rst-content img {
+  max-width: none !important;
+  height: auto;
+}
+.wy-table-responsive {
+    overflow: visible;
+}
+
+.dataTables_wrapper {
+    overflow: auto;
+}

pymodaq_plugins_beam_shaping-5.3.2/docs/src/_static/js/sidebar_toggle.js

@@ -0,0 +1,44 @@
+// Adds a button to show/hide the navigation sidebar of the Read the Docs theme.
+// The choice is remembered between pages.
+(function () {
+    var KEY = "beamshaping-docs-sidebar-hidden";
+
+    function stored() {
+        try {
+            return window.localStorage.getItem(KEY) === "1";
+        } catch (e) {
+            return false;
+        }
+    }
+
+    function store(hidden) {
+        try {
+            window.localStorage.setItem(KEY, hidden ? "1" : "0");
+        } catch (e) {
+            // storage unavailable: the choice only lasts for this page
+        }
+    }
+
+    document.addEventListener("DOMContentLoaded", function () {
+        var button = document.createElement("button");
+        button.type = "button";
+        button.className = "pmq-sidebar-toggle";
+
+        function apply(hidden) {
+            document.body.classList.toggle("pmq-sidebar-hidden", hidden);
+            button.innerHTML = hidden ? "☰" : "«";
+            button.title = hidden ? "Show the navigation sidebar" : "Hide the navigation sidebar";
+            button.setAttribute("aria-label", button.title);
+            button.setAttribute("aria-expanded", hidden ? "false" : "true");
+        }
+
+        button.addEventListener("click", function () {
+            var hidden = !document.body.classList.contains("pmq-sidebar-hidden");
+            apply(hidden);
+            store(hidden);
+        });
+
+        apply(stored());
+        document.body.appendChild(button);
+    });
+})();

{pymodaq_plugins_beam_shaping-5.3.0 → pymodaq_plugins_beam_shaping-5.3.2}/docs/src/acknowledgments.rst

@@ -41,7 +41,7 @@ Main Sources
      - `GitHub: pymodaq_plugins_beam_shaping <https://github.com/PyMoDAQ/pymodaq_plugins_beam_shaping>`_
    * - **Scientific Article**
      - Full manuscript (PDF/LaTeX) provided by the authors (Rollo, Arbouet, Weber)
-     - `To be cited <>`_
+     - To be cited
    * - **PyMoDAQ Documentation**
      - Official guide for extensions and documentation style
      - `pymodaq.cnrs.fr <https://pymodaq.cnrs.fr/en/latest/>`_
@@ -54,10 +54,10 @@ Main Sources
 
 
 Tools Used
----------
+----------
 - **Sphinx** (with ``sphinx-rtd-theme``) for documentation generation.
 - **reStructuredText** (``.rst``) for writing.
-- **LaTeX** for mathematical equations (integrated via ``sphinx.ext.imgmath``).
+- **LaTeX** syntax for mathematical equations (rendered in the browser by MathJax via ``sphinx.ext.mathjax``).
 - **HDF5** for describing the structure of ``.h5beam`` files.
 
 

{pymodaq_plugins_beam_shaping-5.3.0 → pymodaq_plugins_beam_shaping-5.3.2}/docs/src/bibtex.bib

@@ -208,6 +208,7 @@
   year     = {1972},
   pages    = {237},
   volume   = {35},
+  url      = {https://web.archive.org/web/20160328053000/http://www.u.arizona.edu/~ppoon/GerchbergandSaxton1972.pdf},
   abstract = {An algorithm is presented for the rapid solution of the phase of the complete wave function whose intensity in the diffraction and imaging planes of an imaging system are known. A proof is given showing that a defined error between the estimated function and the correct function must decrease as the algorithm iterates. The problem of uniqueness is discussed and results are presented demonstrating the power of the method.},
   groups   = {pulse shaping},
 }
@@ -639,4 +640,49 @@ year = {2013},
 url = {https://opg.optica.org/ao/abstract.cfm?URI=ao-52-1-1},
 doi = {10.1364/AO.52.000001},
 abstract = {The addition of electronics, computers, and software to interferometry has enabled enormous improvements in optical metrology. This paper discusses four areas in which computerized interferometric measurement improvements have been made in the measurement of surface shape and surface roughness: (a)\&\#xA0;The use of computer-generated holograms for the testing of aspheric optics, (b)\&\#xA0;phase-shifting interferometry for getting interferometric data into a computer so the data can be analyzed, (c)\&\#xA0;computerized interference microscopes, including multiple-wavelength and coherence scanning, for the precision measurement of surface microstructure, and (d)\&\#xA0;vibration-insensitive dynamic interferometers for enabling precise measurements in noncontrolled environments.},
-}
+}
+
+@article{gutierrez-cuevas_binary_2024,
+	title = {Binary holograms for shaping light with digital micromirror devices},
+	journal = {Journal of Physics: Photonics},
+	author = {Guti\'errez-Cuevas, R. and Popoff, S. M.},
+	volume = {6},
+	number = {4},
+	pages = {045022},
+	year = {2024},
+	url = {https://arxiv.org/abs/2311.16685},
+	note = {arXiv:2311.16685},
+}
+
+@article{lee_binary_1974,
+	title = {Binary {Synthetic} {Holograms}},
+	journal = {Applied Optics},
+	author = {Lee, Wai-Hon},
+	volume = {13},
+	number = {7},
+	pages = {1677--1682},
+	year = {1974},
+	doi = {10.1364/AO.13.001677},
+}
+
+@article{brown_complex_1966,
+	title = {Complex {Spatial} {Filtering} with {Binary} {Masks}},
+	journal = {Applied Optics},
+	author = {Brown, B. R. and Lohmann, A. W.},
+	volume = {5},
+	number = {6},
+	pages = {967--974},
+	year = {1966},
+	doi = {10.1364/AO.5.000967},
+}
+
+@article{bryngdahl_interferograms_1968,
+	title = {Interferograms are {Image} {Holograms}},
+	journal = {Journal of the Optical Society of America},
+	author = {Bryngdahl, O. and Lohmann, A. W.},
+	volume = {58},
+	number = {1},
+	pages = {141--142},
+	year = {1968},
+	doi = {10.1364/JOSA.58.000141},
+}

{pymodaq_plugins_beam_shaping-5.3.0 → pymodaq_plugins_beam_shaping-5.3.2}/docs/src/conf.py

@@ -33,7 +33,7 @@ extensions = [
     "sphinx_autodoc_typehints",
     'sphinx.ext.doctest',
     'sphinx.ext.coverage',
-    'sphinx.ext.imgmath',
+    'sphinx.ext.mathjax',  # equations rendered in the browser, no LaTeX needed on the build machine (Read the Docs)
     'sphinx.ext.githubpages',
     'sphinx.ext.autosummary',
     'releases',
@@ -53,19 +53,9 @@ numfig_format = {
     'section': 'Section %s',
 }
 
-html_css_files = [
-    'https://fonts.googleapis.com/icon?family=Material+Icons',
-    'css/custom.css',  # Pour styliser les icônes
-]
-
 bibtex_bibfiles = ['bibtex.bib']  # Chemin relatif à docs/
 bibtex_reference_style = 'author_year'  # Style de citation (ex: "Weber 2021")
 
-# Configuration pour imgmath (équations LaTeX)
-imgmath_image_format = 'png'  # ou 'svg'
-imgmath_font_size = 14
-imgmath_dpi = 150
-
 # -- Options for autodocumentation ---------------------------------------------
 autodoc_member_order = "groupwise"
 autoclass_content = "class"
@@ -120,7 +110,12 @@ html_theme_options = {
 }
 
 html_css_files = [
+    'https://fonts.googleapis.com/icon?family=Material+Icons',
     'css/overflow.css',
+    'css/layout.css',  # full-width content, tables kept within it
+]
+html_js_files = [
+    'js/sidebar_toggle.js',  # button to hide the navigation sidebar
 ]
 
 html_static_path = ["_static", "_images"]  # NOUVEAU: Ajout de "_images"
@@ -134,6 +129,10 @@ datatables_options = {
     'paging': True,
 }
 
+# -- Options for rediraffe -----------------------------------------------------
+# Redirections of the pages that are renamed or removed, one "old_page new_page" per line (without the extension)
+rediraffe_redirects = 'redirects.txt'
+
 # -- Options for intersphinx ---------------------------------------------------
 intersphinx_mapping = {
     'python': ('https://docs.python.org/3', None),

{pymodaq_plugins_beam_shaping-5.3.0 → pymodaq_plugins_beam_shaping-5.3.2}/docs/src/introduction.rst

@@ -37,6 +37,7 @@ Applications
      - Wavefront correction (aberration compensation).
 
 .. _FIG-schema:
+
 .. figure:: /_images/layout.png
    :alt: General Beam-Shaping Problem
    :width: 90%

{pymodaq_plugins_beam_shaping-5.3.0 → pymodaq_plugins_beam_shaping-5.3.2}/docs/src/quick_start.rst

@@ -7,7 +7,7 @@ Quick Start
    :alt: Save
    :align: middle
 
-.. |file_open| image:: /_static/icons/folder_open.png
+.. |file_open| image:: /_static/icons/file_open.png
    :height: 20pt
    :alt: Load
    :align: middle
@@ -22,7 +22,7 @@ Quick Start
    :alt: Input
    :align: middle
 
-.. |deblur| image:: /_static/icons/tune.png
+.. |deblur| image:: /_static/icons/deblur.png
    :height: 20pt
    :alt: Corrections
    :align: middle
@@ -128,6 +128,7 @@ Follow these steps to perform your first beam shaping:
 For more details on the interface, see :numref:`FIG-quick-start`.
 
 .. _FIG-quick-start:
+
 .. figure:: /_images/main_app.png
    :alt: BeamShaping User Interface
    :width: 100%

pymodaq_plugins_beam_shaping-5.3.2/docs/src/redirects.txt

@@ -0,0 +1 @@
+# "old_page new_page" for each page that is renamed or removed (paths relative to docs/src, without extension)

pymodaq_plugins_beam_shaping-5.3.2/docs/src/references.rst

@@ -0,0 +1,22 @@
+References
+==========
+
+PyMoDAQ Documentation
+---------------------
+- To cite PyMoDAQ: :cite:p:`Weber2021`
+- `PyMoDAQ Official Documentation <https://pymodaq.cnrs.fr/en/latest/>`_
+- `Extension Plugins Guide <https://pymodaq.cnrs.fr/en/latest/developer_folder/extension_plugins.html>`_
+- `Plugin Template Repository <https://github.com/PyMoDAQ/pymodaq_plugins_template>`_
+
+Beam Shaping Literature
+-----------------------
+The articles cited in this documentation:
+
+.. bibliography::
+   :cited:
+   :style: plain
+
+Plugin Repository
+-----------------
+- `PyMoDAQ-BeamShaping GitHub <https://github.com/PyMoDAQ/pymodaq_plugins_beam_shaping>`_
+