tomwer 2.0.1.dev0__tar.gz → 2.0.2__tar.gz

{tomwer-2.0.1.dev0/src/tomwer.egg-info → tomwer-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tomwer
-Version: 2.0.1.dev0
+Version: 2.0.2
 Summary: Tomography workflow tools
 Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 License: MIT

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/orangecontrib/tomwer/widgets/reconstruction/MultiCoROW.py

@@ -208,6 +208,9 @@ class MultiCoROW(
         """
         if scan is None:
             return
+        if not _check_helical(scan=scan, process=self):
+            return
+
         if scan.cor_params is None:
             scan.cor_params = CoRParams()
         if scan.multicor_params is None:
@@ -446,3 +449,26 @@ class MultiCoROW(
         The overwrite of `handleNewSignals` is to make sure we won't trigger one extra time the widget.
         """
         pass
+
+
+def _check_helical(scan: TomwerScanBase, process: MultiCoROW) -> bool:
+    if not scan._is_helical():
+        return True
+
+    error_msg = (
+        f"scan {scan} is a helical scan. Multi-cor doesn't work with helical scans."
+    )
+    _logger.error(error_msg)
+
+    msg = qt.QMessageBox(process)
+    msg.setIcon(qt.QMessageBox.Warning)
+    msg.setText(error_msg)
+    msg.show()
+
+    ProcessManager().notify_dataset_state(
+        dataset=scan,
+        process=process,
+        details=error_msg,
+        state=DatasetState.FAILED,
+    )
+    return False

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/orangecontrib/tomwer/widgets/visualization/SampleMovedOW.py

@@ -75,7 +75,7 @@ class SampleMovedOW(widget.OWBaseWidget, openclass=True):
         assert isinstance(scan, TomwerScanBase)
         if os.path.isdir(scan.path):
             self._scanNameQLabel.setText(os.path.basename(scan.path))
-            rawSlices = scan.get_proj_angle_url()
+            rawSlices = dict(scan.get_proj_angle_url())
 
             self._mainWidget.clearOnLoadActions()
             self._mainWidget.setImages(rawSlices)

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/app/samplemoved.py

@@ -82,7 +82,7 @@ def main(argv):
     options.scan_path = options.scan_path.rstrip(os.path.sep)
 
     scan = ScanFactory.create_scan_object(options.scan_path, options.entry)
-    rawSlices = scan.get_proj_angle_url()
+    rawSlices = dict(scan.get_proj_angle_url())
     widget.setImages(rawSlices)
     # TODO: set back the flat field correction
     splash.finish(widget)

tomwer-2.0.2/src/tomwer/core/_typing.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from pint import Quantity
+
+from typing import Any, TypeAlias
+from numpy.typing import NDArray
+
+ImageType: TypeAlias = NDArray[Any]
+PixelQuantity: TypeAlias = Quantity
+
+Position: TypeAlias = tuple[float | None, float | None, float | None]
+"""(z, y, x) translation in meter. Any element is None if unresolved / not provided by the scan."""
+
+PositionInPixel: TypeAlias = tuple[int | None, int | None, int | None]
+"""(z, y, x) translation in pixel. Any element is None if unresolved / not provided by the scan."""

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/core/drac/rawdataset.py

@@ -85,7 +85,7 @@ class DracRawDataset(DracDatasetBase):
         if self.raw_flats_required and len(scan.flats) > 0:
             data_to_save["flat"] = next(iter(scan.flats.values()))
         if self.raw_projections_required:
-            projections = scan.projections_with_angle()
+            projections = dict(scan.projections_with_angle())
             picked_angles = DracRawDataset.select_angles(
                 angles_list=sorted(projections.keys()),
                 each_angle=self.raw_projections_each,

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/core/reconstruction/common/NabuBaseReconstructor.py

@@ -62,6 +62,8 @@ class NabuBaseReconstructor:
 
     EXPECTS_SINGLE_SLICE = True
 
+    _NABU_PROCESS_PYTHON_MODULE = settings.NABU_FULL_FIELD_APP_PATH
+
     def __init__(
         self,
         scan: TomwerScanBase,
@@ -229,7 +231,7 @@ class NabuBaseReconstructor:
         command = (
             sys.executable,
             "-m",
-            settings.NABU_FULL_FIELD_APP_PATH,
+            self._NABU_PROCESS_PYTHON_MODULE,
             f"{shlex.quote(conf_file)}",  # adding ' around file name allows to handle config file with spaces
             "--logfile",
             f"{shlex.quote(log_file)}",
@@ -326,7 +328,7 @@ class NabuBaseReconstructor:
         job = SBatchScriptJob(
             slurm_config=cluster_config,
             script=(
-                f"python3 -m {settings.NABU_FULL_FIELD_APP_PATH} '{conf_file}' --logfile='{log_file}' --gpu_mem_fraction={gpu_mem_fraction} --cpu_mem_fraction={cpu_mem_fraction}",
+                f"python3 -m {self._NABU_PROCESS_PYTHON_MODULE} '{conf_file}' --logfile='{log_file}' --gpu_mem_fraction={gpu_mem_fraction} --cpu_mem_fraction={cpu_mem_fraction}",
             ),
             script_path=filter_esrf_mounting_points(
                 os.path.join(self.scan.resolved_path, "slurm_scripts", script_name)

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/core/reconstruction/common/settings.py

@@ -16,6 +16,8 @@ NABU_TOMWER_SERVING_HATCH = "nabu_tomwer_serving_hatch.h5"
 
 NABU_FULL_FIELD_APP_PATH = "nabu.app.reconstruct"
 
+NABU_HELICAL_APP_PATH = "nabu.app.reconstruct_helical"
+
 NABU_CAST_APP_PATH = "nabu.app.cast_volume"
 
 NABU_MULTICOR_PATH = "nabu.app.multicor"

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/core/reconstruction/common/test/test_nabu_utils.py

@@ -9,6 +9,7 @@ from tomwer.core.reconstruction.common.utils import (
 )
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.utils.scanutils import MockNXtomo
 
 from tomwer.core.volume.edfvolume import EDFVolume
 from tomwer.core.volume.hdf5volume import HDF5Volume
@@ -16,16 +17,29 @@ from tomwer.core.reconstruction.common.utils import (
     get_default_output_volume_for_tiff_3d,
 )
 
-_scans = (
-    NXtomoScan(
-        scan="/my_scan_file.nx",
-        entry="entry_test",
-    ),
-    EDFTomoScan("/my_scan_folder"),
-)
+
+@pytest.fixture(params=("nx", "edf"))
+def scan(request, tmp_path):
+    """
+    provide a scan backed by a real file / folder so properties requiring
+    file access (like dim_2 or _is_helical, which needs a z translation) can be resolved.
+    """
+    if request.param == "nx":
+        return MockNXtomo(
+            scan_path=str(tmp_path / "nx_scan"),
+            n_ini_proj=2,
+            n_proj=2,
+            n_alignement_proj=0,
+            create_final_flat=False,
+            create_ini_dark=True,
+            create_ini_flat=True,
+            n_refs=1,
+            dim=2048,
+        ).scan
+    else:
+        return EDFTomoScan(str(tmp_path / "my_scan_folder"))
 
 
-@pytest.mark.parametrize("scan", _scans)
 @pytest.mark.parametrize("axis", ("YZ", "XZ", "XY"))
 def test_get_recons_volume_identifier(scan, axis, tmp_path):
     """
@@ -101,7 +115,6 @@ def test_get_recons_volume_identifier(scan, axis, tmp_path):
     )
 
 
-@pytest.mark.parametrize("scan", _scans)
 def test_get_multi_cor_recons_volume_identifier(scan):
     """
     test the get_multi_cor_recons_volume_identifier function

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/core/reconstruction/common/utils.py

@@ -244,6 +244,8 @@ def nabu_std_err_has_error(errs: bytes | None):
             or "Remark: The" in line
             or "int x_stop_other = other_x_range.y;" in line
             or "int y_stop_other = other_y_range.y;" in line
+            or "------------------" in line
+            or "Helical reconstruction is a PROTOTYPE" in line
         )
 
     if errs is None:
@@ -251,7 +253,6 @@ def nabu_std_err_has_error(errs: bytes | None):
     else:
         for line in errs.decode("UTF-8").split("\n"):
             if not ignore(line):
-                print("\n\nline is", line)
                 return True
     return False
 
@@ -272,6 +273,13 @@ def slice_index_to_int(
             # backward compatibility in the case the scan is not provided. Should not happen anymore
             _logger.warning("Scan not provided. Consider the 2048 width detector")
             return 2047
+        elif scan._is_helical():
+            z_pixel_range = scan._projections_z_pixel_range()
+            if z_pixel_range is None:
+                _logger.error("Unable to determine z pixel range. Define a default one")
+                return 2047
+            z_height_covered_by_helice = z_pixel_range[1] - z_pixel_range[0]
+            return z_height_covered_by_helice + scan.dim_2 - 1
         elif scan.dim_2 is not None:
             return scan.dim_2 - 1
         else:
@@ -286,7 +294,16 @@ def slice_index_to_int(
             # default middle.
             return 1024
         elif axis is NabuPlane.XY:
-            if scan.dim_2 is None:
+            if scan._is_helical():
+                z_pixel_range = scan._projections_z_pixel_range()
+                if z_pixel_range is None:
+                    _logger.error(
+                        "Unable to determine z pixel range. Define a default one"
+                    )
+                    return 1024
+
+                return (z_pixel_range[1] - z_pixel_range[0]) // 2
+            elif scan.dim_2 is None:
                 _logger.warning("unable to get dim size, guess this is 2048 height")
                 return 1024
             else:

tomwer-2.0.2/src/tomwer/core/reconstruction/cor/anglemode.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import numpy
+from enum import Enum as _Enum
+from tomwer.core.reconstruction.cor.cor_resource import (
+    CoRResource,
+)
+import logging
+from silx.io.url import DataUrl
+
+_logger = logging.getLogger(__name__)
+
+
+class CoRAngleMode(_Enum):
+    """Existing modes for computing the Center of Rotation (CoR)"""
+
+    use_0_180 = "0-180"
+    use_90_270 = "90-270"
+    manual_selection = "manual"
+
+
+def find_angles_pair(
+    mode: CoRAngleMode,
+    projection_angles: list[tuple[float, DataUrl]],
+    is_helical: bool = False,
+) -> tuple[CoRResource | None, CoRResource | None]:
+    """
+    Find a pair of opposite projections for CoR computation.
+
+    :param mode: Angle selection mode. Either a `CorAngleMode` or a value convertible to it.
+    :param projection_angles: List of (projection angle in degrees, corresponding data URL) pairs.
+    :param is_helical: If True, `projection_angles` can contain several projections sharing the
+        same angle modulo 360 (unwrapped angles spanning several turns). In that case the
+        projection closest to the middle of the full (unwrapped) angular range is preferred.
+
+    :return: The two selected projections as `CoRResource` instances, or `(None, None)` if no suitable pair can be found.
+    """
+    mode = CoRAngleMode(mode)
+
+    urls_by_angle = dict(projection_angles)
+    angles = numpy.array(tuple(urls_by_angle.keys()))
+
+    if len(angles) < 2:
+        _logger.warning("less than two angles found. Unable to get opposite angles")
+        return None, None
+
+    def mod_angle(value):
+        return value % 360
+
+    initial_angle = mod_angle(angles[0])
+    if is_helical:
+        # find the angle closest to the middle of the full angular range
+        # Note: angles are expected to be in degrees, and already unwrap
+        initial_angle = pick_angle_in_middle_range(angles, initial_angle)
+        # restrict the search to angles within 200 degree of the selected
+        # reference, to avoid matching the same (mod 360) angle from a much
+        # farther turn.
+        # Note: initially we were considering filtering by the z value
+        # and keep only projections that cover a part of the z covered by the original frame.
+        # but this is simpler and more robust, and should work in all cases.
+        angles_range_epsilon = 10.0  # degrees
+        angles_range_threshold = 180.0 + angles_range_epsilon
+        angles = angles[numpy.abs(angles - initial_angle) <= angles_range_threshold]
+
+    if mode in (CoRAngleMode.use_0_180, CoRAngleMode.manual_selection):
+        if is_helical:
+            target_angle_pair = (initial_angle, initial_angle + 180.0)
+        else:
+            target_angle_pair = (initial_angle, mod_angle(initial_angle + 180.0))
+    elif mode is CoRAngleMode.use_90_270:
+        if is_helical:
+            target_angle_pair = (initial_angle + 90.0, initial_angle + 270.0)
+        else:
+            target_angle_pair = (
+                mod_angle(initial_angle + 90.0),
+                mod_angle(initial_angle + 270.0),
+            )
+    else:
+        raise ValueError(f"{mode} is not handled")
+
+    def _circular_distance(angles: numpy.ndarray, target: float) -> numpy.ndarray:
+        # result in [0, 180]
+        return numpy.abs(((angles - target + 180.0) % 360.0) - 180.0)
+
+    def find_nearest(angles: numpy.ndarray, angle: float):
+        dist = _circular_distance(angles, angle)
+        idx = dist.argmin()
+        if isinstance(idx, numpy.ndarray):
+            idx = idx[0]
+        return angles[idx]
+
+    nearest_c1 = find_nearest(angles=angles, angle=target_angle_pair[0])
+    nearest_c2 = find_nearest(angles=angles, angle=target_angle_pair[1])
+    return (
+        CoRResource(urls_by_angle[nearest_c1], angle=nearest_c1),
+        CoRResource(urls_by_angle[nearest_c2], angle=nearest_c2),
+    )
+
+
+def pick_angle_in_middle_range(
+    angles: numpy.ndarray, target_angle: float, anchor_tolerance_deg=0.2
+) -> float:
+    """
+    Pick the angle closest to the middle of the full angular range.
+
+    :param angles: Array of angles in degrees (unwrapped, spanning several turns).
+    :param target_angle: The target angle to consider (in degrees).
+    :return: The angle closest to the middle of the full angular range.
+    """
+    dist = numpy.abs(((angles - target_angle + 180.0) % 360.0) - 180.0)
+    anchor_candidates = numpy.where(dist <= anchor_tolerance_deg)[0]
+    if len(anchor_candidates) == 0:
+        anchor_candidates = numpy.array([int(dist.argmin())])
+    anchor_index = int(anchor_candidates[len(anchor_candidates) // 2])
+    return angles[anchor_index]

tomwer-2.0.2/src/tomwer/core/reconstruction/cor/cor_resource.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import logging
+import numpy
+from nabu.preproc.phase import PaganinPhaseRetrieval
+from tomoscan.esrf.scan.utils import get_data
+
+from silx.io.url import DataUrl
+
+_logger = logging.getLogger(__name__)
+
+
+class CoRResource:
+    """
+    Helper for picking resource for Cor search.
+
+    Associates a projection url with its raw, normalized and Paganin-filtered data.
+    The raw / normalized / Paganin data are lazily computed and cached on the
+    instance the first time they are requested.
+
+    :param url: url of the projection this resource points to. `None` if the
+        resource is not yet bound to any projection.
+    :param angle: rotation angle (in degree) of the projection, if known.
+    """
+
+    _PAGANIN_CONFIG = {"distance": 100e-3, "energy": 35, "delta_beta": 1e3}
+    """Paganin configuration for axis calculation. To simplify we have only one
+    static configuration for now. Otherwise complicate stuff"""
+
+    def __init__(self, url: None | DataUrl, angle: float | None = None):
+        assert url is None or isinstance(url, DataUrl)
+        assert url is None or url.is_valid()
+        self.__url = url
+        self.__raw_data = None
+        self.__norme_data = None
+        self.__norm_paganin = None
+        self.__angle = angle
+        self.__position_px = (None, None, None)
+
+    def __str__(self):
+        return f"{type(self)}, url: {self.__url.path() if self.__url else None}"
+
+    @property
+    def url(self):
+        return self.__url
+
+    @property
+    def data(self):
+        """Raw projection data, read from `url` and cached on first access.
+
+        :return: 2D numpy.array, or `None` if `url` is `None`
+        """
+        if self.__url is None:
+            return None
+        if self.__raw_data is None:
+            self.__raw_data = get_data(self.url)
+        return self.__raw_data
+
+    @data.setter
+    def data(self, data):
+        """Override the cached raw data (e.g. to inject already-loaded data
+        or to force a reload by setting it back to `None`)."""
+        self.__raw_data = data
+
+    @property
+    def normalized_data(self):
+        """Flat-field corrected (and optionally log-transformed) data, as
+        computed by the last call to `normalize_data`. `None` if
+        `normalize_data` has not been called yet.
+        """
+        return self.__norme_data
+
+    @normalized_data.setter
+    def normalized_data(self, data):
+        """Override the cached normalized data."""
+        self.__norme_data = data
+
+    @property
+    def angle(self) -> float | None:
+        return self.__angle
+
+    @property
+    def position_px(self) -> tuple[float | None, float | None, float | None]:
+        """(z, y, x) pixel position of the projection, as set by the last call
+        to `load_position`. Each component is `None` if `load_position` has
+        not been called yet, or if that component could not be determined.
+        """
+        return self.__position_px
+
+    def set_position(self, scan) -> None:
+        """Look up and cache this resource's (z, y, x) pixel position, by
+        matching the `TomoFrame` sharing this resource's `url` in `scan.frames`
+        and converting its translation (in metric unit) to pixel using
+        `scan.pixel_size`.
+
+        Silently leaves the position(s) to `None` if `scan` doesn't expose
+        `frames` / `pixel_size` (e.g. non-NXtomo scans), if no frame matches
+        this resource's `url`, or if a given translation is not defined on
+        the matching frame.
+
+        :param scan: scan the projection belongs to.
+        """
+        from tomwer.core.scan.nxtomoscan import NXtomoScan  # avoid cyclci import
+
+        self.__position_px = (None, None, None)
+        if self.__url is None:
+            return
+
+        if not isinstance(scan, NXtomoScan):
+            return
+
+        frames = scan.frames
+        pixel_size = scan.pixel_size
+        if not frames or not pixel_size:
+            return
+        for frame in frames:
+            if frame.url == self.__url:
+                translations = (
+                    frame.z_translation,
+                    frame.y_translation,
+                    frame.x_translation,
+                )
+                self.__position_px = tuple(
+                    translation / pixel_size if translation is not None else None
+                    for translation in translations
+                )
+                break
+
+    def normalize_data(self, scan, log_):
+        """Compute (and cache) the flat-field corrected data for axis calculation.
+
+        :param scan: scan the projection belongs to, used to apply flat-field
+            correction. Must be an instance of `TomwerScanBase`.
+        :param log_: if True, apply `-log` on the flat-field corrected data
+            (after clipping values <= 1 to 1) instead of just replacing NaNs
+            with the data maximum.
+        :return: the normalized data (2D numpy.array), or `None` if `url` is `None`
+        :raises TypeError: if `scan` is not a `TomwerScanBase` instance
+        """
+        from tomwer.core.scan.scanbase import TomwerScanBase  # avoid cyclci import
+
+        if not isinstance(scan, TomwerScanBase):
+            raise TypeError(
+                f"scan is expected to be an instance of {TomwerScanBase}. {type(scan)} provided"
+            )
+        if self.__url is None:
+            return None
+        else:
+            self.__norme_data = scan.data_flat_field_correction(data=self.data)
+            if log_ is True:
+                self.__norme_data[numpy.isnan(self.__norme_data)] = (
+                    self.__norme_data.max()
+                )
+                if self.__norme_data.max() < 0:
+                    _logger.error("max data value < 0 unable to compute log")
+                else:
+                    try:
+                        data = self.__norme_data
+                        data[data <= 1] = 1
+                        self.__norme_data = -numpy.log(data)
+                    except Exception as e:
+                        _logger.error("Fail to apply log on radio" + e)
+            else:
+                self.__norme_data[numpy.isnan(self.__norme_data)] = (
+                    self.__norme_data.min()
+                )
+
+        return self.__norme_data
+
+    @property
+    def normalized_data_paganin(self):
+        """`normalized_data` filtered by a Paganin phase retrieval
+        (using `CoRResource._PAGANIN_CONFIG`), computed and cached on first access.
+
+        :return: data processed by the Paganin phase retrieval, or `None` if
+            `url` is `None`
+        :raises ValueError: if `normalized_data` is `None` (`normalize_data`
+            must be called first)
+        """
+        if self.__url is None:
+            return None
+        if self.__norm_paganin is None:
+            if self.normalized_data is None:
+                raise ValueError("data should be normalized before applying " "paganin")
+            else:
+                data = self.normalized_data
+                phase_retrieval = PaganinPhaseRetrieval(
+                    data.shape, **CoRResource._PAGANIN_CONFIG
+                )
+                self.__norm_paganin = phase_retrieval.apply_filter(data)
+        return self.__norm_paganin
+
+    @normalized_data_paganin.setter
+    def normalized_data_paganin(self, data):
+        """Override the cached Paganin-filtered data."""
+        self.__norm_paganin = data
+
+    def __eq__(self, other):
+        """Two `CoRResource` are equal if they point to the same `url`
+        (`angle` and cached data are ignored)."""
+        if not isinstance(other, CoRResource):
+            return False
+        if self.url is None and other.url is None:
+            return True
+        elif self.url is None or other.url is None:
+            return False
+        else:
+            return self.url == other.url

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/core/reconstruction/slice/NabuSliceMode.py

@@ -24,7 +24,17 @@ class NabuSliceMode(_Enum):
             if mode == mode.MIDDLE:
                 axis = NabuPlane.from_axis(axis)
                 if axis is NabuPlane.XY:
-                    n_slice = scan.dim_2 or 2048
+                    if (
+                        scan._is_helical()
+                        and scan._projections_z_pixel_range() is not None
+                    ):
+                        range_coverred_by_helice = (
+                            scan._projections_z_pixel_range()[1]
+                            - scan._projections_z_pixel_range()[0]
+                        )
+                        n_slice = range_coverred_by_helice + scan.dim_2
+                    else:
+                        n_slice = scan.dim_2 or 2048
                 elif axis in (NabuPlane.YZ, NabuPlane.XZ):
                     n_slice = scan.dim_1 or 2048
                 else:

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/core/reconstruction/slice/SingleSliceRunner.py

@@ -287,3 +287,7 @@ class SingleSliceRunner(NabuBaseReconstructor):
             ctf=ctf,
             axis=axis,
         )
+
+
+class SingleSliceRunnerHelical(SingleSliceRunner):
+    _NABU_PROCESS_PYTHON_MODULE = nabu_settings.NABU_HELICAL_APP_PATH

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/core/reconstruction/slice/SliceInterpreter.py

@@ -56,14 +56,27 @@ class SliceInterpreter:
                 )
             )
 
+            max_axis_1_size = scan.dim_1  # y
+            max_axis_2_size = scan.dim_1  # x
+            if scan._is_helical():
+                z_pixel_range = scan._projections_z_pixel_range()
+                if z_pixel_range is None:
+                    _logger.error(
+                        "Unable to determine z pixel range. Define a default one (2048)"
+                    )
+                range_covered_by_helice = z_pixel_range[1] - z_pixel_range[0]
+                max_axis_0_size = range_covered_by_helice + scan.dim_2
+            else:
+                max_axis_0_size = scan.dim_2  # z
+
             scalar_slices = list(
                 filter(
                     lambda slice_index: cls.filter_slice(
                         slice_index=int(slice_index),
                         axis=reconstruction_axis,
-                        max_axis_0_size=scan.dim_2,  # z
-                        max_axis_1_size=scan.dim_1,  # y
-                        max_axis_2_size=scan.dim_1,  # x
+                        max_axis_0_size=max_axis_0_size,  # z
+                        max_axis_1_size=max_axis_1_size,  # y
+                        max_axis_2_size=max_axis_2_size,  # x
                         invalid_slice_callback=invalid_slice_callback,
                         scan_id=scan.get_identifier().short_description(),
                     ),

{tomwer-2.0.1.dev0 → tomwer-2.0.2}/src/tomwer/core/reconstruction/slice/slices.py

@@ -16,7 +16,10 @@ from tomwer.core.reconstruction.common.nabucommon import (
     ResultsRun,
 )
 from tomwer.core.reconstruction.common.plane import NabuPlane
-from tomwer.core.reconstruction.slice.SingleSliceRunner import SingleSliceRunner
+from tomwer.core.reconstruction.slice.SingleSliceRunner import (
+    SingleSliceRunner,
+    SingleSliceRunnerHelical,
+)
 from tomwer.core.reconstruction.common.target import Target
 from tomwer.core.reconstruction.utils.cor import copy_cor
 from tomwer.core.scan.scanbase import TomwerScanBase
@@ -234,7 +237,13 @@ def run_single_slice_reconstruction(
     else:
         process_name = ""
 
-    slice_reconstructor = SingleSliceRunner(
+    if scan._is_helical():
+        constructor = SingleSliceRunnerHelical
+        _logger.warning("Helical use case found. Reminder: this is still a prototype.")
+    else:
+        constructor = SingleSliceRunner
+
+    slice_reconstructor = constructor(
         scan=scan,
         config=nabu_config,
         dry_run=dry_run,