nabu 2024.2.14__py3-none-any.whl → 2025.1.0__py3-none-any.whl

nabu/reconstruction/fbp_base.py

@@ -1,3 +1,4 @@
+import warnings
 import numpy as np
 from ..utils import updiv, nextpow2, convert_index, deprecation_warning
 from ..processing.processing_base import ProcessingBase
@@ -6,6 +7,19 @@ from .sinogram import SinoMult
 from .sinogram import get_extended_sinogram_width
 
 
+def rot_center_is_in_middle_of_roi(rot_center, roi, tol=2.0):
+    # NB. tolerance should be at least 2,
+    # because in halftomo the extended sinogram width is 2*sino_width - int(2 * XXXX)
+    #   (where  XXX depends on whether the CoR is on the left or on the right)
+    #  because of the int(2 * stuff), we can have a jump of at most two pixels.
+    #
+    start_x, end_x, start_y, end_y = roi
+    return (
+        abs((start_x + end_x - 1) / 2 - rot_center) - 0.5 < tol
+        and abs((start_y + end_y - 1) / 2 - rot_center) - 0.5 < tol
+    )
+
+
 class BackprojectorBase:
     """
     Base class for backprojectors.
@@ -22,6 +36,7 @@ class BackprojectorBase:
         "scale_factor": None,
         "filter_cutoff": 1.0,
         "outer_circle_value": 0.0,
+        "crop_filtered_data": True,
     }
 
     kernel_filename = None
@@ -82,7 +97,7 @@ class BackprojectorBase:
         backend_options: dict, optional
             OpenCL/Cuda options passed to the OpenCLProcessing or CudaProcessing class.
 
-        Other parameters
+        Other Parameters
         -----------------
         extra_options: dict, optional
             Dictionary with a set of advanced options. The default are the following:
@@ -160,9 +175,6 @@ class BackprojectorBase:
         self.axis_pos = self.rot_center
         self._set_angles(angles, n_angles)
         self._set_slice_roi(slice_roi)
-        #
-        # offset = start - move
-        # move = 0 if not(centered_axis) else start + (n-1)/2. - c
         if self.extra_options["centered_axis"]:
             self.offsets = {
                 "x": self.rot_center - (self.n_x - 1) / 2.0,
@@ -208,6 +220,19 @@ class BackprojectorBase:
         end_x = convert_index(end_x, self.n_x, self.n_x)
         end_y = convert_index(end_y, self.n_y, self.n_y)
         self.slice_shape = (end_y - start_y, end_x - start_x)
+        if self.extra_options["centered_axis"] and not (
+            rot_center_is_in_middle_of_roi(self.rot_center, (start_x, end_x, start_y, end_y))
+        ):
+            warnings.warn(
+                "Using 'centered_axis' when doing a non-centered ROI reconstruction might have side effects: 'start_xy' and 'end_xy' have a different meaning",
+                RuntimeWarning,
+            )
+            # self.extra_options["centered_axis"] = False
+        if self.extra_options.get("clip_outer_circle", False) and (
+            start_x > 2 or start_y > 2 or abs(end_y - self.n_y) > 2 or abs(end_y - self.n_y) > 2
+        ):
+            warnings.warn("clip_outer_circle is not supported when doing RoI reconstruction", RuntimeWarning)
+            self.extra_options["clip_outer_circle"] = False
         self.n_x = self.slice_shape[-1]
         self.n_y = self.slice_shape[-2]
         self.offsets = {"x": start_x, "y": start_y}
@@ -245,6 +270,11 @@ class BackprojectorBase:
         if filter_name in ["None", "none"]:
             self.sino_filter = None
             return
+
+        # TODO
+        if not (self.extra_options.get("crop_filtered_data", True)):
+            warnings.warn("crop_filtered_data = False is not supported for FBP yet", RuntimeWarning)
+        #
         sinofilter_other_kwargs = self._get_filter_init_extra_options()
         self.sino_filter = self.SinoFilterClass(
             self.sino_shape,
@@ -355,7 +385,7 @@ class BackprojectorBase:
 
     def backproj(self, sino, output=None, do_checks=True):
         if self.halftomo and self.rot_center < self.dwidth:
-            self.sino_mult.prepare_sino(sino)
+            sino = self.sino_mult.prepare_sino(sino)
         self._transfer_to_texture(sino)
         d_slice = self._set_output(output, check=do_checks)
         self._set_kernel_slice_arg(d_slice)
@@ -377,6 +407,7 @@ class BackprojectorBase:
             # if a new device array was allocated for sinogram, then the filtering can overwrite it,
             # since it won't affect user argument
             if id(d_sino) != id(sino):
+                # if id(d_sino) != id(sino) and self.extra_options.get("crop_filtered_data", True):
                 filt_kwargs = {"output": d_sino}
             #
             sino_to_backproject = self.sino_filter(d_sino, **filt_kwargs)

nabu/reconstruction/filtering.py

@@ -5,15 +5,6 @@ from silx.image.tomography import compute_fourier_filter, get_next_power
 from ..processing.padding_base import PaddingBase
 from ..utils import check_supported, get_num_threads
 
-# # COMPAT.
-# from .filtering_cuda import CudaSinoFilter
-
-# SinoFilter = deprecated_class(
-#     "From version 2023.1, 'filtering_cuda.CudaSinoFilter' should be used instead of 'filtering.SinoFilter'. In the future, 'filtering.SinoFilter' will be a numpy-only class.",
-#     do_print=True,
-# )(CudaSinoFilter)
-# #
-
 
 class SinoFilter:
     available_filters = [
@@ -44,11 +35,44 @@ class SinoFilter:
         sino_shape,
         filter_name=None,
         padding_mode="zeros",
+        crop_filtered_data=True,
         extra_options=None,
     ):
+        """
+        Initialize a SinoFilter instance.
+
+        Parameters
+        ----------
+        sino_shape: tuple
+            Shape of sinogram, in the form (n_angles, detector_width) or (n_sinos, n_angles, detector_width)
+        filter_name: str, optional
+            Name of the filter. Default is ram-lak.
+        padding_mode: str, optional
+            How to pad the data prior to filtering. Default is zero-padding, corresponding to linear convolution with the filter kernel.
+            In practice this value is often set to "edges" for interior tomography.
+        crop_filtered_data: bool, optional
+            Whether to crop the final, filtered sinogram. Default is True. See notes below.
+        extra_options: dict, optional
+            Dictionary of advanced extra options.
+
+        Notes
+        -----
+        Sinogram filtering done in the Filtered Back-Projection (FBP) method consists, in theory, in applying a high-pass filter
+        to the sinogram prior to backprojection. This high-pass filter is normally the Ramachandran-Lakshminarayanan (Ram-Lak) filter
+        yielding a close-to-ideal reconstruction (see Natterer's "Mathematical methods in image reconstruction").
+        As the filter kernel has a large extent in spatial domain, it's best performed in Fourier domain via the Fourier-convolution theorem.
+        Filtering in Fourier domain should be done with a data padded to at least twice its size.
+        Zero-padding should be used for mathematical correctness (so that multiplication in Fourier domain corresponds to an actual linear convolution).
+        However if the sinogram does not decay to "zero" near the edges (i.e in interior tomography), padding with zeros usually gives artefacts after filtering.
+        In this case, padding with edges is preferred (corresponding to a convolution with the "edges" extension mode).
+
+        After inverse Fourier transform, the (padded and filtered) data is cropped back to its original size.
+        In some cases, it's preferable to keep the data un-cropped for further processing.
+        """
+
         self._init_extra_options(extra_options)
         self._set_padding_mode(padding_mode)
-        self._calculate_shapes(sino_shape)
+        self._calculate_shapes(sino_shape, crop_filtered_data)
         self._init_fft()
         self._allocate_memory()
         self._compute_filter(filter_name)
@@ -67,7 +91,7 @@ class SinoFilter:
         check_supported(padding_mode, self.available_padding_modes, "padding mode")
         self.padding_mode = padding_mode
 
-    def _calculate_shapes(self, sino_shape):
+    def _calculate_shapes(self, sino_shape, crop_filtered_data):
         self.ndim = len(sino_shape)
         if self.ndim == 2:
             n_angles, dwidth = sino_shape
@@ -90,6 +114,11 @@ class SinoFilter:
         self.pad_left = (self.dwidth_padded - self.dwidth) // 2
         self.pad_right = self.dwidth_padded - self.dwidth - self.pad_left
 
+        self.crop_filtered_data = crop_filtered_data
+        self.output_shape = self.sino_shape
+        if not (self.crop_filtered_data):
+            self.output_shape = self.sino_padded_shape
+
     def _init_fft(self):
         pass
 
@@ -147,19 +176,16 @@ class SinoFilter:
         if arr.shape != self.sino_shape:
             raise ValueError("Expected sinogram shape %s, got %s" % (self.sino_shape, arr.shape))
 
-    def filter_sino(self, sino, output=None, no_output=False):
+    def filter_sino(self, sino, output=None):
         """
         Perform the sinogram siltering.
 
         Parameters
         ----------
-        sino: numpy.ndarray or pycuda.gpuarray.GPUArray
+        sino: array
             Input sinogram (2D or 3D)
-        output: numpy.ndarray or pycuda.gpuarray.GPUArray, optional
+        output: array, optional
             Output array.
-        no_output: bool, optional
-            If set to True, no copy is be done. The resulting data lies
-            in self.d_sino_padded.
         """
         self._check_array(sino)
         # sino_padded = np.pad(
@@ -169,16 +195,21 @@ class SinoFilter:
         sino_padded_f = rfft(sino_padded, axis=1, workers=get_num_threads(self.extra_options["fft_threads"]))
         sino_padded_f *= self.filter_f
         sino_filtered = irfft(sino_padded_f, axis=1, workers=get_num_threads(self.extra_options["fft_threads"]))
+
         if output is None:
-            res = np.zeros(self.sino_shape, dtype=np.float32)
+            if not (self.crop_filtered_data):
+                # No need to allocate extra memory here
+                return sino_filtered
+            res = np.zeros(self.output_shape, dtype=np.float32)
         else:
             res = output
-        if self.ndim == 2:
-            # res[:] = sino_filtered[:, : self.dwidth]  # pylint: disable=E1126 # ?!
-            res[:] = sino_filtered[:, self.pad_left : -self.pad_right]  # pylint: disable=E1126 # ?!
+
+        if self.crop_filtered_data:
+            # res[:] = sino_filtered[..., : self.dwidth]  # pylint: disable=E1126 # ?!
+            res[:] = sino_filtered[..., self.pad_left : -self.pad_right]  # pylint: disable=E1126 # ?!
         else:
-            # res[:] = sino_filtered[:, :, : self.dwidth]  # pylint: disable=E1126 # ?!
-            res[:] = sino_filtered[:, :, self.pad_left : -self.pad_right]  # pylint: disable=E1126 # ?!
+            res[:] = sino_filtered[:]
+
         return res
 
     __call__ = filter_sino
@@ -191,6 +222,7 @@ def filter_sinogram(
     padding_mode="constant",
     normalize=True,
     filter_cutoff=1.0,
+    crop_filtered_data=True,
     **padding_kwargs,
 ):
     """
@@ -228,6 +260,8 @@ def filter_sinogram(
     fourier_filter = fourier_filter[: padded_width // 2 + 1]  # R2C
     sino_f = rfft(sinogram_padded, axis=1)
     sino_f *= fourier_filter
-    # sino_filtered = irfft(sino_f, axis=1)[:, :width]  # pylint: disable=E1126 # ?!
-    sino_filtered = irfft(sino_f, axis=1)[:, pad_left:-pad_right]  # pylint: disable=E1126 # ?!
+    sino_filtered = irfft(sino_f, axis=1)
+    if crop_filtered_data:
+        # sino_filtered = sino_filtered[:, :width]  # pylint: disable=E1126 # ?!
+        sino_filtered = sino_filtered[:, pad_left:-pad_right]  # pylint: disable=E1126 # ?!
     return sino_filtered

nabu/reconstruction/filtering_cuda.py

@@ -1,25 +1,33 @@
 import numpy as np
 from ..cuda.processing import CudaProcessing
-from ..utils import get_cuda_srcfile
+from ..utils import docstring, get_cuda_srcfile
 from ..processing.padding_cuda import CudaPadding
 from ..processing.fft_cuda import get_fft_class
 from .filtering import SinoFilter
 
 
 class CudaSinoFilter(SinoFilter):
-    default_extra_options = {**SinoFilter.default_extra_options, **{"fft_backend": "vkfft"}}
+    default_extra_options = {**SinoFilter.default_extra_options, "fft_backend": "vkfft"}
 
+    @docstring(SinoFilter)
     def __init__(
         self,
         sino_shape,
         filter_name=None,
         padding_mode="zeros",
+        crop_filtered_data=True,
         extra_options=None,
         cuda_options=None,
     ):
         self._cuda_options = cuda_options or {}
         self.cuda = CudaProcessing(**self._cuda_options)
-        super().__init__(sino_shape, filter_name=filter_name, padding_mode=padding_mode, extra_options=extra_options)
+        super().__init__(
+            sino_shape,
+            filter_name=filter_name,
+            padding_mode=padding_mode,
+            crop_filtered_data=crop_filtered_data,
+            extra_options=extra_options,
+        )
         self._init_kernels()
 
     def _init_fft(self):
@@ -60,25 +68,12 @@ class CudaSinoFilter(SinoFilter):
         )
 
     def filter_sino(self, sino, output=None):
-        """
-        Perform the sinogram siltering.
-
-        Parameters
-        ----------
-        sino: numpy.ndarray or pycuda.gpuarray.GPUArray
-            Input sinogram (2D or 3D)
-        output: pycuda.gpuarray.GPUArray, optional
-            Output array.
-        no_output: bool, optional
-            If set to True, no copy is be done. The resulting data lies
-            in self.d_sino_padded.
-        """
         self._check_array(sino)
         if not (isinstance(sino, self.cuda.array_class)):
             sino = self.cuda.set_array("sino", sino)
         elif not (sino.flags.c_contiguous):
             # Transfer the device array into another, c-contiguous, device array
-            # We can throw an error as well in this case, but often we so something like fbp(radios[:, i, :])
+            # We can throw an error as well in this case, but often we do something like fbp(radios[:, i, :])
             sino_tmp = self.cuda.allocate_array("sino_contig", sino.shape)
             sino_tmp.set(sino)
             sino = sino_tmp
@@ -97,13 +92,19 @@ class CudaSinoFilter(SinoFilter):
 
         # return
         if output is None:
-            res = self.cuda.allocate_array("output", self.sino_shape)
+            if not (self.crop_filtered_data):
+                # No need to allocate extra memory here
+                return self.d_sino_padded
+            res = self.cuda.allocate_array("output", self.output_shape)
         else:
             res = output
-        if self.ndim == 2:
-            res[:] = self.d_sino_padded[:, self.pad_left : self.pad_left + self.dwidth]
+
+        if self.crop_filtered_data:
+            # res[:] = sino_filtered[..., : self.dwidth]  # pylint: disable=E1126 # ?!
+            res[:] = self.d_sino_padded[..., self.pad_left : -self.pad_right]  # pylint: disable=E1126 # ?!
         else:
-            res[:] = self.d_sino_padded[:, :, self.pad_left : self.pad_left + self.dwidth]
+            res[:] = self.d_sino_padded[:]
+
         return res
 
     __call__ = filter_sino

nabu/reconstruction/filtering_opencl.py

@@ -19,13 +19,22 @@ class OpenCLSinoFilter(SinoFilter):
         sino_shape,
         filter_name=None,
         padding_mode="zeros",
+        crop_filtered_data=True,
         extra_options=None,
         opencl_options=None,
     ):
         self._opencl_options = opencl_options or {}
         self.opencl = OpenCLProcessing(**self._opencl_options)
         self.queue = self.opencl.queue
-        super().__init__(sino_shape, filter_name=filter_name, padding_mode=padding_mode, extra_options=extra_options)
+        super().__init__(
+            sino_shape,
+            filter_name=filter_name,
+            padding_mode=padding_mode,
+            crop_filtered_data=crop_filtered_data,
+            extra_options=extra_options,
+        )
+        if not (crop_filtered_data):
+            raise NotImplementedError  # TODO
         self._init_kernels()
 
     def _init_fft(self):
@@ -61,19 +70,6 @@ class OpenCLSinoFilter(SinoFilter):
         self.memcpy2D = OpenCLMemcpy2D(queue=self.queue)
 
     def filter_sino(self, sino, output=None):
-        """
-        Perform the sinogram siltering.
-
-        Parameters
-        ----------
-        sino: numpy.ndarray or pyopencl.array
-            Input sinogram (2D or 3D)
-        output: pyopencl.array, optional
-            Output array.
-        no_output: bool, optional
-            If set to True, no copy is be done. The resulting data lies
-            in self.d_sino_padded.
-        """
         self._check_array(sino)
         sino = self.opencl.set_array("sino", sino)
 

nabu/reconstruction/hbp.py

@@ -1,3 +1,15 @@
+# Generalized Hierarchical Backprojection (GHBP)
+# for fast tomographic reconstruction from ultra high resolution images at non-negligible fan angles.
+#
+# Authors/Contributions:
+# - Jonas Graetz, Fraunhofer IIS / Universität Würzburg: Algorithm Design and original OpenCL/Python implementation.
+# - Alessandro Mirone, ESRF: CUDA translation, ESRF / BM18 integration, testing <mirone@esrf.fr>
+# - Pierre Paleo, ESRF: ESRF / BM18 integration, testing <pierre.paleo@esrf.fr>
+#
+# JG was funded by the German Federal Ministry of Education and Research (BMBF), grant 05E2019,
+# funding the development of BM18 at ESRF in collaboration with the Fraunhofer Gesellschaft,
+# the Julius-Maximilians-Universität Würzburg, and the University of Passau
+
 import math
 import numpy as np
 
@@ -12,6 +24,7 @@ from .fbp import CudaBackprojector
 
 
 try:
+    # ruff: noqa: F401
     import pycuda.driver as cuda
     from pycuda import gpuarray as garray
 
@@ -60,7 +73,7 @@ class HierarchicalBackprojector(CudaBackprojector):
 
         # to do the reconstruction in reduction_steps steps
         self.reduction_steps = self.extra_options.get("hbp_reduction_steps", 2)
-        reduction_factor = int(math.ceil((sino_shape[-2]) ** (1 / self.reduction_steps)))
+        reduction_factor = math.ceil((sino_shape[-2]) ** (1 / self.reduction_steps))
 
         # TODO customize
         axis_source_meters = 1.0e9
@@ -138,15 +151,15 @@ class HierarchicalBackprojector(CudaBackprojector):
 
         N = self.slice_shape[1] * fac
 
-        angularRange = abs(self.angles.ptp()) / self.sino_shape[0] * reductionFactor
+        angularRange = abs(np.ptp(self.angles)) / self.sino_shape[0] * reductionFactor
 
-        ngrids = int(math.ceil(self.sino_shape[0] / reductionFactor))
+        ngrids = math.ceil(self.sino_shape[0] / reductionFactor)
 
         grid_width = int(
             np.rint(2 * N * self.whf[0])
         )  # double sampling to account/compensate for diamond shaped grid of ray-intersections
-        grid_height = int(
-            math.ceil(angularRange * N * self.whf[1])
+        grid_height = math.ceil(
+            angularRange * N * self.whf[1]
         )  # small-angle approximation, generates as much "lines" as needed to account for all intersection levels
 
         m = (len(self.angles) // reductionFactor) * reductionFactor
@@ -166,7 +179,7 @@ class HierarchicalBackprojector(CudaBackprojector):
             )
         ]
         self.gridInvTransforms += [np.array([np.linalg.inv(t) for t in self.gridTransforms[-1]], dtype=np.float32)]
-        self.grids += [(grid_height, grid_width, int(math.ceil(ngrids / legs)))]
+        self.grids += [(grid_height, grid_width, math.ceil(ngrids / legs))]
         self.reductionFactors += [reductionFactor]
 
         ### intermediate level grids: accumulation grids ###
@@ -177,13 +190,13 @@ class HierarchicalBackprojector(CudaBackprojector):
             # for a reasonable (with regard to memory requirement) grid-aspect ratio in the intermediate levels,
             # the covered angular range per grid should not exceed 28.6°, i.e.,
             # fewer than 7 (6.3) or 13 (12.6)  grids for a 180° / 360° scan is not reasonable
-            if int(math.ceil(ngrids / reductionFactor)) < 20:
+            if math.ceil(ngrids / reductionFactor) < 20:
                 break
             angularRange *= reductionFactor
-            ngrids = int(math.ceil(ngrids / reductionFactor))
+            ngrids = math.ceil(ngrids / reductionFactor)
 
-            grid_height = int(
-                math.ceil(angularRange * N * self.whf[1])
+            grid_height = math.ceil(
+                angularRange * N * self.whf[1]
             )  # implicit small angle approximation, whose validity is
             # asserted by the preceding "break"
             gridAinvT = self._getAinvT(N, grid_height, grid_width)
@@ -205,7 +218,7 @@ class HierarchicalBackprojector(CudaBackprojector):
                 )
             ]
             self.gridInvTransforms += [np.array([np.linalg.inv(t) for t in self.gridTransforms[-1]], dtype=np.float32)]
-            self.grids += [(grid_height, grid_width, int(math.ceil(ngrids / legs)))]
+            self.grids += [(grid_height, grid_width, math.ceil(ngrids / legs))]
             self.reductionFactors += [reductionFactor]
 
         ##### final accumulation grid #################
@@ -331,7 +344,7 @@ class HierarchicalBackprojector(CudaBackprojector):
             )
 
         else:
-            for leg in list(range(0, self.legs)):
+            for leg in list(range(self.legs)):
                 gridOffset = leg * self.grids[0][2]
                 projOffset = gridOffset * self.reductionFactors[0]
                 gws = getGridSize(self.grids[0], lws)
@@ -418,7 +431,7 @@ def get_max_grid_size(grids):
 
 
 def getGridSize(minimum, local):
-    m, l = np.array(minimum), np.array(local)
+    m, l = np.array(minimum), np.array(local)  # noqa: E741
     new = (m // l) * l
     new[new < m] += l[new < m]
     return tuple(map(int, new // l))

nabu/reconstruction/mlem.py

@@ -12,6 +12,28 @@ except ImportError:
 class MLEMReconstructor:
     """
     A reconstructor for MLEM reconstruction using the CorrCT toolbox.
+
+    Parameters
+    ----------
+    data_vwu_shape : tuple
+        Shape of the input data, expected to be (n_slices, n_angles, n_dets). Raises an error if the shape is not 3D.
+    angles_rad : numpy.ndarray
+        Angles in radians for the projections. Must match the second dimension of `data_vwu_shape`.
+    shifts_vu : numpy.ndarray, optional.
+        Shifts in the v and u directions for each angle. If provided, must have the same number of cols as `angles_rad`. Each col is (tv,tu)
+    cor : float, optional
+        Center of rotation, which will be adjusted based on the sinogram width.
+    n_iterations : int, optional
+        Number of iterations for the MLEM algorithm. Default is 50.
+    extra_options : dict, optional
+        Additional options for the reconstruction process. Default options include:
+        - scale_factor (float, default is 1.0): Scale factor for the reconstruction.
+        - compute_shifts (boolean, default is False): Whether to compute shifts.
+        - tomo_consistency (boolean, default is False): Whether to enforce tomographic consistency.
+        - v_min_for_v_shifts (number, default is 0): Minimum value for vertical shifts.
+        - v_max_for_v_shifts (number, default is None): Maximum value for vertical shifts.
+        - v_min_for_u_shifts (number, default is 0): Minimum value for horizontal shifts.
+        - v_max_for_u_shifts (number, default is None): Maximum value for horizontal shifts.
     """
 
     default_extra_options = {
@@ -21,25 +43,32 @@ class MLEMReconstructor:
         "v_max_for_v_shifts": None,
         "v_min_for_u_shifts": 0,
         "v_max_for_u_shifts": None,
+        "scale_factor": 1.0,
+        "centered_axis": False,
+        "clip_outer_circle": False,
+        "outer_circle_value": 0.0,
+        "filter_cutoff": 1.0,
+        "padding_mode": None,
+        "crop_filtered_data": True,
     }
 
     def __init__(
         self,
-        sinos_shape,
+        data_vwu_shape,
         angles_rad,
         shifts_uv=None,
-        cor=None,
+        cor=None,  # absolute
         n_iterations=50,
         extra_options=None,
     ):
-        """ """
         if not (__have_corrct__):
             raise ImportError("Need corrct package")
         self.angles_rad = angles_rad
         self.n_iterations = n_iterations
+        self.scale_factor = extra_options.get("scale_factor", 1.0)
 
         self._configure_extra_options(extra_options)
-        self._set_sino_shape(sinos_shape)
+        self._set_sino_shape(data_vwu_shape)
         self._set_shifts(shifts_uv, cor)
 
     def _configure_extra_options(self, extra_options):
@@ -58,16 +87,24 @@ class MLEMReconstructor:
 
     def _set_shifts(self, shifts_uv, cor):
         if shifts_uv is None:
-            self.shifts_uv = np.zeros([self.n_angles, 2])
+            self.shifts_vu = None
         else:
             if shifts_uv.shape[0] != self.n_angles:
                 raise ValueError(
                     f"Number of shifts given ({shifts_uv.shape[0]}) does not mathc the number of projections ({self.n_angles})."
                 )
-            self.shifts_uv = shifts_uv.copy()
-        self.cor = cor
+            self.shifts_vu = -shifts_uv.copy().T[::-1]
+        if cor is None:
+            self.cor = 0.0
+        else:
+            self.cor = (
+                -cor + (self.sinos_shape[-1] - 1) / 2.0
+            )  # convert absolute to relative in the ASTRA convention, which is opposite to Nabu relative convention.
+
+    def reset_rot_center(self, cor):
+        self.cor = -cor + (self.sinos_shape[-1] - 1) / 2.0
 
-    def reconstruct(self, data_vwu):
+    def reconstruct(self, data_vwu, x0=None):
         """
         data_align_vwu: numpy.ndarray or pycuda.gpuarray
             Raw data, with shape (n_sinograms, n_angles, width)
@@ -76,14 +113,17 @@ class MLEMReconstructor:
         """
         if not isinstance(data_vwu, np.ndarray):
             data_vwu = data_vwu.get()
-        data_vwu /= data_vwu.mean()
+        # data_vwu /= data_vwu.mean()
 
         # MLEM recons
         self.vol_geom_align = cct.models.VolumeGeometry.get_default_from_data(data_vwu)
-        self.prj_geom_align = cct.models.ProjectionGeometry.get_default_parallel()
-        # Vertical shifts were handled in pipeline. Set them to ZERO
-        self.shifts_uv[:, 1] = 0.0
-        self.prj_geom_align.set_detector_shifts_vu(self.shifts_uv.T[::-1])
+        if self.shifts_vu is not None:
+            self.prj_geom_align = cct.models.ProjectionGeometry.get_default_parallel()
+            # Vertical shifts were handled in pipeline. Set them to ZERO
+            self.shifts_vu[:, 0] = 0.0
+            self.prj_geom_align.set_detector_shifts_vu(self.shifts_vu, self.cor)
+        else:
+            self.prj_geom_align = None
 
         variances_align = cct.processing.compute_variance_poisson(data_vwu)
         self.weights_align = cct.processing.compute_variance_weight(variances_align, normalized=True)  # , use_std=True
@@ -94,6 +134,5 @@ class MLEMReconstructor:
         with cct.projectors.ProjectorUncorrected(
             self.vol_geom_align, self.angles_rad, rot_axis_shift_pix=self.cor, prj_geom=self.prj_geom_align
         ) as A:
-            rec, _ = solver(A, data_vwu, iterations=self.n_iterations, **self.solver_opts)
-
-        return rec
+            rec, _ = solver(A, data_vwu, iterations=self.n_iterations, x0=x0, **self.solver_opts)
+        return rec * self.scale_factor

nabu/reconstruction/projection.py

@@ -32,7 +32,6 @@ class Projector:
 
         Parameters
         -----------
-
         slice_shape: tuple
             Shape of the slice: (num_rows, num_columns).
         angles: int or sequence
@@ -198,10 +197,9 @@ class Projector:
         if image.dtype != np.dtype("f"):
             raise ValueError("Expected float32 data type, got %s" % str(image.dtype))
         if not isinstance(image, (np.ndarray, garray.GPUArray)):
-            raise ValueError("Expected either numpy.ndarray or pyopencl.array.Array")
-        if isinstance(image, np.ndarray):
-            if not image.flags["C_CONTIGUOUS"]:
-                raise ValueError("Please use C-contiguous arrays")
+            raise TypeError("Expected either numpy.ndarray or pyopencl.array.Array")
+        if isinstance(image, np.ndarray) and not image.flags["C_CONTIGUOUS"]:
+            raise ValueError("Please use C-contiguous arrays")
 
     def set_image(self, image, check=True):
         if check:

nabu/reconstruction/sinogram.py

@@ -290,7 +290,7 @@ def match_half_sinos_parts(sino, angles, output=None):
     """
     n_a = angles.size
     n_a_2 = n_a // 2
-    sino_part1 = sino[:n_a_2, :]
+    # sino_part1 = sino[:n_a_2, :]
     sino_part2 = sino[n_a_2:, :]
     angles = np.rad2deg(angles)  # more numerically stable ?
     angles_1 = angles[:n_a_2]

nabu/reconstruction/sinogram_cuda.py

@@ -212,7 +212,6 @@ class CudaSinoNormalization(SinoNormalization):
         else:
             # This kernel seems to have an issue on arrays that are not C-contiguous.
             # We have to process image per image.
-            nz = np.int32(1)
             nthreadsperblock = (1, 32, 1)  # TODO tune
             nblocks = (1, int(updiv(self.n_angles, nthreadsperblock[1])), 1)
             for i in range(sinos.shape[0]):