darfix 4.0.3__tar.gz → 4.1.0__tar.gz

{darfix-4.0.3/src/darfix.egg-info → darfix-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: darfix
-Version: 4.0.3
+Version: 4.1.0
 Summary: Computer vision software for the interpretation of diffraction images
 Author-email: ESRF <dau-pydev@esrf.fr>
 License: The MIT license follows:
@@ -40,6 +40,7 @@ Requires-Dist: numpy<3
 Requires-Dist: numba
 Requires-Dist: silx<3,>=2.2.0
 Requires-Dist: matplotlib
+Requires-Dist: PyOpenGL
 Requires-Dist: ewoks>=1.0.0
 Requires-Dist: packaging
 Requires-Dist: scikit-learn
@@ -49,7 +50,7 @@ Requires-Dist: eval_type_backport
 Provides-Extra: full-noqt
 Requires-Dist: opencv-python-headless>=4.3.0.36; extra == "full-noqt"
 Requires-Dist: scikit-image>=0.17.1; extra == "full-noqt"
-Requires-Dist: ewoksorange>=1.0.0; extra == "full-noqt"
+Requires-Dist: ewoksorange<3.0.0,>=2.1.0; extra == "full-noqt"
 Requires-Dist: hdf5plugin; extra == "full-noqt"
 Provides-Extra: full
 Requires-Dist: darfix[full_noqt]; extra == "full"
@@ -96,6 +97,8 @@ darfix
 
 Drag widgets from the left panel to the canvas to start making your workflow.
 
+See https://darfix.readthedocs.io/en/stable/#installation for more infos and **Troubleshooting**.
+
 ## Documentation
 
 The documentation of the latest release is available at https://darfix.readthedocs.io

{darfix-4.0.3 → darfix-4.1.0}/README.md

@@ -17,6 +17,8 @@ darfix
 
 Drag widgets from the left panel to the canvas to start making your workflow.
 
+See https://darfix.readthedocs.io/en/stable/#installation for more infos and **Troubleshooting**.
+
 ## Documentation
 
 The documentation of the latest release is available at https://darfix.readthedocs.io

{darfix-4.0.3 → darfix-4.1.0}/pyproject.toml

@@ -8,7 +8,7 @@ addopts = "--import-mode=importlib" # for all pytest versions, pytest-cov needs
 
 [project]
 name = "darfix"
-version = "4.0.3"
+version = "4.1.0"
 keywords = ["orange3 add-on","ewoks"]
 authors = [{name = "ESRF", email = "dau-pydev@esrf.fr"}]
 description = "Computer vision software for the interpretation of diffraction images"
@@ -25,6 +25,7 @@ dependencies = [
     "numba",
     "silx >= 2.2.0,<3",
     "matplotlib",
+    "PyOpenGL",
     "ewoks >=1.0.0",
     "packaging",
     "scikit-learn",
@@ -44,7 +45,7 @@ Changelog = "https://gitlab.esrf.fr/XRD/darfix/-/blob/main/CHANGELOG.md"
 full_noqt = [
     "opencv-python-headless >=4.3.0.36",
     "scikit-image>=0.17.1",
-    "ewoksorange >=1.0.0",
+    "ewoksorange (>=2.1.0,<3.0.0)",
     "hdf5plugin",
 ]
 full = [

{darfix-4.0.3 → darfix-4.1.0}/src/darfix/core/dataset.py

@@ -84,6 +84,7 @@ class ImageDataset(ImageStack):
     :param transformation: Axes to use when displaying the images
     :param metadata_url: url to the metadata
     :param positioners: positioners metadata instance
+    :param moments: Pre-computed statistical 4 moments for each dimension 0:COM 1:Fwhm 2:Skewness 3:Kurtosis
     .. warning::
 
         When loading the full dataset will be store to memory.
@@ -95,10 +96,11 @@ class ImageDataset(ImageStack):
         raw_data: numpy.ndarray | None = None,
         detector_url: str | DataUrl | None = None,
         dims: AcquisitionDims | None = None,
-        transformation: numpy.ndarray | None = None,
+        transformation: Transformation | None = None,
         title: str | None = None,
         metadata_url: DataUrl | str | None = None,
         positioners: Positioners | None = None,
+        moments: dict[int, numpy.ndarray] = {},
     ):
 
         if raw_data is None:
@@ -106,7 +108,7 @@ class ImageDataset(ImageStack):
         super().__init__(raw_data)
 
         self._frames_intensity = []
-        self.moments_dims = {}
+        self.moments_dims = moments
         self.state_of_operations = StateOfOperations()
         self._dir = _dir
         self._transformation = transformation
@@ -147,7 +149,7 @@ class ImageDataset(ImageStack):
             self.state_of_operations.stop(operation)
 
     @property
-    def transformation(self):
+    def transformation(self) -> Transformation:
         return self._transformation
 
     @transformation.setter
@@ -165,7 +167,7 @@ class ImageDataset(ImageStack):
         return self._positioners.url
 
     @property
-    def dir(self):
+    def dir(self) -> str:
         return self._dir
 
     @property
@@ -950,14 +952,12 @@ class ImageDataset(ImageStack):
         return dataset
 
     @staticmethod
-    def load_from_output_dir(output_dir: str, filename: str = "data.h5"):
-        file = Path(output_dir) / filename
+    def load(file: str):
         h5dict = h5todict(file)
 
         if "positioners" in h5dict:
             positioners = Positioners(
                 DataUrl(file_path=file, data_path="/positioners", scheme="silx"),
-                h5dict["positioners"],
             )
         else:
             positioners = None
@@ -975,27 +975,25 @@ class ImageDataset(ImageStack):
             dimensions = None
 
         loaded_dataset = ImageDataset(
-            output_dir,
-            raw_data=h5dict["raw_data"],
+            Path(file).parent,
+            raw_data=h5dict["preprocessed_data"],
             dims=dimensions,
-            transformation=h5dict.get("transformation", None),
             title=h5dict.get("title", None),
             positioners=positioners,
         )
         loaded_dataset.reshape_data()
         return loaded_dataset
 
-    def save_in_output_dir(self, filename: str = "data.h5"):
-        file = Path(self._dir) / filename
+    def save(self, file: str):
+        file = Path(file)
         if "RAW_DATA" in file.parts:
             raise PermissionError(
                 f"Write in RAW_DATA dir of ESRF is not allowed: {file}"
             )
         h5dict = {
-            "raw_data": self.as_array3d(),
+            "preprocessed_data": self.as_array3d(),
             "dimensions": self.dims.to_dict(),
-            "positioners": self.metadata_dict,
-            "transformation": self.transformation,
+            "positioners": self._positioners.all(),
             "title": self.title,
             "writer": {"name": "darfix", "version": __version__},
         }

{darfix-4.0.3 → darfix-4.1.0}/src/darfix/core/dimension.py

@@ -131,6 +131,14 @@ class Dimension:
         """
         return self._stop
 
+    def min(self) -> float:
+        """Note : min can be different from start if step is negative"""
+        return min(self._start, self._stop)
+
+    def max(self) -> float:
+        """Note : max can be different from stop if step is negative"""
+        return max(self._start, self._stop)
+
     @property
     def step(self) -> float:
         """

darfix-4.1.0/src/darfix/core/grainplot.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+from typing import Tuple
+
+import numpy
+from matplotlib.colors import hsv_to_rgb
+from silx.math.medianfilter import medfilt2d
+
+from darfix.core.transformation import Transformation
+from darfix.io.utils import create_nxdata_dict
+
+from ..dtypes import AxisType
+from .dataset import ImageDataset
+from .utils import compute_hsv
+
+DimensionRange = Tuple[float, float]
+
+
+class MomentType(Enum):
+    COM = "Center of mass"
+    FWHM = "FWHM"
+    SKEWNESS = "Skewness"
+    KURTOSIS = "Kurtosis"
+
+
+class OrientationDistData:
+    KEY_IMAGE_SIZE = 1000
+
+    def __init__(
+        self,
+        dataset: ImageDataset,
+        x_dimension: int,
+        y_dimension: int,
+        x_dimension_range: DimensionRange,
+        y_dimension_range: DimensionRange,
+        zsum: numpy.ndarray | None = None,
+    ) -> None:
+        """
+        Store data for orientation distribution RGB layer (the HSV colormap) and data (Histogram 2D)
+
+        :param zsum: Precomputed dataset.zsum() used as the weight of the histogram 2D . If None dataset.zsum() is called.
+        """
+
+        if len(dataset.moments_dims) == 0:
+            raise ValueError("Moments should be computed before.")
+
+        com_x = dataset.moments_dims[x_dimension][0].ravel()
+        com_y = dataset.moments_dims[y_dimension][0].ravel()
+
+        self.x_range = x_dimension_range
+        self.y_range = y_dimension_range
+
+        if zsum is None:
+            zsum = dataset.zsum()
+            zsum = zsum.ravel()
+        else:
+            zsum = zsum.ravel()
+
+        # automatic bins
+        # In darfix<=3.x orientation distribution shape was the size of the dimension
+        # A x2 Factor is a little thinner. To see if it needs to be update in the future.
+        self.x_bins = dataset.dims.get(x_dimension).size * 2
+        self.y_bins = dataset.dims.get(y_dimension).size * 2
+
+        self.x_label = dataset.dims.get(x_dimension).name
+        self.y_label = dataset.dims.get(y_dimension).name
+
+        x_data = numpy.linspace(-1, 1, self.KEY_IMAGE_SIZE)
+        y_data = numpy.linspace(-1, 1, self.KEY_IMAGE_SIZE)
+        x_mesh, y_mesh = numpy.meshgrid(x_data, y_data)
+        self.rgb_key = hsv_to_rgb(compute_hsv(x_mesh, y_mesh))
+
+        # Histogram in 2D
+        histogram, _, _ = numpy.histogram2d(
+            com_y,
+            com_x,  # note: y first is in purpose : see numpy.histogram2d documentation
+            weights=zsum,  # We need to take into account pixel intensity
+            bins=[self.y_bins, self.x_bins],
+            range=[self.y_range, self.x_range],
+        )
+        self.data = histogram
+        """Orientation distribution data as an histogram 2D of the center of mass in two dimensions"""
+        self.smooth_data = medfilt2d(numpy.ascontiguousarray(self.data))
+        """ `self.data` filtered with a median filter 2D"""
+
+    def x_data_values(self) -> numpy.ndarray:
+        return numpy.linspace(
+            self.x_range[0], self.x_range[1], self.x_bins, endpoint=False
+        )
+
+    def y_data_values(self) -> numpy.ndarray:
+        return numpy.linspace(
+            self.y_range[0], self.y_range[1], self.y_bins, endpoint=False
+        )
+
+    def x_rgb_key_values(self) -> numpy.ndarray:
+        return numpy.linspace(
+            self.x_range[0], self.x_range[1], self.KEY_IMAGE_SIZE, endpoint=False
+        )
+
+    def y_rgb_key_values(self) -> numpy.ndarray:
+        return numpy.linspace(
+            self.y_range[0], self.y_range[1], self.KEY_IMAGE_SIZE, endpoint=False
+        )
+
+    def origin(
+        self,
+        origin: AxisType,
+    ) -> tuple[float, float]:
+        if origin == "dims":
+            return (self.x_range[0], self.y_range[0])
+        elif origin == "center":
+            return (
+                -numpy.ptp(self.x_range) / 2,
+                -numpy.ptp(self.y_range) / 2,
+            )
+        else:
+            return (0, 0)
+
+    def data_plot_scale(self) -> tuple[float, float]:
+        return (
+            numpy.ptp(self.x_range) / self.x_bins,
+            numpy.ptp(self.y_range) / self.y_bins,
+        )
+
+    def rgb_key_plot_scale(self) -> tuple[float, float]:
+        return (
+            numpy.ptp(self.x_range) / self.KEY_IMAGE_SIZE,
+            numpy.ptp(self.y_range) / self.KEY_IMAGE_SIZE,
+        )
+
+    def to_motor_coordinates(
+        self,
+        points_x: numpy.ndarray,
+        points_y: numpy.ndarray,
+        origin: AxisType,
+    ) -> tuple[numpy.ndarray, numpy.ndarray]:
+        """
+        Given points_x, points_y in the 2D space of self.data, returns motor coordinates x, y
+        """
+        x_origin, y_origin = self.origin(origin)
+        return (
+            points_x * numpy.ptp(self.x_range) / (self.x_bins - 1) + x_origin,
+            points_y * numpy.ptp(self.y_range) / (self.y_bins - 1) + y_origin,
+        )
+
+
+class MultiDimMomentType(Enum):
+    """Moments that are only computed for datasets with multiple dimensions"""
+
+    ORIENTATION_DIST = "Orientation distribution"
+    MOSAICITY = "Mosaicity"
+
+
+def get_axes(transformation: Transformation | None) -> tuple[
+    tuple[numpy.ndarray, numpy.ndarray] | None,
+    tuple[str, str] | None,
+    tuple[str, str] | None,
+]:
+    if not transformation:
+        return None, None, None
+
+    axes = (transformation.xregular, transformation.yregular)
+    axes_names = ("x", "y")
+    axes_long_names = (transformation.label, transformation.label)
+
+    return axes, axes_names, axes_long_names
+
+
+def compute_normalized_component(
+    component: numpy.ndarray, dimension_range: DimensionRange
+):
+
+    min_component = dimension_range[0]
+    max_component = dimension_range[1]
+
+    return 2 * (component - min_component) / (max_component - min_component) - 1
+
+
+def compute_mosaicity(
+    moments: dict[int, numpy.ndarray],
+    x_dimension: int,
+    y_dimension: int,
+    x_dimension_range: DimensionRange,
+    y_dimension_range: DimensionRange,
+):
+    norm_center_of_mass_x = compute_normalized_component(
+        moments[x_dimension][0],
+        dimension_range=x_dimension_range,
+    )
+    norm_center_of_mass_y = compute_normalized_component(
+        moments[y_dimension][0],
+        dimension_range=y_dimension_range,
+    )
+    return hsv_to_rgb(compute_hsv(norm_center_of_mass_x, norm_center_of_mass_y))
+
+
+def create_moment_nxdata_groups(
+    parent: dict[str, Any],
+    moment_data: numpy.ndarray,
+    axes,
+    axes_names,
+    axes_long_names,
+):
+
+    for i, map_type in enumerate(MomentType):
+        map_value = map_type.value
+        parent[map_value] = create_nxdata_dict(
+            moment_data[i],
+            map_value,
+            axes,
+            axes_names,
+            axes_long_names,
+        )
+
+
+def generate_grain_maps_nxdict(
+    dataset: ImageDataset,
+    mosaicity: numpy.ndarray | None,
+    orientation_dist_image: OrientationDistData | None,
+) -> dict:
+    moments = dataset.moments_dims
+    axes, axes_names, axes_long_names = get_axes(dataset.transformation)
+
+    nx = {
+        "entry": {"@NX_class": "NXentry"},
+        "@NX_class": "NXroot",
+        "@default": "entry",
+    }
+
+    if mosaicity is not None:
+        nx["entry"][MultiDimMomentType.MOSAICITY.value] = create_nxdata_dict(
+            mosaicity,
+            MultiDimMomentType.MOSAICITY.value,
+            axes,
+            axes_names,
+            axes_long_names,
+            rgba=True,
+        )
+        nx["entry"]["@default"] = MultiDimMomentType.MOSAICITY.value
+    else:
+        nx["entry"]["@default"] = MomentType.COM.value
+
+    if orientation_dist_image is not None:
+        nx["entry"][MultiDimMomentType.ORIENTATION_DIST.value] = {
+            "key": create_nxdata_dict(
+                orientation_dist_image.rgb_key,
+                "image",
+                (
+                    orientation_dist_image.y_rgb_key_values(),
+                    orientation_dist_image.x_rgb_key_values(),
+                ),
+                (orientation_dist_image.y_label, orientation_dist_image.x_label),
+                rgba=True,
+            ),
+            "data": create_nxdata_dict(
+                orientation_dist_image.data,
+                "orientation distribution",
+                (
+                    orientation_dist_image.y_data_values(),
+                    orientation_dist_image.x_data_values(),
+                ),
+                (orientation_dist_image.y_label, orientation_dist_image.x_label),
+            ),
+            "@default": "data",
+        }
+
+    if dataset.dims.ndim <= 1:
+        create_moment_nxdata_groups(
+            nx["entry"],
+            moments[0],
+            axes,
+            axes_names,
+            axes_long_names,
+        )
+    else:
+        for axis, dim in dataset.dims.items():
+            nx["entry"][dim.name] = {"@NX_class": "NXcollection"}
+            create_moment_nxdata_groups(
+                nx["entry"][dim.name],
+                moments[axis],
+                axes,
+                axes_names,
+                axes_long_names,
+            )
+
+    return nx

{darfix-4.0.3 → darfix-4.1.0}/src/darfix/core/imageRegistration.py

@@ -22,10 +22,11 @@ try:
 except ImportError:
     from skimage.feature import register_translation as phase_cross_correlation
 
+from enum import Enum as _Enum
+
 from packaging.version import Version
 from scipy.ndimage import center_of_mass
 from scipy.ndimage import fourier_shift
-from silx.utils.enum import Enum as _Enum
 
 from darfix.io import utils
 
@@ -168,7 +169,7 @@ def apply_opencv_shift(img, shift, shift_approach="fft"):
         raise RuntimeError(
             "opencv-python is not installed. Unable to apply shift with it. Please install it."
         )
-    shift_approach = ShiftApproach.from_value(shift_approach)
+    shift_approach = ShiftApproach(shift_approach)
     if shift_approach == ShiftApproach.LINEAR:
         img = img.astype(numpy.int16)
         M = numpy.float32([[1, 0, shift[1]], [0, 1, shift[0]]])
@@ -203,7 +204,7 @@ def improve_linear_shift(
     :param Union[`linear`,`fft`] shift_approach: The shift method to be used to apply the shift.
     :returns: ndarray
     """
-    shift_approach = ShiftApproach.from_value(shift_approach)
+    shift_approach = ShiftApproach(shift_approach)
     v = numpy.asanyarray(v)
     iData = range(data.shape[0])
 
@@ -283,7 +284,7 @@ def shift_correction(data, n_shift, shift_approach="fft", callback=None):
     :returns: The shifted images.
     :rtype: ndarray
     """
-    shift_approach = ShiftApproach.from_value(shift_approach)
+    shift_approach = ShiftApproach(shift_approach)
 
     shift = numpy.asanyarray(n_shift)
 

{darfix-4.0.3 → darfix-4.1.0}/src/darfix/core/imageStack.py

@@ -125,6 +125,14 @@ class ImageStack:
         indices: numpy.ndarray | None = None,
         fixed_dimension: FixedDimension | None = None,
     ):
+        """
+        Act like `self.as_array3d` if `fixed_dimension` is None.
+
+        :warning: if `fixed_dimension` is not None, this method duplicate the fitered part of the dataset.
+        """
+        if fixed_dimension is None:
+            return self.as_array3d(indices)
+
         return self.as_array3d()[
             self.filter_indices(indices=indices, fixed_dimension=fixed_dimension)
         ]

{darfix-4.0.3 → darfix-4.1.0}/src/darfix/core/mapping.py

@@ -15,7 +15,7 @@ import darfix
 from ..math import Vector3D
 
 
-@njit(parallel=True, fastmath=True, error_model="numpy")
+@njit(parallel=True, fastmath=True, cache=True, error_model="numpy")
 def _mean_fast(
     x: numpy.ndarray,
     y: numpy.ndarray,
@@ -34,7 +34,7 @@ def _mean_fast(
     return mean
 
 
-@njit(parallel=True, fastmath=True, error_model="numpy")
+@njit(parallel=True, fastmath=True, cache=True, error_model="numpy")
 def _sigma_fast(
     x: numpy.ndarray,
     y: numpy.ndarray,
@@ -57,7 +57,7 @@ def _sigma_fast(
     return sigma
 
 
-@njit(parallel=True, fastmath=True, error_model="numpy")
+@njit(parallel=True, fastmath=True, cache=True, error_model="numpy")
 def _skewness_kurtosis_fast(
     x: numpy.ndarray,
     y: numpy.ndarray,

{darfix-4.0.3 → darfix-4.1.0}/src/darfix/core/noiseremoval.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 from concurrent.futures import ThreadPoolExecutor
 from concurrent.futures import as_completed
+from enum import Enum as _Enum
 from typing import Any
 from typing import Callable
 from typing import TypedDict
 
 import numpy
-from silx.utils.enum import Enum as _Enum
 from tqdm import tqdm
 
 from darfix.core.utils import OperationAborted
@@ -26,34 +26,40 @@ class BackgroundType(_Enum):
 class NoiseRemovalOperation(TypedDict):
     type: Operation
     parameters: dict[str, Any]
-    aborted: bool
 
 
 def operation_to_str(op: NoiseRemovalOperation) -> str:
     result = None
-    if op["type"] is Operation.BS:
+    op_type = op["type"]
+    if op_type is Operation.BS:
         result = f"Background subtraction {op['parameters']}"
 
-    elif op["type"] is Operation.HP:
+    elif op_type is Operation.HP:
         result = f"Hot pixel removal: {op['parameters']}"
 
-    elif op["type"] is Operation.THRESHOLD:
+    elif op_type is Operation.THRESHOLD:
         result = f"Threshold removal: {op['parameters']}"
 
-    elif op["type"] is Operation.MASK:
+    elif op_type is Operation.MASK:
         result = "Mask removal"
+    else:
+        raise ValueError(f"Unknown operation type {op_type}")
+    return result
 
-    if result is not None:
-        return result + (" ABORTED" if "aborted" in op else "")
 
-    return super().__str__(op)
+def clean_operation_dict(op: NoiseRemovalOperation) -> dict:
+    """Just keep `type` and `parameters` in the saved dict"""
+    return {
+        "type": op["type"],
+        "parameters": op["parameters"],
+    }
 
 
 def apply_noise_removal_operation(
     image: numpy.ndarray, operation: NoiseRemovalOperation
 ) -> None:
     if operation["type"] is Operation.BS:
-        apply_background_substraction(image, **operation["parameters"])
+        apply_background_substraction(image, operation["background"])
 
     if operation["type"] is Operation.HP:
         apply_hot_pixel_removal(image, **operation["parameters"])
@@ -76,7 +82,7 @@ def create_background_substraction_operation(
         method = imageOperations.Method.MEDIAN
 
     if background_type is not None:
-        background_type = BackgroundType.from_value(background_type)
+        background_type = BackgroundType(background_type)
 
     if background_type == BackgroundType.DARK_DATA:
         bg = dataset.bg_dataset.as_array3d()
@@ -88,10 +94,12 @@ def create_background_substraction_operation(
         raise NotImplementedError(
             f"Background type {background_type!r} not implemented yet."
         )
+    parameters = dict(method=method, background_type=background_type)
 
     return NoiseRemovalOperation(
         type=Operation.BS,
-        parameters=dict(background=imageOperations.compute_background(bg, method)),
+        parameters=parameters,
+        background=imageOperations.compute_background(bg, method),
     )
 
 

{darfix-4.0.3 → darfix-4.1.0}/src/darfix/core/positioners.py

@@ -38,9 +38,15 @@ class Positioners:
         else:
             self.load()
 
+    def all(self):
+        """
+        Merge constants and data in the same dict
+        """
+        return {**self._data, **self._constants}
+
     def load(self):
         """
-        Use url to load data
+        Use url to load data and constants
         """
         h5_positioners_dict = {}
         self._constants = {}

{darfix-4.0.3 → darfix-4.1.0}/src/darfix/core/rocking_curves.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import multiprocessing
+from enum import Enum as _Enum
 from functools import partial
 from multiprocessing import Pool
 from typing import Generator
@@ -11,7 +12,6 @@ from typing import Union
 
 import numpy
 import tqdm
-from silx.utils.enum import Enum as _Enum
 
 from ..io.utils import create_nxdata_dict
 from ..processing.rocking_curves import FitMethod
@@ -61,9 +61,9 @@ class Maps_3D(_Enum):
     CORRELATION_YZ = "Cross-correlation between second and third motors"
 
 
-MAPS_1D: Tuple[Maps_1D] = Maps_1D.values()
-MAPS_2D: Tuple[Maps_2D] = Maps_2D.values()
-MAPS_3D: Tuple[Maps_3D] = Maps_3D.values()
+MAPS_1D: Tuple[Maps_1D] = tuple(member.value for member in Maps_1D)
+MAPS_2D: Tuple[Maps_2D] = tuple(member.value for member in Maps_2D)
+MAPS_3D: Tuple[Maps_3D] = tuple(member.value for member in Maps_3D)
 
 
 def _rocking_curves_per_px(