tomwer 1.3.27__py3-none-any.whl → 1.4.0rc0__py3-none-any.whl

tomwer/core/process/reconstruction/__init__.py

@@ -1,30 +1,4 @@
 # coding: utf-8
-###########################################################################
-# Copyright (C) 2016 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-#############################################################################
-
-__authors__ = ["H.Payno"]
-__license__ = "MIT"
-__date__ = "30/05/2017"
 
 """The reconstruction module is contains all processes relative to
 reconstruction (lamino, tomography reconstruction, axis calculation...)"""

tomwer/core/process/reconstruction/axis/anglemode.py

@@ -1,32 +1,4 @@
 # coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "15/10/2019"
-
 
 from silx.utils.enum import Enum as _Enum
 
@@ -38,7 +10,7 @@ class CorAngleMode(_Enum):
 
     @classmethod
     def from_value(cls, value):
-        # TODO: back comaptibility if is int
+        # TODO: back compatibility if is int
         if value == 0:
             return CorAngleMode.use_0_180
         elif value == 1:

tomwer/core/process/reconstruction/axis/axis.py

@@ -1,36 +1,9 @@
-# coding: utf-8
-###########################################################################
-# Copyright (C) 2016 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-#############################################################################
-
 """contain the AxisProcess
 """
 
-__authors__ = ["C.Nemoz", "H.Payno"]
-__license__ = "MIT"
-__date__ = "19/03/2019"
+from __future__ import annotations
 
 import logging
-from typing import Optional, Union
 
 import numpy
 from nabu.estimation.cor import (
@@ -50,6 +23,7 @@ import tomwer.version
 from tomwer.core.process.reconstruction.utils.cor import absolute_pos_to_relative
 from tomwer.core.process.task import Task
 from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils import image, logconfig
@@ -89,9 +63,7 @@ pc_height = 10.0 / 100.0
 pc_width = 50.0 / 100.0
 
 
-def _absolute_pos_to_relative_with_warning(
-    absolute_pos: float, det_width: Optional[int]
-):
+def _absolute_pos_to_relative_with_warning(absolute_pos: float, det_width: int | None):
     """
     nabu returns the value as absolute. tomwer needs it as relative
     Also handle the case (unlikely) the detector width cannot be found
@@ -147,8 +119,8 @@ def compute_cor_nabu_growing_window(
     :param radio_1:
     :param radio_2:
     :param padding_mode: padding mode
-    :param str side: side of the cor
-    :param bool flip_frame_2_lr: if True will left-right flip the second frame
+    :param side: side of the cor
+    :param flip_frame_2_lr: if True will left-right flip the second frame
     :param horz_fft_width:
 
     :return:
@@ -176,13 +148,11 @@ def compute_cor_nabu_growing_window(
 
 def compute_cor_nabu_growing_window_radios(
     scan: TomwerScanBase,
-):
+) -> float | None:
     """
     Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
 
-    :param TomwerScanBase scan:
-
-    :return:
+    :param scan: scan for which we want to get the reconstruction parameters
     """
     has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
     has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
@@ -220,13 +190,11 @@ def compute_cor_nabu_growing_window_radios(
 
 def compute_cor_nabu_growing_window_sinogram(
     scan: TomwerScanBase,
-):
+) -> float | None:
     """
     Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
 
-    :param TomwerScanBase scan:
-
-    :return:
+    :param scan:
     """
     has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
     has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
@@ -322,7 +290,7 @@ def compute_scan_composite_coarse_to_fine(scan: TomwerScanBase):
     )
 
 
-def get_composite_options(scan):
+def get_composite_options(scan) -> tuple:
     theta = scan.axis_params.composite_options.get("theta", DEFAULT_CMP_THETA)
     n_subsampling_y = scan.axis_params.composite_options.get(
         "n_subsampling_y", DEFAULT_CMP_N_SUBSAMPLING_Y
@@ -339,13 +307,12 @@ def get_composite_options(scan):
     return theta, n_subsampling_y, oversampling, take_log, near_pos, near_width
 
 
-def compute_scan_cor_nabu_growing_window(scan):
+def compute_scan_cor_nabu_growing_window(scan) -> float | None:
     """
     Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
     value.
 
-    :param `.TomoBase` scan: scan to process
-    :return: Union[float, None]
+    :param scan: scan to process
     """
     if not scan.axis_params.use_sinogram:
         radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
@@ -376,22 +343,20 @@ def compute_cor_nabu_sliding_window(
     padding_mode,
     flip_frame_2_lr=True,
     horz_fft_width=False,
-):
+) -> float | None:
     """
     Call nabu.preproc.alignement.CenterOfRotationSlidingWindow.find_shift
 
     :param radio_1:
     :param radio_2:
     :param padding_mode:
-    :param str side: side of the cor
+    :param side: side of the cor
     :param horz_fft_width:
-    :param bool flip_frame_2_lr: if True will left-right flip the second frame
+    :param flip_frame_2_lr: if True will left-right flip the second frame
     :param half_acq_cor_guess: The approximate position of the rotation axis
                                from the image center. Optional. When given a
                                special algorithm is used which can work also
                                in half-tomo conditions.
-
-    :return:
     """
     nabu_class = CenterOfRotationSlidingWindow(horz_fft_width=horz_fft_width)
     res = nabu_class.find_shift(
@@ -399,21 +364,18 @@ def compute_cor_nabu_sliding_window(
         img_2=numpy.fliplr(radio_2) if flip_frame_2_lr else radio_2,
         side=side,
         roi_yxhw=None,
-        padding_mode=padding_mode,
         median_filt_shape=None,
     )
     return res
 
 
 def compute_cor_nabu_sliding_window_radios(
-    scan,
-):
+    scan: TomwerScanBase,
+) -> float | None:
     """
-    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+    Call nabu.preproc.alignment.CenterOfRotationGrowingWindow.find_shift
 
     :param TomwerScanBase scan:
-
-    :return:
     """
     has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
     has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
@@ -442,14 +404,12 @@ def compute_cor_nabu_sliding_window_radios(
 
 
 def compute_cor_nabu_sliding_window_sinogram(
-    scan,
-):
+    scan: TomwerScanBase,
+) -> float | None:
     """
-    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+    Call nabu.preproc.alignment.CenterOfRotationGrowingWindow.find_shift
 
     :param TomwerScanBase scan:
-
-    :return:
     """
     has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
     has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
@@ -469,13 +429,12 @@ def compute_cor_nabu_sliding_window_sinogram(
     )
 
 
-def compute_scan_cor_nabu_sliding_window(scan):
+def compute_scan_cor_nabu_sliding_window(scan: TomwerScanBase) -> float | None:
     """
     Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
     value.
 
-    :param `.TomoBase` scan: scan to process
-    :return: Union[float, None]
+    :param scan: scan to process
     """
     if not scan.axis_params.use_sinogram:
         radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
@@ -499,7 +458,7 @@ def compute_scan_cor_nabu_sliding_window(scan):
         return compute_cor_nabu_sliding_window_radios(scan=scan)
 
 
-def compute_scan_fourier_angles(scan):
+def compute_scan_fourier_angles(scan: TomwerScanBase) -> float | None:
     """
     run 'scan_fourier_angles' algorithm for the requested scan
     """
@@ -522,12 +481,10 @@ def compute_scan_fourier_angles(scan):
 
 
 def compute_scan_octave_accurate_radios(
-    scan,
-):
+    scan: TomwerScanBase,
+) -> float | None:
     """
-    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
-
-    :param TomwerScanBase scan:
+    Call nabu.preproc.alignment.CenterOfRotationGrowingWindow.find_shift
 
     :return:
     """
@@ -560,12 +517,23 @@ def compute_scan_octave_accurate_radios(
     )
 
 
-def compute_scan_octave_accurate(scan):
+def read_scan_x_rotation_axis_pixel_position(scan: TomwerScanBase):
+    """read center of rotation estimation from metadata"""
+    if isinstance(scan, EDFTomoScan):
+        raise TypeError("EDFTomoScan have not information about estimated cor position")
+    else:
+        res = scan.x_rotation_axis_pixel_position
+        if res is None:
+            _logger.error(
+                f"unable to find x_rotation_axis_pixel_position from {scan.get_identifier()}"
+            )
+    return res
+
+
+def compute_scan_octave_accurate(scan: TomwerScanBase) -> float | None:
     """
     Compute center of rotation from `octave-accurate` algorithm
     scan
-    :param scan:
-    :return:
     """
     cor_options = scan.axis_params.get_nabu_cor_options_as_dict()
     radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
@@ -574,7 +542,7 @@ def compute_scan_octave_accurate(scan):
         if key in cor_options:
             extra_options[key] = float(cor_options[key])
 
-    corfinder = CenterOfRotationOctaveAccurate(cor_options=cor_options)
+    corfinder = CenterOfRotationOctaveAccurate()
     res = corfinder.find_shift(
         img_1=radio_1,
         img_2=numpy.fliplr(radio_2) if scan.axis_params.flip_lr else radio_2,
@@ -586,14 +554,10 @@ def compute_scan_octave_accurate(scan):
 
 
 def compute_cor_nabu_centered_radios(
-    scan,
-):
+    scan: TomwerScanBase,
+) -> float | None:
     """
-    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
-
-    :param TomwerScanBase scan:
-
-    :return:
+    Call nabu.preproc.alignment.CenterOfRotationGrowingWindow.find_shift
     """
     has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
     has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
@@ -636,7 +600,7 @@ def compute_cor_nabu_centered(
     :param radio_2:
     :param padding_mode:
     :param horz_fft_width:
-    :param bool flip_frame_2_lr: if True will left-right flip the second frame
+    :param flip_frame_2_lr: if True will left-right flip the second frame
     :param half_acq_cor_guess: The approximate position of the rotation axis
                                from the image center. Optional. When given a
                                special algorithm is used which can work also
@@ -656,14 +620,12 @@ def compute_cor_nabu_centered(
     )
 
 
-def compute_scan_cor_nabu_centered(scan):
+def compute_scan_cor_nabu_centered(scan: TomwerScanBase) -> float | None:
     """
     Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
     value.
 
-    :param `.TomoBase` scan: scan to process
-    :return: Union[float, None]
-
+    :param scan: scan to process
     """
     assert scan.axis_params is not None
     radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
@@ -692,7 +654,7 @@ def compute_cor_nabu_global(
     :param radio_2:
     :param padding_mode:
     :param horz_fft_width:
-    :param bool flip_frame_2_lr: if True will left-right flip the second frame
+    :param flip_frame_2_lr: if True will left-right flip the second frame
     :return:
     """
     nabu_class = CenterOfRotationAdaptiveSearch(horz_fft_width=horz_fft_width)
@@ -707,11 +669,11 @@ def compute_cor_nabu_global(
 
 def compute_cor_nabu_global_radios(
     scan: TomwerScanBase,
-):
+) -> float | None:
     """
     Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
 
-    :param TomwerScanBase scan:
+    :param scan:
 
     :return:
     """
@@ -741,14 +703,12 @@ def compute_cor_nabu_global_radios(
     )
 
 
-def compute_scan_cor_nabu_global(scan):
+def compute_scan_cor_nabu_global(scan: TomwerScanBase) -> float | None:
     """
     Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
     value.
 
-    :param `.TomoBase` scan: scan to process
-    :return: Union[float, None]
-
+    :param scan: scan to process
     """
     assert scan.axis_params is not None
     radio_1, radio_2 = AxisTask.get_inputs(scan=scan)
@@ -765,7 +725,6 @@ def compute_scan_cor_nabu_global(scan):
 def get_stdmax_column(x: numpy.ndarray) -> float:
     """
 
-    :param x:
     :return: column index of the maximal standard deviation
     """
     kernel_size = 5
@@ -792,9 +751,6 @@ class AxisTask(
 ):
     """
     Process used to compute the center of rotation of a scan
-
-    :param axis_params: parameters to configure the axis process
-    :type: AxisRP
     """
 
     _CALCULATIONS_METHODS = {
@@ -809,6 +765,7 @@ class AxisTask(
         AxisMode.near: compute_scan_composite_coarse_to_fine,
         AxisMode.sino_fourier_angles: compute_scan_fourier_angles,
         AxisMode.octave_accurate_radios: compute_scan_octave_accurate,
+        AxisMode.read: read_scan_x_rotation_axis_pixel_position,
     }
 
     def __init__(
@@ -867,12 +824,12 @@ class AxisTask(
         In this case we will lock the axis as defined 'fixed' with the current
         value
 
-        :param bool lock: if true lock the currently existing position value
+        :param lock: if true lock the currently existing position value
         """
         self._locked = lock
         if lock:
             self._recons_params_before_lock = self._axis_params.to_dict()
-            if self._axis_params not in (AxisMode.manual, AxisMode.read):
+            if self._axis_params != AxisMode.manual:
                 self._axis_params.mode = AxisMode.manual
         else:
             if self._recons_params_before_lock:
@@ -988,10 +945,9 @@ class AxisTask(
     def get_inputs_urls(scan):
         """Make sure we have valid projections to be used for axis calculation
 
-        :param TomwerScanBase scan: scan to check
+        :param scan: scan to check
         :raise: NoAxisUrl if fails to found
         :return: the two projections to be used for axis calculation
-        :rtype: tuple of AxisResource
         """
         if (
             scan.axis_params
@@ -1040,8 +996,8 @@ class AxisTask(
         """
         Compute the position value for the scan
 
-        :param TomwerScanBase scan:
-        :param bool wait: used for threaded process. True if we want to end the
+        :param scan:
+        :param wait: used for threaded process. True if we want to end the
                           computation before releasing hand.
         :return: scan as a TomoBase
         """
@@ -1108,10 +1064,10 @@ class AxisTask(
         else:
             raise NotImplementedError("mode not implemented yet")
 
-    def define_calculation_mode(self, mode, fct_pointer):
+    def define_calculation_mode(self, mode: AxisMode, fct_pointer):
         """Register the function to call of the given mode
 
-        :param AxisMode mode: the mode to register
+        :param mode: the mode to register
         :param fct_pointer: pointer to the function to call
         """
         self._mode_calculation_fct[mode] = fct_pointer
@@ -1120,13 +1076,11 @@ class AxisTask(
         """
 
         :param scan: scan for which we compute the center of rotation
-        :type: TomoScan
         :return: position of the rotation axis. Use the `.AxisMode` defined
                  by the `.ReconsParams` of the `.AxisProcess`
-        :rtype: float or None (if fail to compute the axis position)
         """
         mode = self._axis_params.mode
-        if mode in (AxisMode.manual, AxisMode.read):
+        if mode in (AxisMode.manual,):
             # If mode is read or manual the position_value is not computed and
             # we will keep the actual one (should have been defined previously)
             res = self._axis_params.relative_cor_value
@@ -1153,9 +1107,7 @@ class AxisTask(
         return "Compute center of rotation"
 
     @staticmethod
-    def get_cor_frm_process_file(
-        process_file, entry, as_url=False
-    ) -> Union[None, float]:
+    def get_cor_frm_process_file(process_file, entry, as_url=False) -> float | None:
         """
         Read cor position from a tomwer_process file
 

tomwer/core/process/reconstruction/axis/mode.py

@@ -76,7 +76,7 @@ class AxisMode(_Enum):
     composite_coarse_to_fine = "composite-coarse-to-fine"
     sino_fourier_angles = "sino-fourier-angles"
     octave_accurate_radios = "radios-octave-accurate"
-    read = "read"
+    read = "read from estimated cor"
     # alias to composite_coarse_to_fine with near mode
     near = "near"
 
@@ -93,6 +93,8 @@ class AxisMode(_Enum):
                 "Axis mode requested is 'sliding-window'. To insure backward compatibility replace it by 'sliding-window-radios'"
             )
             value = AxisMode.sliding_window_radios
+        elif value == "read":
+            value = AxisMode.read
 
         return super().from_value(value=value)
 
@@ -108,8 +110,8 @@ AXIS_MODE_METADATAS = {
     ),
     # read
     AxisMode.read: AxisModeMetadata(
-        lockable=False,
-        tooltip="Read COR value from a file",
+        lockable=True,
+        tooltip="Read COR value from nexus file ({entry}/instrument/detector/x_rotation_axis_pixel_position dataset). Will work only for NXtomo / hdf5 datasets",
         computing_constrains=(),
         allows_padding=False,
         valid_inputs=None,