Merge branch 'main' into 2644_automatic_dynamic_mask

Author: kif

src/pyFAI/benchmark/__init__.py

@@ -24,7 +24,7 @@
 "Benchmark for Azimuthal integration of PyFAI"
 
 __author__ = "Jérôme Kieffer"
-__date__ = "21/05/2024"
+__date__ = "11/03/2025"
 __license__ = "MIT"
 __copyright__ = "2012-2024 European Synchrotron Radiation Facility, Grenoble, France"
 
@@ -256,6 +256,7 @@ def __init__(self, nbr=10, repeat=1, memprofile=False, unit="2th_deg", max_size=
         self.unit = unit
         self.out_2d = (500, 360)
         self.max_size = max_size or sys.maxunicode
+        self.plot_y_range = [1, 1000]
 
     def get_cpu(self):
         if self._cpu is None:
@@ -363,7 +364,7 @@ def bench_1d(self, method="splitBBox", check=False, opencl=None, function="integ
                 device = ' '.join(str(ocl.platforms[platformid].devices[deviceid]).split())
             print("Working on device: %s platform: %s device: %s" % (devicetype, platform, device))
             # label = ("%s %s %s %s %s" % (function, devicetype, self.LABELS[method.method[1:4]], platform, device)).replace(" ", "_")
-            label = f'{devicetype}:{platform}:{device} / {function}: {method.split_lower}_{method.algo_lower}_{method.impl_lower}'
+            label = f'{devicetype}:{platform}:{device} / {function}: ({method.split_lower},{method.algo_lower},{method.impl_lower})'
             method = IntegrationMethod.select_method(dim=1, split=method.split_lower,
                                                       algo=method.algo_lower, impl=method.impl_lower,
                                                       target=(opencl["platformid"], opencl["deviceid"]))[0]
@@ -639,24 +640,25 @@ def init_curve(self):
                 self.ax.set_yscale("log", base=2)
             except Exception:
                 self.ax.set_yscale("log", basey=2)
-            t = [0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000]
+            t = [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000]
             self.ax.set_yticks([float(i) for i in t])
             self.ax.set_yticklabels([str(i)for i in t])
             self.ax.set_xlim(0.0, 20)
-            self.ax.set_ylim(0.5, 1500)
+            self.ax.set_ylim(0.75 * self.plot_y_range[0],
+                             1.5 * self.plot_y_range[1])
             self.ax.set_title(f'CPU: {self.get_cpu()}\nGPU: {self.get_gpu()}')
 
             # Display detector markers (vertical lines)
             self.ax.vlines(
                 x=data_sizes,
-                ymin=self.ax.get_ylim()[0],
-                ymax=self.ax.get_ylim()[1],
+                ymin=0,
+                ymax=100*self.plot_y_range[1],
                 linestyles='dashed',
                 alpha=0.4,
                 colors='black',
             )
             for size, detector_label in zip(data_sizes, detector_names):
-                self.ax.text(x=size, y=0.6, s=detector_label, rotation=270, fontsize=7)
+                self.ax.text(x=size, y=0.8, s=detector_label, rotation=270, fontsize=7)
 
             update_fig(self.fig)
 
@@ -674,7 +676,11 @@ def new_curve(self, results, label, style="-", marker="x"):
         self.plot_x = list(results.keys())
         self.plot_x.sort()
         self.plot_y = [1000.0 / results[i] for i in self.plot_x]
+        self.plot_y_range = [min(min(self.plot_y_range), min(self.plot_y)),
+                             max(max(self.plot_y_range), max(self.plot_y))]
         self.plot = self.ax.plot(self.plot_x, self.plot_y, marker + style, label=label)[0]
+        self.ax.set_ylim(0.75 * self.plot_y_range[0],
+                         1.5 * self.plot_y_range[1])
 
         handles, labels = self.ax.get_legend_handles_labels()
         self.ax.legend(
@@ -697,9 +703,14 @@ def new_point(self, size, exec_time):
         if not self.plot:
             return
 
+        y_value = 1000.0 / exec_time
         self.plot_x.append(size)
-        self.plot_y.append(1000.0 / exec_time)
+        self.plot_y.append(y_value)
         self.plot.set_data(self.plot_x, self.plot_y)
+        self.plot_y_range = [min(self.plot_y_range[0], y_value),
+                             max(self.plot_y_range[1], y_value)]
+        self.ax.set_ylim(0.75 * self.plot_y_range[0],
+                         1.5 * self.plot_y_range[1])
         update_fig(self.fig)
 
     def display_all(self):

src/pyFAI/detectors/_xspectrum.py

@@ -4,7 +4,7 @@
 #    Project: Fast Azimuthal integration
 #             https://github.com/silx-kit/pyFAI
 #
-#    Copyright (C) 2022-2024 European Synchrotron Radiation Facility, Grenoble, France
+#    Copyright (C) 2022-2025 European Synchrotron Radiation Facility, Grenoble, France
 #
 #    Principal author:       Jérôme Kieffer ([email protected])
 #
@@ -34,7 +34,7 @@
 __contact__ = "[email protected]"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "25/06/2024"
+__date__ = "20/02/2025"
 __status__ = "production"
 
 import numpy
@@ -51,6 +51,7 @@ class _Lambda(Detector):
     # This detector does not exist but those are place-holder
     MODULE_SIZE = (256, 256)
     MODULE_GAP = (4, 4)
+    DUMMY = 0
     force_pixel = True
 
     def __init__(self, pixel1=55e-6, pixel2=55e-6, max_shape=None, module_size=None, orientation=0):
@@ -128,3 +129,21 @@ class Lambda10M(_Lambda):
     """
     MAX_SHAPE = (2596, 4676)
     aliases = ["Lambda 10M"]
+
+class Lambda9M(_Lambda):
+    """
+    LAMBDA 9M detector
+    """
+    MAX_SHAPE = (3868, 3227)
+    aliases = ["Lambda 9M"]
+
+    def calc_mask(self):
+        """
+        Returns a generic mask for module based detectors...
+        """
+        if self.max_shape is None:
+            raise NotImplementedError("Generic Lambda detector does not know"
+                                      "its max size ...")
+        mask = numpy.zeros(self.max_shape, dtype=numpy.int8)
+        logger.warning("Lambda9M mask is detector specific, no pixel are actually masked")
+        return mask

src/pyFAI/gui/pilx/MainWindow.py

@@ -46,8 +46,6 @@
 from silx.gui import qt
 from silx.gui.colors import Colormap
 from silx.image.marchingsquares import find_contours
-from silx.io.url import DataUrl
-from silx.io import get_data
 from silx.gui.plot.items.image import ImageBase
 
 from .models import ImageIndices
@@ -56,17 +54,19 @@
     compute_radial_values,
     get_dataset,
     get_indices_from_values,
+    get_mask_image,
     get_radial_dataset,
 )
 from .widgets.DiffractionImagePlotWidget import DiffractionImagePlotWidget
 from .widgets.IntegratedPatternPlotWidget import IntegratedPatternPlotWidget
 from .widgets.MapPlotWidget import MapPlotWidget
 from .widgets.TitleWidget import TitleWidget
 from ...io.integration_config import WorkerConfig
-from ...utils.mathutil import binning as rebin_fct
-from ...detectors import Detector
+from ...utils.mathutil import binning
+
 logger = logging.getLogger(__name__)
 
+
 class MainWindow(qt.QMainWindow):
     sigFileChanged = qt.Signal(str)
 
@@ -253,28 +253,25 @@ def getMask(self, image, maskfile=None):
         :return: 2D array
         """
         if maskfile:
-            mask_image = get_data(url=DataUrl(maskfile))
-            if mask_image.shape != image.shape:
-                binning = [m//i for i, m in zip(image.shape, mask_image.shape)]
-                if min(binning)<1:
-                    mask_image = None
-                else:
-                    mask_image = rebin_fct(mask_image, binning)
+            mask_image = get_mask_image(maskfile, image.shape)
         else:
             mask_image = None
+
         detector = self.worker_config.poni.detector
-        if detector:
-            detector_mask = detector.mask
-            if detector.shape != image.shape:
-                detector.guess_binning(image)
-                detector_mask = rebin_fct(detector_mask, detector.binning)
-            if mask_image is None:
-                mask_image = detector_mask
-            else:
-                numpy.logical_or(mask_image, detector_mask, out=mask_image)
-            detector.mask = mask_image
-            mask_image = detector.dynamic_mask(image)
-        return mask_image
+        if not detector:
+            return mask_image
+
+        detector_mask = detector.mask
+        if detector.shape != image.shape:
+            detector.guess_binning(image)
+            detector_mask = binning(detector_mask, detector.binning)
+
+        if mask_image is None:
+            detector.mask = detector_mask
+        else:
+            detector.mask = numpy.logical_or(mask_image, detector_mask)
+
+        return detector.dynamic_mask(image)
 
     def displayImageAtIndices(self, indices: ImageIndices):
         if self._file_name is None:

src/pyFAI/gui/pilx/utils.py

@@ -28,23 +28,28 @@
 
 """Tool to visualize diffraction maps."""
 from __future__ import annotations
+
 __author__ = "Loïc Huder"
 __contact__ = "[email protected]"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
 __date__ = "19/02/2025"
 __status__ = "development"
 
-from typing import Iterable, Optional
 import logging
+from typing import Iterable, Optional, Tuple
+
 logger = logging.getLogger(__name__)
-import json
+import os.path
+
 import h5py
 import numpy
-import os.path
+from silx.io import get_data
+from silx.io.url import DataUrl
+
 from ...integrator.azimuthal import AzimuthalIntegrator
-from ...detectors import Detector
 from ...io.integration_config import WorkerConfig
+from ...utils.mathutil import binning
 
 
 def compute_radial_values(worker_config: WorkerConfig) -> numpy.ndarray:
@@ -115,3 +120,18 @@ def guess_axis_path(existing_axis_path: str, parent: h5py.Group) -> str | None:
             return guessed_axis_path
 
     return None
+
+
+def get_mask_image(maskfile: str, image_shape: Tuple[int, int]) -> numpy.ndarray | None:
+    """Retrieves mask image from the URL. Rebin to match"""
+    mask_image = get_data(url=DataUrl(maskfile))
+    assert isinstance(mask_image, numpy.ndarray)
+    if mask_image.shape == image_shape:
+        return mask_image
+
+    # If mismatched shapes, try to rebin
+    bin_size = [m // i for i, m in zip(image_shape, mask_image.shape)]
+    if bin_size[0] == 0 or bin_size[1] == 0:
+        return None
+
+    return binning(mask_image, bin_size)

src/pyFAI/integrator/azimuthal.py

@@ -1590,7 +1590,7 @@ def medfilt1d_ng(self, data,
 
                 intpl = integr.medfilt(data, **kwargs)
         else:
-            raise RuntimeError("Not yet implemented. Sorry")
+            raise RuntimeError(f"Method {method} is not yet implemented. Please report an issue on https://github.com/silx-kit/pyFAI/issues/new")
         result = Integrate1dResult(intpl.position * unit.scale, intpl.intensity, intpl.sem)
         result._set_method_called("sigma_clip_ng")
         result._set_method(method)

src/pyFAI/test/test_azimuthal_integrator.py

@@ -33,7 +33,7 @@
 __contact__ = "[email protected]"
 __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
-__date__ = "29/01/2025"
+__date__ = "11/03/2025"
 
 import unittest
 import os
@@ -304,6 +304,7 @@ def test_medfilt1d(self):
             self.assertLess(rwp, 0.1, "Rwp trimmed-mean Cython/OpenCL: %.3f" % rwp_ocl)
         ref = ocl = pyt = rwp = rwp_ocl = rwp_pyt = None
 
+    @unittest.skipIf(UtilsTest.low_mem, "test using >100Mb")
     def test_radial(self):
         "Non regression for #1602"
         res = self.ai.integrate_radial(self.data, npt=360, npt_rad=10,