httomolibgpu 5.6__tar.gz → 5.8__tar.gz

{httomolibgpu-5.6/httomolibgpu.egg-info → httomolibgpu-5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 5.6
+Version: 5.8
 Summary: Commonly used tomography data processing methods at DLS.
 Author-email: Daniil Kazantsev <daniil.kazantsev@diamond.ac.uk>, Yousef Moazzam <yousef.moazzam@diamond.ac.uk>, Naman Gera <naman.gera@diamond.ac.uk>
 License: BSD-3-Clause
@@ -33,6 +33,7 @@ Requires-Dist: imageio; extra == "dev"
 Requires-Dist: h5py; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pyfftw; extra == "dev"
+Requires-Dist: tomophantom; extra == "dev"
 Dynamic: license-file
 
 HTTomolibGPU is a library of GPU accelerated methods for tomography

{httomolibgpu-5.6 → httomolibgpu-5.8}/httomolibgpu/misc/denoise.py

@@ -175,7 +175,9 @@ def total_variation_PD(
     __check_variable_type(iterations, [int], "iterations", [], methods_name)
     __check_variable_type(isotropic, [bool], "isotropic", [], methods_name)
     __check_variable_type(nonnegativity, [bool], "nonnegativity", [], methods_name)
-    __check_variable_type(lipschitz_const, [float, int], "lipschitz_const", [], methods_name)
+    __check_variable_type(
+        lipschitz_const, [float, int], "lipschitz_const", [], methods_name
+    )
     __check_variable_type(gpu_id, [int], "gpu_id", [], methods_name)
     __check_variable_type(half_precision, [bool], "half_precision", [], methods_name)
     ###################################

{httomolibgpu-5.6 → httomolibgpu-5.8}/httomolibgpu/misc/morph.py

@@ -45,6 +45,7 @@ from httomolibgpu.misc.utils import (
 __all__ = [
     "sino_360_to_180",
     "data_resampler",
+    "average_projection_frames",
 ]
 
 
@@ -80,45 +81,76 @@ def sino_360_to_180(
     )
     __check_variable_type(overlap, [int, float], "overlap", [], methods_name)
     __check_variable_type(side, [str], "side", ["left", "right"], methods_name)
-    __check_if_positive_nonzero(
-        overlap, "overlap", positive=True, nonzero=True, methods_name=methods_name
-    )
     ###################################
     #
     dx, dy, dz = data.shape
 
     overlap = int(np.round(overlap))
-    if overlap >= dz - 1:
-        raise ValueError("Overlap must be less than size of the horizontal detector")
     if overlap % 2 != 0:
         overlap += 1
-
+    overlap_pos = abs(overlap)
+    if overlap_pos >= dz - 1:
+        raise ValueError("Overlap must be less than size of the horizontal detector")
     n = dx // 2
     out = cp.empty((n, dy, 2 * dz - overlap), dtype=data.dtype)
 
     if side == "left":
-        weights = cp.linspace(0, 1.0, overlap, dtype=cp.float32)
-        out[:, :, -dz + overlap :] = data[:n, :, overlap:]
-        out[:, :, : dz - overlap] = data[n : 2 * n, :, overlap:][:, :, ::-1]
-        out[:, :, dz - overlap : dz] = (
-            weights * data[:n, :, :overlap]
-            + (weights * data[n : 2 * n, :, :overlap])[:, :, ::-1]
-        )
+        if overlap == 0:
+            out[:, :, -dz:] = data[:n, :, :]
+            out[:, :, :dz] = data[n : 2 * n, :, :][:, :, ::-1]
+            return out
+        elif overlap < 0:
+            out[:, :, -dz:] = data[:n, :, :]
+            out[:, :, : (dz + overlap_pos)] = cp.pad(
+                data[n : 2 * n, :, :][:, :, ::-1],
+                pad_width=(
+                    (0, 0),
+                    (0, 0),
+                    (0, overlap_pos),
+                ),
+                mode="edge",
+            )
+            return out
+        else:
+            weights = cp.linspace(0, 1.0, overlap, dtype=cp.float32)
+            out[:, :, -dz + overlap :] = data[:n, :, overlap:]
+            out[:, :, : dz - overlap] = data[n : 2 * n, :, overlap:][:, :, ::-1]
+            out[:, :, dz - overlap : dz] = (
+                weights * data[:n, :, :overlap]
+                + (weights * data[n : 2 * n, :, :overlap])[:, :, ::-1]
+            )
     if side == "right":
-        weights = cp.linspace(1.0, 0, overlap, dtype=cp.float32)
-        out[:, :, : dz - overlap] = data[:n, :, :-overlap]
-        out[:, :, -dz + overlap :] = data[n : 2 * n, :, :-overlap][:, :, ::-1]
-        out[:, :, dz - overlap : dz] = (
-            weights * data[:n, :, -overlap:]
-            + (weights * data[n : 2 * n, :, -overlap:])[:, :, ::-1]
-        )
+        if overlap == 0:
+            out[:, :, :dz] = data[:n, :, :]
+            out[:, :, dz::] = data[n : 2 * n, :, :][:, :, ::-1]
+            return out
+        elif overlap < 0:
+            out[:, :, : (dz + overlap_pos)] = cp.pad(
+                data[:n, :, :],
+                pad_width=(
+                    (0, 0),
+                    (0, 0),
+                    (0, overlap_pos),
+                ),
+                mode="edge",
+            )
+            out[:, :, (dz + overlap_pos) : :] = data[n : 2 * n, :, :][:, :, ::-1]
+            return out
+        else:
+            weights = cp.linspace(1.0, 0, overlap, dtype=cp.float32)
+            out[:, :, : dz - overlap] = data[:n, :, :-overlap]
+            out[:, :, -dz + overlap :] = data[n : 2 * n, :, :-overlap][:, :, ::-1]
+            out[:, :, dz - overlap : dz] = (
+                weights * data[:n, :, -overlap:]
+                + (weights * data[n : 2 * n, :, -overlap:])[:, :, ::-1]
+            )
 
     return cp.pad(
         out,
         pad_width=(
             (0, 0),
             (0, 0),
-            (overlap // 2, overlap // 2),
+            (overlap_pos // 2, overlap_pos // 2),
         ),
         mode="edge",
     )
@@ -274,3 +306,65 @@ def data_resampler(
     if expanded:
         scaled_data = cp.squeeze(scaled_data, axis=axis)
     return scaled_data
+
+
+def average_projection_frames(
+    data: cp.ndarray,
+    projection_averaging_factor: int = 2,
+) -> cp.ndarray:
+    """
+    This method averages/downsamples by averaging data along the angular direction based on the provided projection_averaging_factor.
+
+    Parameters
+    ----------
+    data : cp.ndarray
+        3d cupy array given as (angles, detY, detX).
+    projection_averaging_factor : int
+        to average every (defined by the provided factor) consecutive projections into one effective projection.
+
+    Raises
+    ----------
+        ValueError: When data is not 3D
+
+    Returns
+    -------
+        cp.ndarray: 3D cupy array with averaged projection data
+    """
+
+    ### Data and parameters checks ###
+    methods_name = "average_projection_frames"
+    __check_if_data_3D_array(data, methods_name)
+    __check_if_data_correct_type(
+        data, accepted_type=["float32", "uint16"], methods_name=methods_name
+    )
+    __check_if_positive_nonzero(
+        projection_averaging_factor,
+        "projection_averaging_factor",
+        True,
+        True,
+        methods_name,
+    )
+
+    ###################################
+    if projection_averaging_factor > 1:
+        k = projection_averaging_factor
+        n_proj = data.shape[0]
+
+        n_full = n_proj // k
+        remainder = n_proj % k
+
+        n_out = n_full + (remainder > 0)
+
+        averaged = cp.empty((n_out, *data.shape[1:]), dtype=data.dtype)
+
+        if n_full:
+            averaged[:n_full] = (
+                data[: n_full * k].reshape(n_full, k, *data.shape[1:]).mean(axis=1)
+            )
+
+        if remainder:
+            averaged[-1] = data[n_full * k :].mean(axis=0)
+
+        return averaged
+    else:
+        return data

httomolibgpu-5.8/httomolibgpu/misc/sorting.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ---------------------------------------------------------------------------
+# Copyright 2026 Diamond Light Source Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either ecpress or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ---------------------------------------------------------------------------
+# Created By  : Tomography Team at DLS <scientificsoftware@diamond.ac.uk>
+# Created Date: 22 April 2026
+# ---------------------------------------------------------------------------
+
+from typing import Tuple
+import cupy as cp
+
+
+def argsort_with_reverse(
+    data: cp.ndarray, axis: int = -1
+) -> Tuple[cp.ndarray, cp.ndarray]:
+    """
+    Compute sorting indices for an 1D or 2D array, and efficiently compute the indices to revert the sort.
+    """
+    dim = len(data.shape)
+    if 1 <= dim <= 2:
+        pass
+    else:
+        raise ValueError("only 1D and 2D arrays are supported")
+    if axis < 0:
+        axis = dim + axis
+    if axis >= dim:
+        raise ValueError("invalid axis")
+    sort_indices = cp.argsort(data, axis=axis)
+    reverse_sort_indices = cp.empty_like(sort_indices)
+    if dim == 1:
+        reverse_sort_indices[sort_indices] = cp.arange(0, data.size)
+    elif axis == 0:  # sort rows
+        nrows, ncols = data.shape
+        cols = cp.arange(ncols)[None, :]
+        reverse_sort_indices[sort_indices, cols] = cp.arange(nrows)[:, None]
+    else:  # sort columns
+        nrows, ncols = data.shape
+        rows = cp.arange(nrows)[:, None]
+        reverse_sort_indices[rows, sort_indices] = cp.arange(ncols)
+
+    return sort_indices, reverse_sort_indices

{httomolibgpu-5.6 → httomolibgpu-5.8}/httomolibgpu/prep/stripe.py

@@ -23,6 +23,7 @@
 import numpy as np
 import pywt
 from httomolibgpu import cupywrapper
+from httomolibgpu.misc.sorting import argsort_with_reverse
 
 cp = cupywrapper.cp
 cupy_run = cupywrapper.cupy_run
@@ -116,21 +117,18 @@ def _rs_sort(sinogram, size, dim):
     """
     Remove stripes using the sorting technique.
     """
-    sinogram = cp.transpose(sinogram)
+    #: Sort each row of the sinogram by its grayscale values
+    sortvals, sortvals_reverse = argsort_with_reverse(sinogram, axis=0)
 
-    #: Sort each column of the sinogram by its grayscale values
-    #: Keep track of the sorting indices so we can reverse it below
-    sortvals = cp.argsort(sinogram, axis=1)
-    sortvals_reverse = cp.argsort(sortvals, axis=1)
-    sino_sort = cp.take_along_axis(sinogram, sortvals, axis=1)
+    sino_sort = cp.take_along_axis(sinogram, sortvals, axis=0)
 
     #: Now apply the median filter on the sorted image along each row
-    sino_sort = median_filter(sino_sort, (size, 1) if dim == 1 else (size, size))
+    sino_sort = median_filter(sino_sort, (1, size) if dim == 1 else (size, size))
 
     #: step 3: re-sort the smoothed image columns to the original rows
-    sino_corrected = cp.take_along_axis(sino_sort, sortvals_reverse, axis=1)
+    sino_corrected = cp.take_along_axis(sino_sort, sortvals_reverse, axis=0)
 
-    return cp.transpose(sino_corrected)
+    return sino_corrected
 
 
 def remove_stripe_ti(
@@ -821,6 +819,7 @@ def remove_all_stripe(
     la_size: int = 61,
     sm_size: int = 21,
     dim: Literal[1, 2] = 1,
+    normalize: bool = False,
 ) -> cp.ndarray:
     """
     Remove all types of stripe artifacts from sinogram using Nghia Vo's
@@ -839,6 +838,8 @@ def remove_all_stripe(
         Window size of the median filter to remove small-to-medium stripes.
     dim : {1, 2},
         Dimension of the window.
+    normalize : bool,
+        Controls whether to normalize while removing large stripes
 
     Returns
     -------
@@ -859,10 +860,10 @@ def remove_all_stripe(
     __check_variable_type(dim, [int], "dim", [1, 2], methods_name)
     ###################################
 
-    matindex = _create_matindex(data.shape[2], data.shape[0])
     for m in range(data.shape[1]):
         sino = data[:, m, :]
-        sino = _rs_dead(sino, snr, la_size, matindex)
+        sino = _rs_dead(sino, snr, la_size)
+        sino = _rs_large(sino, snr, la_size, normalize)
         sino = _rs_sort(sino, sm_size, dim)
         sino = cp.nan_to_num(sino)
         data[:, m, :] = sino
@@ -910,15 +911,17 @@ def _detect_stripe(listdata, snr):
     return listmask
 
 
-def _rs_large(sinogram, snr, size, matindex, drop_ratio=0.1, norm=True):
+def _rs_large(sinogram, snr, size, normalize, drop_ratio=0.1):
     """
     Remove large stripes.
     """
     drop_ratio = max(min(drop_ratio, 0.8), 0)  # = cp.clip(drop_ratio, 0.0, 0.8)
     nrow, ncol = sinogram.shape
     ndrop = int(0.5 * drop_ratio * nrow)
-    sinosort = cp.sort(sinogram, axis=0)
+    sort_indices, sort_indices_reverse = argsort_with_reverse(sinogram, axis=0)
+    sinosort = cp.take_along_axis(sinogram, sort_indices, axis=0)
     sinosmooth = median_filter(sinosort, (1, size))
+
     list1 = cp.mean(sinosort[ndrop : nrow - ndrop], axis=0)
     list2 = cp.mean(sinosmooth[ndrop : nrow - ndrop], axis=0)
     listfact = list1 / list2
@@ -927,30 +930,16 @@ def _rs_large(sinogram, snr, size, matindex, drop_ratio=0.1, norm=True):
     listmask = _detect_stripe(listfact, snr)
     listmask = binary_dilation(listmask, iterations=1).astype(listmask.dtype)
     matfact = cp.tile(listfact, (nrow, 1))
-    # Normalize
-    if norm is True:
+    if normalize:
         sinogram = sinogram / matfact
-    sinogram1 = cp.transpose(sinogram)
-    matcombine = cp.asarray(cp.dstack((matindex, sinogram1)))
-
-    ids = cp.argsort(matcombine[:, :, 1], axis=1)
-    matsort = matcombine.copy()
-    matsort[:, :, 0] = cp.take_along_axis(matsort[:, :, 0], ids, axis=1)
-    matsort[:, :, 1] = cp.take_along_axis(matsort[:, :, 1], ids, axis=1)
-
-    matsort[:, :, 1] = cp.transpose(sinosmooth)
-    ids = cp.argsort(matsort[:, :, 0], axis=1)
-    matsortback = matsort.copy()
-    matsortback[:, :, 0] = cp.take_along_axis(matsortback[:, :, 0], ids, axis=1)
-    matsortback[:, :, 1] = cp.take_along_axis(matsortback[:, :, 1], ids, axis=1)
-
-    sino_corrected = cp.transpose(matsortback[:, :, 1])
+        sort_indices, sort_indices_reverse = argsort_with_reverse(sinogram, axis=0)
+    sino_corrected = cp.take_along_axis(sinosmooth, sort_indices_reverse, axis=0)
     listxmiss = cp.where(listmask > 0.0)[0]
     sinogram[:, listxmiss] = sino_corrected[:, listxmiss]
     return sinogram
 
 
-def _rs_dead(sinogram, snr, size, matindex, norm=True):
+def _rs_dead(sinogram, snr, size):
     """remove unresponsive and fluctuating stripes"""
     sinogram = cp.copy(sinogram)  # Make it mutable
     nrow, _ = sinogram.shape
@@ -979,9 +968,6 @@ def _rs_dead(sinogram, snr, size, matindex, norm=True):
             sinogram[:, listx[ids]] - sinogram[:, listx[ids - 1]]
         )
 
-    # Remove residual stripes
-    if norm is True:
-        sinogram = _rs_large(sinogram, snr, size, matindex)
     return sinogram
 
 

{httomolibgpu-5.6 → httomolibgpu-5.8}/httomolibgpu/recon/algorithm.py

@@ -56,6 +56,7 @@ __all__ = [
     "CGLS3d_tomobar",
     "FISTA3d_tomobar",
     "ADMM3d_tomobar",
+    "OSEM3d_tomobar",
 ]
 
 input_data_axis_labels = ["angles", "detY", "detX"]  # set the labels of the input data
@@ -126,7 +127,18 @@ def FBP2d_astra(
         filter_type,
         [str],
         "filter_type",
-        ["none", "ram-lak", "shepp-logan", "tukey", "gaussian", "blackman", "kaiser"],
+        [
+            "none",
+            "ram-lak",
+            "cosine",
+            "shepp-logan",
+            "tukey",
+            "gaussian",
+            "blackman",
+            "kaiser",
+            "lanczos",
+            "hann",
+        ],
         methods_name,
     )
     __check_variable_type(
@@ -552,15 +564,15 @@ def FISTA3d_tomobar(
     subsets_number: int
         The number of the ordered subsets to accelerate convergence. Keep the value bellow 10 to avoid divergence.
     data_fidelity: str
-        Data fidelity given as 'LS' (Least Squares), 'PWLS' (Penalised Weightes LS).
+        Data fidelity given as 'LS' (Least Squares)
     regularisation_type: str
-        A method to use for regularisation. Currently PD_TV and ROF_TV are available.
+        A method to use for regularisation. Currently PD_TV and ROF_TV penalties are available.
     regularisation_parameter: float
         The main regularisation parameter to control the amount of smoothing/noise removal. Larger values lead to stronger smoothing.
     regularisation_iterations: int
         The number of iterations for regularisers (aka INNER iterations).
     regularisation_half_precision: bool
-        Perform faster regularisation computation in half-precision with a very minimal sacrifice in quality.
+        Perform faster regularisation computation in half-precision with some sacrifice in quality (can be used to find the best settings).
     nonnegativity : bool
         Impose nonnegativity constraint on the reconstructed image.
     gpu_id : int
@@ -644,7 +656,7 @@ def ADMM3d_tomobar(
     initialisation: Literal["FBP", "CGLS", "SIRT", None] = "FBP",
     ADMM_rho_const: float = 1.0,
     ADMM_relax_par: float = 1.7,
-    regularisation_type: str = "PD_TV",
+    regularisation_type: Literal["ROF_TV", "PD_TV"] = "PD_TV",
     regularisation_parameter: float = 0.0025,
     regularisation_iterations: int = 40,
     regularisation_half_precision: bool = True,
@@ -679,21 +691,23 @@ def ADMM3d_tomobar(
     subsets_number: int
         The number of the ordered subsets to accelerate convergence. The recommended range is between 12 to 24.
     data_fidelity: str
-        Data fidelity given as 'LS' (Least Squares), 'PWLS' (Penalised Weightes LS).
+        Data fidelity given as 'LS' (Least Squares)
     initialisation: str, optional
         Initialise ADMM with the reconstructed image to reduce the number of iterations and accelerate. Choose between 'CGLS' or 'SIRT' when data
         is noisy and/or undersampled. Choose 'FBP' when the data is of better quality (default) or None.
     ADMM_rho_const: float
         Convergence related parameter for ADMM, higher values lead to slower convergence, but too small values can destabilise the iterations.
         Recommended range is between 0.9 and 2.0.
-    ADMM_relax_par: Relaxation parameter which can lead to acceleration of the algorithm, keep it in the range between 1.5 and 1.8 to avoid divergence.     regularisation_type: str
-        A method to use for regularisation. Currently PD_TV and ROF_TV are available.
+    ADMM_relax_par: float
+        Relaxation parameter which can lead to acceleration of the algorithm, keep it in the range between 1.5 and 1.8 to avoid divergence.
+    regularisation_type: str
+        A method to use for regularisation. Currently PD_TV and ROF_TV penalties are available.
     regularisation_parameter: float
         The main regularisation parameter to control the amount of smoothing/noise removal. Larger values lead to stronger smoothing.
     regularisation_iterations: int
         The number of iterations for regularisers (aka INNER iterations).
     regularisation_half_precision: bool
-        Perform faster regularisation computation in half-precision with a very minimal sacrifice in quality.
+        Perform faster regularisation computation in half-precision with some sacrifice in quality (can be used to find the best settings).
     nonnegativity : bool
         Impose nonnegativity constraint (set to True) on the reconstructed image. Default False.
     gpu_id : int
@@ -835,6 +849,125 @@ def ADMM3d_tomobar(
     return cp.require(cp.swapaxes(reconstruction, 0, 1), requirements="C")
 
 
+## %%%%%%%%%%%%%%%%%%%%%%% OSEM reconstruction %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
+def OSEM3d_tomobar(
+    data: cp.ndarray,
+    angles: np.ndarray,
+    center: Optional[float] = None,
+    detector_pad: Union[bool, int] = False,
+    recon_size: Optional[int] = None,
+    recon_mask_radius: Optional[float] = 0.95,
+    iterations: int = 20,
+    subsets_number: int = 12,
+    regularisation_type: Literal["ROF_TV", "PD_TV"] = "PD_TV",
+    regularisation_parameter: float = 1.0,
+    regularisation_iterations: int = 30,
+    regularisation_half_precision: bool = True,
+    nonnegativity: bool = True,
+    gpu_id: int = 0,
+) -> cp.ndarray:
+    """
+    Ordered-Subsets Expectation-Maximisation method is the accelerated Maximum Likelihood Expectation-Maximisation (MLEM) algorithm.
+    Can be coupled with various types of regularisation or denoising operations :cite:`kazantsev2019ccpi` (currently accepts ROF_TV and PD_TV regularisations only).
+    Should be applied to reconstruct emission-type measurements, e.g., XRF tomography measurements.
+
+    Parameters
+    ----------
+    data : cp.ndarray
+        Projection data as a CuPy array.
+    angles : np.ndarray
+        An array of angles given in radians.
+    center : float, optional
+        The center of rotation (CoR).
+    detector_pad : bool, int
+        Detector width padding with edge values to remove circle/arc type artifacts in the reconstruction. Set to True to perform
+        an automated padding or specify a certain value as an integer.
+    recon_size : int, optional
+        The squared size of the reconstructed slice. By default (None), the reconstructed size will be the dimension of the horizontal detector.
+    recon_mask_radius: float, optional
+        The radius of the circular mask that applies to the reconstructed slice in order to crop
+        out some undesirable artifacts. The values outside the given diameter will be set to zero.
+        To implement the cropping one can use the range [0.7-1.0] or set to None (2.0) when no cropping is needed.
+    iterations : int
+        The number of OSEM algorithm iterations. For OS method 20 interations is normally sufficient, while for MLEM one should run 300-500 iterations.
+    subsets_number: int
+        The number of the ordered subsets to accelerate convergence. One can set 'subsets_number' to 1 to achieve MLEM, but the number of 'iterations' should be also increased.
+    data_fidelity: str
+        Data fidelity given as 'LS' (Least Squares)
+    regularisation_type: str
+        A method to use for regularisation. Currently PD_TV and ROF_TV are available.
+    regularisation_parameter: float
+        The main regularisation parameter to control the amount of smoothing/noise removal. Larger values lead to stronger smoothing.
+    regularisation_iterations: int
+        The number of iterations for regularisers (aka INNER iterations).
+    regularisation_half_precision: bool
+        Perform faster regularisation computation in half-precision with a very minimal sacrifice in quality.
+    nonnegativity : bool
+        Impose nonnegativity constraint on the reconstructed image.
+    gpu_id : int
+        A GPU device index to perform operation on.
+
+    Returns
+    -------
+    cp.ndarray
+        The OSEM reconstructed volume as a CuPy array.
+    """
+    ### Data and parameters checks ###
+    methods_name = "OSEM3d_tomobar"
+    __common_data_parameters_check(
+        data,
+        angles,
+        methods_name,
+        center,
+        detector_pad,
+        recon_size,
+        recon_mask_radius,
+        gpu_id,
+    )
+    __common_iterative_basic_parameters_check(methods_name, iterations, nonnegativity)
+    __common_iterative_parameters_check(
+        methods_name,
+        subsets_number,
+        regularisation_type,
+        regularisation_parameter,
+        regularisation_iterations,
+        regularisation_half_precision,
+    )
+    ###################################
+
+    RecToolsCP = _instantiate_iterative_recon_class(
+        data,
+        angles,
+        center,
+        detector_pad,
+        recon_size,
+        subsets_number,
+        gpu_id,
+    )
+
+    _data_ = {
+        "projection_data": data,
+        "data_axes_labels_order": input_data_axis_labels,
+    }
+
+    _algorithm_ = {
+        "iterations": iterations,
+        "nonnegativity": nonnegativity,
+        "recon_mask_radius": recon_mask_radius,
+    }
+
+    _regularisation_ = {
+        "method": regularisation_type,  # Selected regularisation method
+        "regul_param": regularisation_parameter,  # Regularisation parameter
+        "iterations": regularisation_iterations,  # The number of regularisation iterations
+        "half_precision": regularisation_half_precision,  # enabling half-precision calculation
+    }
+
+    reconstruction = RecToolsCP.OSEM(_data_, _algorithm_, _regularisation_)
+    cp._default_memory_pool.free_all_blocks()
+    return cp.require(cp.swapaxes(reconstruction, 0, 1), requirements="C")
+
+
 ## %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
 def _instantiate_direct_recon_class(
     data: cp.ndarray | Tuple[int, int, int],

{httomolibgpu-5.6 → httomolibgpu-5.8/httomolibgpu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 5.6
+Version: 5.8
 Summary: Commonly used tomography data processing methods at DLS.
 Author-email: Daniil Kazantsev <daniil.kazantsev@diamond.ac.uk>, Yousef Moazzam <yousef.moazzam@diamond.ac.uk>, Naman Gera <naman.gera@diamond.ac.uk>
 License: BSD-3-Clause
@@ -33,6 +33,7 @@ Requires-Dist: imageio; extra == "dev"
 Requires-Dist: h5py; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pyfftw; extra == "dev"
+Requires-Dist: tomophantom; extra == "dev"
 Dynamic: license-file
 
 HTTomolibGPU is a library of GPU accelerated methods for tomography

{httomolibgpu-5.6 → httomolibgpu-5.8}/httomolibgpu.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ httomolibgpu/misc/corr.py
 httomolibgpu/misc/denoise.py
 httomolibgpu/misc/morph.py
 httomolibgpu/misc/rescale.py
+httomolibgpu/misc/sorting.py
 httomolibgpu/misc/utils.py
 httomolibgpu/prep/__init__.py
 httomolibgpu/prep/alignment.py

{httomolibgpu-5.6 → httomolibgpu-5.8}/httomolibgpu.egg-info/requires.txt

@@ -20,3 +20,4 @@ imageio
 h5py
 pre-commit
 pyfftw
+tomophantom

{httomolibgpu-5.6 → httomolibgpu-5.8}/pyproject.toml

@@ -60,7 +60,8 @@ dev = [
   "imageio",
   "h5py",
   "pre-commit",
-  "pyfftw"
+  "pyfftw",
+  "tomophantom"
 ]