tomwer 1.3.26__py3-none-any.whl → 1.4.0__py3-none-any.whl

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

@@ -1,6 +1,7 @@
 import logging
 
 from silx.utils.enum import Enum as _Enum
+from tomwer.core.process.reconstruction.axis.side import Side
 
 _logger = logging.getLogger(__name__)
 
@@ -11,6 +12,14 @@ class AxisModeMetadata:
 
     Ease processing and display
     Maybe this function should be part of nabu ?
+
+    :param lockable: True if this value can be lock and process automatically when a new scan is received
+    :param tooltip: short description of the mode (to be used by the GUI)
+    :param computing_constrains: some constrain like need to have a 0-360 acquisition (so no Half acquisition)
+    :param allows_padding: does the algorithm applies padding (and so can the user provide some mode)
+    :param valid_inputs: compatible input type (pair of radios or sinogram...)
+    :param valid_sides: can a side be provided
+    :param allows_estimated_cor_as_numerical_value: can a numerical value (first guess) be provided to the algorithm
     """
 
     def __init__(
@@ -21,6 +30,7 @@ class AxisModeMetadata:
         allows_padding=False,
         valid_inputs=(),
         valid_sides=(),
+        allows_estimated_cor_as_numerical_value: bool = True,
     ) -> None:
         self._lockable = lockable
         self._tooltip = tooltip
@@ -28,6 +38,9 @@ class AxisModeMetadata:
         self._allows_padding = allows_padding
         self._valid_inputs = valid_inputs
         self._valid_sides = valid_sides
+        self._allows_estimated_cor_as_numerical_value = (
+            allows_estimated_cor_as_numerical_value
+        )
 
     @property
     def is_lockable(self) -> bool:
@@ -53,6 +66,10 @@ class AxisModeMetadata:
     def valid_sides(self) -> tuple:
         return self._valid_sides
 
+    @property
+    def allows_estimated_cor_as_numerical_value(self) -> bool:
+        return self._allows_estimated_cor_as_numerical_value
+
 
 class _InputType(_Enum):
     SINOGRAM = "sinogram"
@@ -69,33 +86,57 @@ class AxisMode(_Enum):
     global_ = "global"
     manual = "manual"
     growing_window_sinogram = "sino-growing-window"
-    growing_window_radios = "radios-growing-window"
+    growing_window_radios = "growing-window"
     sliding_window_sinogram = "sino-sliding-window"
-    sliding_window_radios = "radios-sliding-window"
+    sliding_window_radios = "sliding-window"
     sino_coarse_to_fine = "sino-coarse-to-fine"
     composite_coarse_to_fine = "composite-coarse-to-fine"
-    sino_fourier_angles = "sino-fourier-angles"
-    octave_accurate_radios = "radios-octave-accurate"
-    read = "read"
+    fourier_angles = "fourier-angles"
+    octave_accurate_radios = "octave-accurate"
+    read = "read 'x_rotation_axis_pixel_position'"
     # alias to composite_coarse_to_fine with near mode
     near = "near"
 
     @classmethod
     def from_value(cls, value):
-        # ensure backward compatiblity with workflow defined before COR method on sinograms
-        if value == "growing-window":
+        # ensure backward compatibility with workflow defined before COR method on sinograms
+        if value in ("global_", "global"):
+            value = AxisMode.global_
+        if value == "radio-growing-window":
             _logger.warning(
-                "Axis mode requested is 'growing-window'. To insure backward compatibility replace it by 'growing-window-radios'"
+                f"Axis mode requested is '{value}'. To insure backward compatibility replace it by '{AxisMode.growing_window_radios.value}'"
             )
             value = AxisMode.growing_window_radios
-        elif value == "sliding-window":
+        elif value == "radio-sliding-window":
             _logger.warning(
-                "Axis mode requested is 'sliding-window'. To insure backward compatibility replace it by 'sliding-window-radios'"
+                f"Axis mode requested is '{value}'. To insure backward compatibility replace it by '{AxisMode.sliding_window_radios.value}'"
             )
             value = AxisMode.sliding_window_radios
+        elif value in ("radios-octave-accurate", "accurate"):
+            _logger.warning(
+                f"Axis mode requested is '{value}'. To insure backward compatibility replace it by '{AxisMode.octave_accurate_radios.value}'"
+            )
+            value = AxisMode.octave_accurate_radios
+        elif value in ("read", "read from estimated cor"):
+            value = AxisMode.read
 
         return super().from_value(value=value)
 
+    def requires_radio_indices(self) -> bool:
+        return self in (
+            AxisMode.growing_window_radios,
+            AxisMode.sliding_window_radios,
+            AxisMode.octave_accurate_radios,
+        )
+
+    def requires_sinogram_index(self) -> bool:
+        return self in (
+            AxisMode.growing_window_sinogram,
+            AxisMode.sliding_window_sinogram,
+            AxisMode.fourier_angles,
+            AxisMode.sino_coarse_to_fine,
+        )
+
 
 AXIS_MODE_METADATAS = {
     # manual
@@ -105,14 +146,16 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(),
         allows_padding=False,
         valid_inputs=(_InputType.RADIOS_X2,),
+        allows_estimated_cor_as_numerical_value=False,
     ),
     # 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,
+        allows_estimated_cor_as_numerical_value=False,
     ),
     # radio algorithm
     AxisMode.centered: AxisModeMetadata(
@@ -121,6 +164,7 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(),
         allows_padding=True,
         valid_inputs=(_InputType.RADIOS_X2,),
+        valid_sides=(Side.CENTER,),
     ),
     AxisMode.global_: AxisModeMetadata(
         lockable=True,
@@ -128,6 +172,7 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(),
         allows_padding=True,
         valid_inputs=(_InputType.RADIOS_X2,),
+        allows_estimated_cor_as_numerical_value=False,
     ),
     AxisMode.growing_window_radios: AxisModeMetadata(
         lockable=True,
@@ -135,7 +180,8 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(),
         allows_padding=True,
         valid_inputs=(_InputType.RADIOS_X2,),
-        valid_sides=("left", "right", "center", "all"),
+        valid_sides=(Side.RIGHT, Side.LEFT, Side.CENTER, Side.ALL),
+        allows_estimated_cor_as_numerical_value=False,
     ),
     AxisMode.sliding_window_radios: AxisModeMetadata(
         lockable=True,
@@ -143,15 +189,16 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(),
         allows_padding=True,
         valid_inputs=(_InputType.RADIOS_X2,),
-        valid_sides=("left", "right", "center", "near"),
+        valid_sides=(Side.RIGHT, Side.LEFT, Side.CENTER),
     ),
     AxisMode.octave_accurate_radios: AxisModeMetadata(
         lockable=True,
         tooltip="Same method as the 'accurate' octave code",
-        computing_constrains=(),
+        computing_constrains=(_Constrain.FULL_TURN,),
         allows_padding=True,
         valid_inputs=(_InputType.RADIOS_X2,),
-        valid_sides=("center",),
+        valid_sides=(Side.CENTER,),
+        allows_estimated_cor_as_numerical_value=False,
     ),
     # sinogram algorithm
     AxisMode.growing_window_sinogram: AxisModeMetadata(
@@ -160,7 +207,8 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(),
         allows_padding=True,
         valid_inputs=(_InputType.SINOGRAM,),
-        valid_sides=("left", "right", "center", "all"),
+        valid_sides=(Side.RIGHT, Side.LEFT, Side.CENTER, Side.ALL),
+        allows_estimated_cor_as_numerical_value=False,
     ),
     AxisMode.sliding_window_sinogram: AxisModeMetadata(
         lockable=True,
@@ -168,7 +216,11 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(),
         allows_padding=True,
         valid_inputs=(_InputType.SINOGRAM,),
-        valid_sides=("left", "right", "center", "near"),
+        valid_sides=(
+            Side.RIGHT,
+            Side.LEFT,
+            Side.CENTER,
+        ),
     ),
     AxisMode.sino_coarse_to_fine: AxisModeMetadata(
         lockable=True,
@@ -176,18 +228,22 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(_Constrain.FULL_TURN,),
         allows_padding=True,
         valid_inputs=(_InputType.SINOGRAM,),
+        valid_sides=(
+            Side.RIGHT,
+            Side.LEFT,
+        ),
+        allows_estimated_cor_as_numerical_value=False,
     ),
-    AxisMode.sino_fourier_angles: AxisModeMetadata(
+    AxisMode.fourier_angles: AxisModeMetadata(
         lockable=True,
         tooltip="",
         computing_constrains=(_Constrain.FULL_TURN,),
         allows_padding=True,
         valid_inputs=(_InputType.SINOGRAM,),
         valid_sides=(
-            "left",
-            "right",
-            "center",
-            "near",
+            Side.RIGHT,
+            Side.LEFT,
+            Side.CENTER,
         ),
     ),
     # coarse-to-fine algorithm
@@ -197,7 +253,11 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(_Constrain.FULL_TURN,),
         allows_padding=True,
         valid_inputs=(_InputType.COMPOSITE,),
-        valid_sides=("left", "right", "center", "near"),
+        valid_sides=(
+            Side.RIGHT,
+            Side.LEFT,
+            Side.CENTER,
+        ),
     ),
     AxisMode.near: AxisModeMetadata(
         lockable=True,
@@ -205,6 +265,10 @@ AXIS_MODE_METADATAS = {
         computing_constrains=(_Constrain.FULL_TURN,),
         allows_padding=True,
         valid_inputs=(_InputType.COMPOSITE,),
-        valid_sides=("left", "right", "center", "near"),
+        valid_sides=(
+            Side.RIGHT,
+            Side.LEFT,
+            Side.CENTER,
+        ),
     ),
 }