darfix 4.2.0__py3-none-any.whl → 4.3.0__py3-none-any.whl

darfix/core/grainplot.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
+import warnings
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any
-from typing import Dict
 from typing import Tuple
 
+import colorstamps
 import numpy
-from matplotlib.colors import hsv_to_rgb
 from silx.math.medianfilter import medfilt2d
 
 from darfix.core.dimension import AcquisitionDims
@@ -16,19 +16,16 @@ from darfix.io.utils import create_nxdata_dict
 
 from ..dtypes import AxisType
 from ..dtypes import Dataset
+from .moment_types import MomentsPerDimension
 from .moment_types import MomentType
-from .utils import compute_hsv
 
 DimensionRange = Tuple[float, float]
 
 
-DimensionMoments = Dict[MomentType, numpy.ndarray]
-
-
 @dataclass
 class GrainPlotMaps:
     dims: AcquisitionDims
-    moments_dims: list[DimensionMoments]
+    moments_dims: MomentsPerDimension
     zsum: numpy.ndarray
     transformation: numpy.ndarray
     title: str
@@ -50,7 +47,7 @@ class GrainPlotMaps:
         )
 
 
-class OrientationDistData:
+class GrainPlotData:
     KEY_IMAGE_SIZE = 1000
 
     def __init__(
@@ -61,27 +58,30 @@ class OrientationDistData:
         x_dimension_range: DimensionRange,
         y_dimension_range: DimensionRange,
         zsum: numpy.ndarray | None = None,
+        colormap_name: str = "hsv",
+        sat: int = 40,
     ) -> 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.
+
+        :param colormap_name: See https://colorstamps.readthedocs.io/en/latest/index.html#quick-reference
+
+        :param sat: See https://colorstamps.readthedocs.io/en/latest/stamps.html#colorstamps.stamps.get_cmap
         """
 
         if len(grain_plot_maps.moments_dims) == 0:
             raise ValueError("Moments should be computed before.")
 
-        com_x = grain_plot_maps.moments_dims[x_dimension][MomentType.COM].ravel()
-        com_y = grain_plot_maps.moments_dims[y_dimension][MomentType.COM].ravel()
+        com_x = grain_plot_maps.moments_dims[x_dimension][MomentType.COM]
+        com_y = grain_plot_maps.moments_dims[y_dimension][MomentType.COM]
 
         self.x_range = x_dimension_range
         self.y_range = y_dimension_range
 
         if zsum is None:
             zsum = grain_plot_maps.zsum
-            zsum = zsum.ravel()
-        else:
-            zsum = zsum.ravel()
 
         # automatic bins
         # In darfix<=3.x orientation distribution shape was the size of the dimension
@@ -92,16 +92,11 @@ class OrientationDistData:
         self.x_label = grain_plot_maps.dims.get(x_dimension).name
         self.y_label = grain_plot_maps.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
+            com_y.ravel(),
+            com_x.ravel(),  # note: y first is in purpose : see numpy.histogram2d documentation
+            weights=zsum.ravel(),  # We need to take into account pixel intensity
             bins=[self.y_bins, self.x_bins],
             range=[self.y_range, self.x_range],
         )
@@ -109,6 +104,28 @@ class OrientationDistData:
         """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"""
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RuntimeWarning)  # Ignore nan values warning
+            self.mosaicity, stamp = colorstamps.apply_stamp(
+                com_y,
+                com_x,
+                colormap_name,
+                vmin_0=self.y_range[0],
+                vmax_0=self.y_range[1],
+                vmin_1=self.x_range[0],
+                vmax_1=self.x_range[1],
+                sat=sat,
+                clip="none",
+                l=self.KEY_IMAGE_SIZE,
+            )
+
+        # Display pixel with null intensity as black
+        self.mosaicity[zsum == 0] = 0, 0, 0
+
+        # Display out of range pixel as grey
+        self.mosaicity[numpy.isnan(self.mosaicity)] = 0.2
+
+        self.rgb_key = stamp.cmap
 
     def x_data_values(self) -> numpy.ndarray:
         return numpy.linspace(
@@ -194,34 +211,6 @@ def get_axes(transformation: Transformation | None) -> tuple[
     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][MomentType.COM],
-        dimension_range=x_dimension_range,
-    )
-    norm_center_of_mass_y = compute_normalized_component(
-        moments[y_dimension][MomentType.COM],
-        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,
@@ -243,8 +232,7 @@ def create_moment_nxdata_groups(
 
 def generate_grain_maps_nxdict(
     grainPlotMaps: GrainPlotMaps,
-    mosaicity: numpy.ndarray | None,
-    orientation_dist_image: OrientationDistData | None,
+    orientation_dist_image: GrainPlotData | None,
 ) -> dict:
     moments = grainPlotMaps.moments_dims
     axes, axes_names, axes_long_names = get_axes(grainPlotMaps.transformation)
@@ -255,9 +243,10 @@ def generate_grain_maps_nxdict(
         "@default": "entry",
     }
 
-    if mosaicity is not None:
+    if orientation_dist_image is not None:
+
         nx["entry"][MultiDimMomentType.MOSAICITY.value] = create_nxdata_dict(
-            mosaicity,
+            orientation_dist_image.mosaicity,
             MultiDimMomentType.MOSAICITY.value,
             axes,
             axes_names,
@@ -265,10 +254,7 @@ def generate_grain_maps_nxdict(
             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,
@@ -291,6 +277,8 @@ def generate_grain_maps_nxdict(
             ),
             "@default": "data",
         }
+    else:
+        nx["entry"]["@default"] = MomentType.COM.value
 
     if grainPlotMaps.dims.ndim <= 1:
         create_moment_nxdata_groups(

darfix/core/{imageStack.py → image_stack.py}

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from typing import NamedTuple
 from typing import Sequence
 
@@ -75,17 +76,11 @@ class ImageStack:
     def data(self) -> numpy.ndarray:
         return self._data
 
-    def as_array3d(self, indices=None) -> numpy.ndarray:
-        if indices is None:
-            indices = Ellipsis
-        return self._data.reshape((self.nframes,) + self.frame_shape)[indices]
+    def as_array3d(self) -> numpy.ndarray:
+        return self._data.reshape((-1,) + self.frame_shape)
 
-    def as_array2d(self, indices=None) -> numpy.ndarray:
-        if indices is None:
-            indices = Ellipsis
-        return self._data.reshape((self.nframes, self.data.size // self.nframes))[
-            indices
-        ]
+    def as_array2d(self) -> numpy.ndarray:
+        return self._data.reshape((self.nframes, -1))
 
     def filter_indices(
         self,
@@ -95,6 +90,8 @@ class ImageStack:
         """
         :return selected_indices: a list of indices filtered by input `indices` and optionally filtered with one fixed dimension `fixed_dimension`. If inputs are None return the full range of indices.
         """
+        warnings.warn("`filter_indices` method is deprecated", DeprecationWarning)
+
         if fixed_dimension is not None and not isinstance(
             fixed_dimension, FixedDimension
         ):
@@ -122,7 +119,6 @@ class ImageStack:
 
     def get_filtered_data(
         self,
-        indices: numpy.ndarray | None = None,
         fixed_dimension: FixedDimension | None = None,
     ):
         """
@@ -131,8 +127,6 @@ class ImageStack:
         :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()
 
-        return self.as_array3d()[
-            self.filter_indices(indices=indices, fixed_dimension=fixed_dimension)
-        ]
+        return self.as_array3d()[self.filter_indices(fixed_dimension=fixed_dimension)]

darfix/core/moment_types.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
 from enum import Enum
+from typing import Dict
+
+import numpy
 
 
 class MomentType(Enum):
@@ -8,3 +11,6 @@ class MomentType(Enum):
     FWHM = "FWHM"
     SKEWNESS = "Skewness"
     KURTOSIS = "Kurtosis"
+
+
+MomentsPerDimension = Dict[int, Dict[MomentType, numpy.ndarray]]

darfix/core/{noiseremoval.py → noise_removal.py}

@@ -13,34 +13,33 @@ from tqdm import tqdm
 from darfix.core.utils import OperationAborted
 
 from ..dtypes import Dataset
-from ..processing import imageOperations
-from .state_of_operation import Operation
+from ..processing import image_operations
+from .noise_removal_type import NoiseRemovalType
 
 
 class BackgroundType(_Enum):
     DATA = "Data"
-    UNUSED_DATA = "Unused data (after partition)"
     DARK_DATA = "Dark data"
 
 
 class NoiseRemovalOperation(TypedDict):
-    type: Operation
+    type: NoiseRemovalType
     parameters: dict[str, Any]
 
 
 def operation_to_str(op: NoiseRemovalOperation) -> str:
     result = None
     op_type = op["type"]
-    if op_type is Operation.BS:
+    if op_type is NoiseRemovalType.BS:
         result = f"Background subtraction {op['parameters']}"
 
-    elif op_type is Operation.HP:
+    elif op_type is NoiseRemovalType.HP:
         result = f"Hot pixel removal: {op['parameters']}"
 
-    elif op_type is Operation.THRESHOLD:
+    elif op_type is NoiseRemovalType.THRESHOLD:
         result = f"Threshold removal: {op['parameters']}"
 
-    elif op_type is Operation.MASK:
+    elif op_type is NoiseRemovalType.MASK:
         result = "Mask removal"
     else:
         raise ValueError(f"Unknown operation type {op_type}")
@@ -48,7 +47,11 @@ def operation_to_str(op: NoiseRemovalOperation) -> str:
 
 
 def clean_operation_dict(op: NoiseRemovalOperation) -> dict:
-    """Just keep `type` and `parameters` in the saved dict"""
+    """Just keep `type` and `parameters` in the saved dict. Transform numpy array into list."""
+    parameters = op["parameters"]
+    for key, value in parameters.items():
+        if isinstance(value, numpy.ndarray):
+            parameters[key] = value.tolist()
     return {
         "type": op["type"],
         "parameters": op["parameters"],
@@ -58,29 +61,29 @@ def clean_operation_dict(op: NoiseRemovalOperation) -> dict:
 def apply_noise_removal_operation(
     image: numpy.ndarray, operation: NoiseRemovalOperation
 ) -> None:
-    if operation["type"] is Operation.BS:
+    if operation["type"] is NoiseRemovalType.BS:
         apply_background_substraction(image, operation["background"])
 
-    if operation["type"] is Operation.HP:
+    if operation["type"] is NoiseRemovalType.HP:
         apply_hot_pixel_removal(image, **operation["parameters"])
 
-    if operation["type"] is Operation.THRESHOLD:
+    if operation["type"] is NoiseRemovalType.THRESHOLD:
         apply_threshold_removal(image, **operation["parameters"])
 
-    if operation["type"] is Operation.MASK:
+    if operation["type"] is NoiseRemovalType.MASK:
         apply_mask_removal(image, **operation["parameters"])
 
 
 def add_background_data_into_operation(
     dataset: Dataset,
     operation: NoiseRemovalOperation,
-) -> NoiseRemovalOperation:
-    """Compute a background image and return a NoiseRemovalOperation with a background parameter"""
+) -> None:
+    """Compute a background image and add it into `operation["background"]`"""
 
-    if operation["type"] is not Operation.BS:
+    if operation["type"] is not NoiseRemovalType.BS:
         raise ValueError("Operation type should be `Operation.BS`")
 
-    method = operation["parameters"].get("method", imageOperations.Method.MEDIAN)
+    method = operation["parameters"].get("method", image_operations.Method.MEDIAN)
 
     background_type = BackgroundType(
         operation["parameters"].get("background_type", BackgroundType.DATA.value)
@@ -88,8 +91,6 @@ def add_background_data_into_operation(
 
     if background_type is BackgroundType.DARK_DATA:
         bg = dataset.bg_dataset.as_array3d()
-    elif background_type is BackgroundType.UNUSED_DATA:
-        bg = dataset.dataset.as_array3d(dataset.bg_indices)
     elif background_type is BackgroundType.DATA:
         bg = dataset.dataset.as_array3d()
     else:
@@ -97,13 +98,13 @@ def add_background_data_into_operation(
             f"Background type {background_type!r} not implemented yet."
         )
 
-    operation["background"] = imageOperations.compute_background(bg, method)
+    operation["background"] = image_operations.compute_background(bg, method)
 
 
 def apply_background_substraction(
     image: numpy.ndarray, background: numpy.ndarray
 ) -> None:
-    imageOperations.background_subtraction(image, background)
+    image_operations.background_subtraction(image, background)
 
 
 def apply_hot_pixel_removal(
@@ -112,19 +113,19 @@ def apply_hot_pixel_removal(
     if kernel_size is None:
         kernel_size = 3
 
-    imageOperations.hot_pixel_removal(image, ksize=kernel_size)
+    image_operations.hot_pixel_removal(image, ksize=kernel_size)
 
 
 def apply_threshold_removal(
     image: numpy.ndarray, bottom: int | None = None, top: int | None = None
 ) -> None:
-    imageOperations.threshold_removal(image, bottom=bottom, top=top)
+    image_operations.threshold_removal(image, bottom=bottom, top=top)
 
 
 def apply_mask_removal(image: numpy.ndarray, mask: numpy.ndarray | None) -> None:
     if mask is None:
         return
-    imageOperations.mask_removal(image, mask)
+    image_operations.mask_removal(image, numpy.asarray(mask, dtype=bool))
 
 
 def apply_noise_removal_operations(

darfix/core/noise_removal_type.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class NoiseRemovalType(Enum):
+    """
+    Enumeration of existing Noise Removal Operations in Darfix
+    """
+
+    BS = 1
+    HP = 2
+    THRESHOLD = 3
+    MASK = 9

darfix/core/positioners.py

@@ -38,6 +38,12 @@ class Positioners:
         else:
             self.load()
 
+    def filter_by_indices(self, indices: numpy.ndarray) -> Positioners:
+        new_positioners = Positioners(self._url, dict(**self._data))
+        for positioner_name, positioner_data in self._data.items():
+            new_positioners._data[positioner_name] = positioner_data[indices]
+        return new_positioners
+
     def all(self):
         """
         Merge constants and data in the same dict

darfix/core/rocking_curves.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from threading import Event
 from typing import Sequence
 
 import numpy
@@ -48,6 +49,7 @@ def fit_rocking_curve_parallel(
     motor_values: Sequence[numpy.ndarray] | numpy.ndarray,
     thresh: float | None,
     method: FitMethod | None,
+    abort_event: Event = Event(),
 ) -> tuple[numpy.ndarray, numpy.ndarray]:
     """
     Fit the rocking curves using multiprocessing.
@@ -95,6 +97,8 @@ def fit_rocking_curve_parallel(
             i = idx % data.shape[2]
             output_data[:, j, i] = y_gauss
             maps[:, j, i] = maps_ji
+            if abort_event.is_set():
+                break
 
     return output_data, maps
 
@@ -155,13 +159,12 @@ def generate_rocking_curves_nxdict(
 def compute_residuals(
     target_dataset,  # ImageDataset. Cannot type due to circular import
     original_dataset,  # ImageDataset. Cannot type due to circular import
-    indices: numpy.ndarray | None,
 ):
     return numpy.sqrt(
         (
             numpy.subtract(
-                target_dataset.as_array3d(indices),
-                original_dataset.as_array3d(indices),
+                target_dataset.as_array3d(),
+                original_dataset.as_array3d(),
             )
             ** 2
         ).sum(axis=(0))

darfix/core/rocking_curves_map.py

@@ -7,8 +7,8 @@ class Maps_1D(_Enum):
     """Names of the fitting parameters of the 1D fit result. Each result is a map of frame size."""
 
     AMPLITUDE = "Amplitude"
-    FWHM = "FWHM"
     PEAK = "Peak position"
+    FWHM = "FWHM"
     BACKGROUND = "Background"
 
 

darfix/core/{shiftcorrection.py → shift_correction.py}

@@ -16,6 +16,5 @@ def apply_shift(
         shift = numpy.array(shift)
 
     dataset = input_dataset.dataset
-    indices = input_dataset.indices
 
-    dataset.apply_shift(shift, axis=selected_axis, indices=indices)
+    dataset.apply_shift(shift, axis=selected_axis)

darfix/core/state_of_operation.py

@@ -1,48 +1,9 @@
-from __future__ import annotations
+import warnings
 
-from contextlib import contextmanager
-from enum import IntEnum
-from typing import Optional
+from darfix.core.noise_removal_type import NoiseRemovalType
 
-
-class Operation(IntEnum):
-    """
-    Flags for different operations in Dataset
-    """
-
-    PARTITION = 0
-    BS = 1
-    HP = 2
-    THRESHOLD = 3
-    SHIFT = 4
-    ROI = 5
-    MOMENTS = 6
-    FIT = 7
-    BINNING = 8
-    MASK = 9
-
-
-class StateOfOperations:
-    def __init__(self):
-        self._is_running = [False] * len(Operation)
-
-    def _start(self, operation: Optional[Operation]) -> None:
-        if operation is None:
-            return
-        self._is_running[operation] = True
-
-    def stop(self, operation: Optional[Operation]) -> None:
-        if operation is None:
-            return
-        self._is_running[operation] = False
-
-    @contextmanager
-    def run_context(self, operation: Optional[Operation]):
-        self._start(operation)
-        try:
-            yield
-        finally:
-            self.stop(operation)
-
-    def is_running(self, operation: Operation) -> bool:
-        return self._is_running[operation]
+warnings.warn(
+    "Use of `Operation` class is deprecated and is only kept for backward compatibility with .ows file from Darfix < 4.3.",
+    DeprecationWarning,
+)
+Operation = NoiseRemovalType

darfix/core/utils.py

@@ -29,42 +29,3 @@ class TooManyDimensionsForRockingCurvesError(ValueError):
         super().__init__(
             "Unsupported number of dimensions. Rocking curves only support 1D, 2D or 3D datasets."
         )
-
-
-def wrapTo2pi(x):
-    """
-    Python implementation of Matlab method `wrapTo2pi`.
-    Wraps angles in x, in radians, to the interval [0, 2*pi] such that 0 maps
-    to 0 and 2*pi maps to 2*pi. In general, positive multiples of 2*pi map to
-    2*pi and negative multiples of 2*pi map to 0.
-    """
-    xwrap = numpy.remainder(x - numpy.pi, TWO_PI)
-    mask = numpy.abs(xwrap) > numpy.pi
-    xwrap[mask] -= TWO_PI * numpy.sign(xwrap[mask])
-    return xwrap + numpy.pi
-
-
-def compute_hsv(x_data: numpy.ndarray, y_data: numpy.ndarray):
-    data = numpy.arctan2(-y_data, -x_data)
-
-    hue = wrapTo2pi(data) / TWO_PI
-    saturation = numpy.sqrt(numpy.power(x_data, 2) + numpy.power(y_data, 2)) / SQRT_2
-    value = numpy.ones_like(x_data)
-
-    # Display NaN values as black
-    value[numpy.isnan(data)] = 0
-    hue[numpy.isnan(data)] = 0
-    saturation[numpy.isnan(data)] = 0
-
-    # Display out of range as grey
-    value[saturation > 1.0] = 0.2
-    saturation[saturation > 1.0] = 1.0
-
-    return numpy.stack(
-        (
-            hue,
-            saturation,
-            value,
-        ),
-        axis=2,
-    )

darfix/dtypes.py

@@ -7,8 +7,6 @@ from typing import Optional
 from typing import Tuple
 from typing import Union
 
-import numpy
-
 from darfix.core.dataset import ImageDataset
 
 AxisAndValueIndices = Tuple[List[int], List[int]]
@@ -20,20 +18,14 @@ class Dataset:
     def __init__(
         self,
         dataset: ImageDataset,
-        indices: Optional[numpy.ndarray] = None,
-        bg_indices: Optional[numpy.ndarray] = None,
         bg_dataset: Optional[ImageDataset] = None,
     ):
-        """Darfix dataset with indices and background
+        """Darfix dataset and background
 
         :param dataset: Darfix dataset object that holds the image stack
-        :param indices: Image stack indices to be taking into account. Usually set by the 'partition data' task. Defaults to None.
-        :param bg_indices: Dark image stack indices to be taking into account. Usually set by the 'partition data' task. Defaults to None.
         :param bg_dataset: Darfix dataset object that holds the dark image stack. Defaults to None.
         """
         self.dataset = dataset
-        self.indices = indices
-        self.bg_indices = bg_indices
         self.bg_dataset = bg_dataset