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

darfix/gui/utils/data_path_completer.py

@@ -3,13 +3,13 @@ from __future__ import annotations
 import h5py
 from silx.gui import qt
 
-from darfix.core.datapathfinder import DETECTOR_KEYWORD
-from darfix.core.datapathfinder import EXISTING_KEYWORDS
-from darfix.core.datapathfinder import FIRST_SCAN_KEYWORD
-from darfix.core.datapathfinder import LAST_SCAN_KEYWORD
-from darfix.core.datapathfinder import SCAN_KEYWORD
-from darfix.core.datapathfinder import get_first_group
-from darfix.core.datapathfinder import get_last_group
+from darfix.core.data_path_finder import DETECTOR_KEYWORD
+from darfix.core.data_path_finder import EXISTING_KEYWORDS
+from darfix.core.data_path_finder import FIRST_SCAN_KEYWORD
+from darfix.core.data_path_finder import LAST_SCAN_KEYWORD
+from darfix.core.data_path_finder import SCAN_KEYWORD
+from darfix.core.data_path_finder import get_first_group
+from darfix.core.data_path_finder import get_last_group
 
 
 class _TreeBuilder:

darfix/gui/utils/data_path_selection.py

@@ -10,10 +10,10 @@ from silx.gui import qt
 from silx.gui.dialog.DatasetDialog import DatasetDialog
 from silx.gui.dialog.GroupDialog import GroupDialog
 
-from darfix.core.datapathfinder import DataPathFinder
-from darfix.core.datapathfinder import UnsolvablePatternError
-from darfix.core.datapathfinder import get_first_group
-from darfix.core.datapathfinder import get_last_group
+from darfix.core.data_path_finder import DataPathFinder
+from darfix.core.data_path_finder import UnsolvablePatternError
+from darfix.core.data_path_finder import get_first_group
+from darfix.core.data_path_finder import get_last_group
 from darfix.gui.utils.data_path_completer import DataPathLineEditWithCompleter
 from darfix.gui.utils.message import unable_to_search_inside_hdf5_file
 

darfix/gui/utils/{rangeSlider.py → range_slider.py}

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import numpy
-from ewoksorange.gui.parameterform import block_signals
+from ewoksorange.gui.widgets.parameter_form import block_signals
 from silx.gui import qt
 from silx.gui.widgets.RangeSlider import RangeSlider
 

darfix/gui/{weakBeamWidget.py → weak_beam_widget.py}

@@ -6,23 +6,16 @@ from silx.gui.colors import Colormap
 from silx.gui.plot import Plot2D
 
 import darfix
+from darfix import dtypes
+from darfix.core.moment_types import MomentType
 from darfix.gui.utils.custom_doublespinbox import createCustomDoubleSpinBox
 
-from ..core.transformation import Transformation
-
 
 class WeakBeamWidget(qt.QMainWindow):
     """
     Widget to recover weak beam to obtain dislocations.
     """
 
-    sigValidate = qt.Signal()
-    """Emit when user validate weak beam (ok pressed)"""
-    sigApplyThreshold = qt.Signal()
-    """Emit when user ask to apply a threshold"""
-    sigNValueChanged = qt.Signal()
-    """Emit when N value has changed"""
-
     def __init__(self, parent=None):
         qt.QMainWindow.__init__(self, parent)
 
@@ -30,9 +23,6 @@ class WeakBeamWidget(qt.QMainWindow):
         layout = qt.QGridLayout()
 
         self._nLE = createCustomDoubleSpinBox()
-        _buttons = qt.QDialogButtonBox(parent=self)
-        self._okB = _buttons.addButton(_buttons.Ok)
-        self._applyThresholdB = _buttons.addButton(_buttons.Apply)
 
         self._plot = Plot2D()
         self._plot.setDefaultColormap(
@@ -42,19 +32,13 @@ class WeakBeamWidget(qt.QMainWindow):
             )
         )
         layout.addWidget(
-            qt.QLabel("Increase/decrease threshold std by a value of : "), 0, 0
+            qt.QLabel("Threshold of X times the standart deviation : "), 0, 0
         )
         layout.addWidget(self._nLE, 0, 1)
         layout.addWidget(self._plot, 1, 0, 1, 2)
-        layout.addWidget(_buttons, 2, 0, 1, 2)
         widget.setLayout(layout)
         self.setCentralWidget(widget)
 
-        # connect signal / slot
-        self._applyThresholdB.clicked.connect(self.sigApplyThreshold)
-        self._okB.clicked.connect(self.sigValidate)
-        self._nLE.editingFinished.connect(self.sigNValueChanged)
-
         # set up
         self.nvalue = 1
 
@@ -66,14 +50,19 @@ class WeakBeamWidget(qt.QMainWindow):
     def nvalue(self, nvalue: float):
         self._nLE.setValue(nvalue)
 
-    def setResult(
-        self, center_of_mass: numpy.ndarray, transformation: None | Transformation
-    ):
+    def updateDataset(self, dataset: dtypes.Dataset):
+        imgDataset = dataset.dataset
+        center_of_mass = imgDataset.moments_dims[0][MomentType.COM]
+        transformation = imgDataset.transformation
         self._plot.clear()
         if transformation is None:
-            self._plot.addImage(center_of_mass, xlabel="pixels", ylabel="pixels")
+            self._plot.addImage(
+                center_of_mass,
+                xlabel="pixels",
+                ylabel="pixels",
+            )
         else:
-            if self._dataset.transformation.rotate:
+            if transformation.rotate:
                 center_of_mass = numpy.rot90(center_of_mass, 3)
             self._plot.addImage(
                 center_of_mass,
@@ -82,7 +71,3 @@ class WeakBeamWidget(qt.QMainWindow):
                 xlabel=transformation.label,
                 ylabel=transformation.label,
             )
-
-    def setProcessingButtonsEnabled(self, enabled):
-        self._applyThresholdB.setEnabled(enabled)
-        self._okB.setEnabled(enabled)

darfix/gui/{zSumWidget.py → zsum_widget.py}

@@ -7,7 +7,7 @@ from silx.gui.plot.StackView import StackViewMainWindow
 import darfix
 
 from ..dtypes import Dataset
-from .filterByDimension import FilterByDimensionWidget
+from .filter_by_dimension import FilterByDimensionWidget
 
 
 class ZSumWidget(qt.QMainWindow):
@@ -38,7 +38,6 @@ class ZSumWidget(qt.QMainWindow):
 
     def setDataset(self, dataset: Dataset):
         self.dataset = dataset.dataset
-        self.indices = dataset.indices
         self._selector.setDimensions(self.dataset.dims)
         self._sv.setGraphTitle(self.dataset.title)
 

darfix/main.py

@@ -1,18 +1,33 @@
 import importlib.metadata
+import os
+import signal
 import sys
 from argparse import ArgumentParser
 
 from silx import config
 
 try:
-    from ewoksorange.canvas.main import arg_parser
     from ewoksorange.canvas.main import main as ewoksorange_main
+    from ewoksorange.gui.canvas.main import arg_parser
 except ImportError as e:
     error_msg = f"ERROR: {e.msg}.\n"
     error_msg += "To use `darfix` command, please use the full installation of darfix:\npip install darfix[full]\n"
     sys.stdout.write(error_msg)
     exit()
 
+__CTRL_C_PRESSED_ONCE = False
+
+
+def __handle_ctrl_c(*args):
+    global __CTRL_C_PRESSED_ONCE
+    if not __CTRL_C_PRESSED_ONCE:
+        __CTRL_C_PRESSED_ONCE = True
+        sys.stdout.write("\nPress CTRL+C again to force kill app.\n")
+    else:
+        # harakiri
+        sys.stdout.write("\nApp killed by user.\n")
+        os.kill(os.getpid(), signal.SIGKILL)
+
 
 def main(argv=None):
 
@@ -43,8 +58,9 @@ def main(argv=None):
     if options.version:
         print(f"Darfix version: {importlib.metadata.version('darfix')}")
         return
-    if ewoksorange_main is None:
-        raise ImportError("Install darfix[full] to use the Orange canvas.")
+
+    signal.signal(signal.SIGINT, __handle_ctrl_c)
+
     ewoksorange_main()
 
 

darfix/processing/rocking_curves.py

@@ -265,7 +265,7 @@ def _fit_xd_rocking_curve(
     :param  x_values: 2D array: K dimensions, N points (float64)
 
     :return: Tuple with:
-    - the fitted gaussian : 1D array of N points (float64)
+    - the fitted gaussian : 1D array of N points (float64) (Only non-zero value of original `y_values` are fitted)
     - fit parameters :  1D array of length len_maps
     """
     if method is None:
@@ -277,17 +277,14 @@ def _fit_xd_rocking_curve(
 
     ptp_y = numpy.ptp(y_values)
 
-    fitted_y = numpy.zeros_like(y_values)
-    y_not_zero_mask = y_values > 0
+    y_zeros = numpy.zeros_like(y_values)
 
     if ptp_y <= thresh:
         # Ptp under threshold
-        return fitted_y, numpy.full(len_maps, numpy.nan)
+        return y_zeros, numpy.full(len_maps, numpy.nan)
 
     if len(y_values) < len_maps:
-        return fitted_y, numpy.full(len_maps, numpy.nan)
-
-    ptp_y = numpy.ptp(y_values)
+        return y_zeros, numpy.full(len_maps, numpy.nan)
 
     p0 = p0_function(com, fwhm, ptp_y)
 
@@ -300,6 +297,7 @@ def _fit_xd_rocking_curve(
         max_y=vmax,
     )
 
+    y_not_zero_mask = y_values > 0
     x_values_masked = x_values[:, y_not_zero_mask]
 
     try:
@@ -316,11 +314,12 @@ def _fit_xd_rocking_curve(
             f"Encountered the following error while fitting rocking curves: '{e}'"
         )
         _logger.debug(f"p0 : \n{p0}\nbounds : \n{bounds}")
-        return fitted_y, numpy.full(len_maps, numpy.nan)
+        return y_zeros, numpy.full(len_maps, numpy.nan)
 
-    fitted_y[y_not_zero_mask] = gaussian_function(x_values_masked, *fit_params)
+    y_fitted = y_zeros
+    y_fitted[y_not_zero_mask] = gaussian_function(x_values_masked, *fit_params)
 
-    return fitted_y, fit_params
+    return y_fitted, fit_params
 
 
 def fit_1d_rocking_curve(
@@ -334,7 +333,7 @@ def fit_1d_rocking_curve(
     :param  x_values: 1D array of N float64
 
     :return: Tuple with:
-    - the fitted gaussian : 1D array of float64
+    - the fitted gaussian : 1D array of float64 (Only non-zero value of original `y_values` are fitted)
     - fit parameters :  1D array of length len(MAPS_1D)
     """
     # _fit_xd_rocking_curve expect array with shape (N_dims, N_points)
@@ -367,7 +366,7 @@ def fit_2d_rocking_curve(
     :param x_values: 2D array (2,N) of float64
 
     :return: Tuple with:
-    - the fitted gaussian : 1D array of N float64
+    - the fitted gaussian : 1D array of N float64 (Only non-zero value of original `y_values` are fitted)
     - fit parameters :  1D array of length len(MAPS_2D)
     """
     return _fit_xd_rocking_curve(
@@ -393,7 +392,7 @@ def fit_3d_rocking_curve(
     :param  x_values: 2D array (3,N) of float64
 
     Return: Tuple with:
-    - the fitted gaussian : 1D array of N float64
+    - the fitted gaussian : 1D array of N float64 (Only non-zero value of original `y_values` are fitted)
     - fit parameters :  1D array of length len(MAPS_3D)
     """
     return _fit_xd_rocking_curve(

darfix/tasks/binning.py

@@ -1,11 +1,8 @@
 from __future__ import annotations
 
-import os
-
 import numpy
+import tqdm
 from ewokscore import Task
-from ewokscore.missing_data import MISSING_DATA
-from ewokscore.missing_data import MissingData
 from ewokscore.model import BaseInputModel
 from pydantic import ConfigDict
 from skimage.transform import rescale
@@ -19,8 +16,6 @@ class Inputs(BaseInputModel):
     """ Input dataset containing a stack of images """
     scale: float
     """Factor to rescale images of the dataset."""
-    output_dir: str | MissingData = MISSING_DATA
-    """ Output directory where the binned data will be saved. If not set, use the input dataset directory."""
 
 
 class Binning(
@@ -34,33 +29,27 @@ class Binning(
         input_dataset: Dataset = self.inputs.dataset
         dataset = input_dataset.dataset
 
-        if len(dataset.data.shape) >= 4:
-            # TODO: Is this expected ? Or should it be fixed for higher dimensionality ?
-            raise ValueError("Binning cannot only be applied to 4D datasets or higher")
-
         scale = self.inputs.scale
-        output_dir = self.get_input_value("output_dir", dataset.dir)
-        os.makedirs(output_dir, exist_ok=True)
 
         # rescale data
         new_data = None
-        for i, image in enumerate(dataset.data):
+        for i, image in enumerate(
+            tqdm.tqdm(dataset.as_array3d(), desc="Binning", total=dataset.nframes)
+        ):
             simage = rescale(image, scale, anti_aliasing=True, preserve_range=True)
             if new_data is None:
                 new_data = numpy.empty(
-                    (len(dataset.data),) + simage.shape, dtype=dataset.data.dtype
+                    (dataset.nframes,) + simage.shape, dtype=dataset.data.dtype
                 )
             new_data[i] = simage
             if self.cancelled:
                 # if cancelled then self.outputs.dataset will be MISSING_DATA
                 return
 
-        new_dataset = dataset.copy(new_dir=output_dir, new_data=new_data)
+        new_dataset = dataset.copy(new_data=new_data)
 
         self.outputs.dataset = Dataset(
             dataset=new_dataset,
-            indices=input_dataset.indices,
-            bg_indices=input_dataset.bg_indices,
             bg_dataset=input_dataset.bg_dataset,
         )
 

darfix/tasks/blind_source_separation.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import os
+from enum import Enum as _Enum
+
+from ewokscore import Task
+from ewokscore.missing_data import MISSING_DATA
+from ewokscore.missing_data import MissingData
+from ewokscore.model import BaseInputModel
+from pydantic import ConfigDict
+from pydantic import Field
+
+from darfix import dtypes
+from darfix.io.utils import write_components
+
+
+class Method(_Enum):
+    """
+    Different blind source separation approaches that can be applied
+    """
+
+    PCA = "PCA"
+
+    NICA = "NICA"
+
+    NMF = "NMF"
+
+    NICA_NMF = "NICA_NMF"
+
+    @staticmethod
+    def _descriptions() -> dict:
+        return {
+            Method.PCA: (
+                "The process of computing the principal components \n"
+                "and using them to perform a change of basis on the data"
+            ),
+            Method.NICA: "Find components independent from each other and non-negative",
+            Method.NMF: (
+                "Non-negative matrix factorization factorizes the data matrix into \n"
+                "two matrices, with the property that all three matrices have no negative elements"
+            ),
+            Method.NICA_NMF: "Apply Non-negative ICA followed by NMF",
+        }
+
+    @staticmethod
+    def get_description(method) -> str:
+        method = Method(method)
+        if method in Method._descriptions():
+            return Method._descriptions()[method]
+        else:
+            raise NotImplementedError
+
+
+class Inputs(BaseInputModel):
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    dataset: dtypes.Dataset
+    """ Input dataset containing a stack of images """
+    method: Method
+    "Method to use for blind source separation"
+    n_comp: int | MissingData = Field(
+        default=MISSING_DATA, description="Number of components to extract"
+    )
+    save: bool | MissingData = MISSING_DATA
+    processing_order: int | MissingData = MISSING_DATA
+
+
+class BlindSourceSeparation(
+    Task,
+    input_model=Inputs,
+    output_names=["dataset", "comp", "W"],
+):
+    """Perform blind source separation on a Darfix dataset.
+    Blind source separation (BSS) comprises all techniques that try to decouple a set of source signals from a set of mixed signals with unknown (or very little) information.
+
+    Supported methods are PCA, NICA, NMF and NICA_NMF.
+
+    Related article  : https://pmc.ncbi.nlm.nih.gov/articles/PMC10161887/#sec3.3.3
+
+    """
+
+    def run(self):
+        if not isinstance(self.inputs.dataset, dtypes.Dataset):
+            raise TypeError(
+                f"'dataset' input should be an instance of Dataset. Got {type(self.inputs.dataset)}."
+            )
+        dataset = self.inputs.dataset.dataset
+        bg_dataset = self.inputs.dataset.bg_dataset
+
+        n_comp = self.get_input_value("n_comp", None)
+        method = Method(self.inputs.method)
+        if method == Method.PCA:
+            comp, W = dataset.pca(n_comp)
+        elif method == Method.NICA:
+            comp, W = dataset.nica(n_comp)
+        elif method == Method.NMF:
+            comp, W = dataset.nmf(n_comp)
+        elif method == Method.NICA_NMF:
+            comp, W = dataset.nica_nmf(n_comp)
+        else:
+            raise ValueError("BSS method not managed")
+        n_comp = comp.shape[0]
+        shape = dataset.frame_shape
+        comp = comp.reshape(n_comp, shape[0], shape[1])
+
+        if self.get_input_value("save", False):
+            write_components(
+                h5file=os.path.join(dataset.dir, "components.h5"),
+                entry="entry",
+                dimensions=dataset.dims.to_dict(),
+                W=W,
+                data=comp,
+                values=dataset.get_dimensions_values(),
+                processing_order=self.get_input_value("processing_order", 0),
+            )
+        self.outputs.dataset = dtypes.Dataset(
+            dataset=dataset,
+            bg_dataset=bg_dataset,
+        )
+
+        self.outputs.W = W
+        self.outputs.comp = comp

darfix/tasks/blindsourceseparation.py

@@ -1,133 +1,10 @@
-from __future__ import annotations
+import warnings
 
-import os
-from enum import Enum as _Enum
+from .blind_source_separation import BlindSourceSeparation  # noqa: F401
 
-import numpy
-from ewokscore import Task
-from ewokscore.missing_data import MISSING_DATA
-from ewokscore.missing_data import MissingData
-from ewokscore.model import BaseInputModel
-from pydantic import ConfigDict
-from pydantic import Field
-
-from darfix import dtypes
-from darfix.io.utils import write_components
-
-
-class Method(_Enum):
-    """
-    Different blind source separation approaches that can be applied
-    """
-
-    PCA = "PCA"
-
-    NICA = "NICA"
-
-    NMF = "NMF"
-
-    NICA_NMF = "NICA_NMF"
-
-    @staticmethod
-    def _descriptions() -> dict:
-        return {
-            Method.PCA: (
-                "The process of computing the principal components \n"
-                "and using them to perform a change of basis on the data"
-            ),
-            Method.NICA: "Find components independent from each other and non-negative",
-            Method.NMF: (
-                "Non-negative matrix factorization factorizes the data matrix into \n"
-                "two matrices, with the property that all three matrices have no negative elements"
-            ),
-            Method.NICA_NMF: "Apply Non-negative ICA followed by NMF",
-        }
-
-    @staticmethod
-    def get_description(method) -> str:
-        method = Method(method)
-        if method in Method._descriptions():
-            return Method._descriptions()[method]
-        else:
-            raise NotImplementedError
-
-
-class Inputs(BaseInputModel):
-    model_config = ConfigDict(use_attribute_docstrings=True)
-    dataset: dtypes.Dataset
-    """ Input dataset containing a stack of images """
-    method: Method
-    "Method to use for blind source separation"
-    n_comp: int | MissingData = Field(
-        default=MISSING_DATA, description="Number of components to extract"
-    )
-    save: bool | MissingData = MISSING_DATA
-    processing_order: int | MissingData = MISSING_DATA
-
-
-class BlindSourceSeparation(
-    Task,
-    input_model=Inputs,
-    output_names=["dataset", "comp", "W"],
-):
-    """Perform blind source separation on a Darfix dataset.
-    Blind source separation (BSS) comprises all techniques that try to decouple a set of source signals from a set of mixed signals with unknown (or very little) information.
-
-    Supported methods are PCA, NICA, NMF and NICA_NMF.
-
-    Related article  : https://pmc.ncbi.nlm.nih.gov/articles/PMC10161887/#sec3.3.3
-
-    """
-
-    def run(self):
-        if not isinstance(self.inputs.dataset, dtypes.Dataset):
-            raise TypeError(
-                f"'dataset' input should be an instance of Dataset. Got {type(self.inputs.dataset)}."
-            )
-        dataset = self.inputs.dataset.dataset
-        indices = self.inputs.dataset.indices
-        bg_indices = self.inputs.dataset.bg_indices
-        bg_dataset = self.inputs.dataset.bg_dataset
-
-        n_comp = self.get_input_value("n_comp", None)
-        method = Method(self.inputs.method)
-        if method == Method.PCA:
-            comp, W = dataset.pca(n_comp, indices=indices)
-        elif method == Method.NICA:
-            comp, W = dataset.nica(n_comp, indices=indices)
-        elif method == Method.NMF:
-            comp, W = dataset.nmf(n_comp, indices=indices)
-        elif method == Method.NICA_NMF:
-            comp, W = dataset.nica_nmf(n_comp, indices=indices)
-        else:
-            raise ValueError("BSS method not managed")
-        n_comp = comp.shape[0]
-        shape = dataset.frame_shape
-        comp = comp.reshape(n_comp, shape[0], shape[1])
-        if bg_indices is not None:
-            # If filter data is activated, the matrix W has reduced dimensionality, so reshaping is not possible
-            # Create empty array with shape the total number of frames
-            W = numpy.zeros((dataset.nframes, n_comp))
-            # Set actual values of W where threshold of filter is True
-            W[indices] = W
-            W = W
-
-        if self.get_input_value("save", False):
-            write_components(
-                h5file=os.path.join(dataset.dir, "components.h5"),
-                entry="entry",
-                dimensions=dataset.dims.to_dict(),
-                W=W,
-                data=comp,
-                values=dataset.get_dimensions_values(),
-                processing_order=self.get_input_value("processing_order", 0),
-            )
-        self.outputs.dataset = dtypes.Dataset(
-            dataset=dataset,
-            indices=indices,
-            bg_indices=bg_indices,
-            bg_dataset=bg_dataset,
-        )
-
-        self.outputs.W = W
-        self.outputs.comp = comp
+warnings.warn(
+    f"The '{__name__}' module is deprecated and will be removed in a future release. "
+    "Please replace module name `blindsourceseparation` by `blind_source_separation`",
+    DeprecationWarning,
+    stacklevel=2,
+)

darfix/tasks/copy.py

@@ -24,7 +24,5 @@ class DataCopy(
             raise dtypes.DatasetTypeError(dataset)
         self.outputs.dataset = dtypes.Dataset(
             dataset=copy.deepcopy(dataset.dataset),
-            indices=copy.deepcopy(dataset.indices),
-            bg_indices=copy.deepcopy(dataset.bg_indices),
             bg_dataset=copy.deepcopy(dataset.bg_dataset),
         )

darfix/tasks/data_partition.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import warnings
+
+from ewokscore import Task
+from ewokscore.missing_data import MISSING_DATA
+from ewokscore.missing_data import MissingData
+from ewokscore.model import BaseInputModel
+from pydantic import ConfigDict
+
+from darfix import dtypes
+
+
+class Inputs(BaseInputModel):
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    dataset: dtypes.Dataset
+    bins: int | MissingData = MISSING_DATA
+    filter_bottom_bin_idx: int | MissingData = MISSING_DATA
+    filter_top_bin_idx: int | MissingData = MISSING_DATA
+
+
+class DataPartition(
+    Task,
+    input_model=Inputs,
+    output_names=["dataset"],
+):
+    """
+    :deprecated: Deprecated task to be removed in 5.0.
+    """
+
+    def run(self):
+        warnings.warn(
+            "`DataPartition` is a legacy task and is poorly tested in Darfix. Before 4.3, it might induce weird behaviour in the next tasks of the workflow."
+            "In 4.3, the low intensity filtering is deactivate and the task does not modify the dataset. This just does nothing in order to not break compatibility with existing workflows."
+            "In 5.0, the task will be removed.",
+            DeprecationWarning,
+        )
+        # Just a pass through
+        self.outputs.dataset = self.inputs.dataset