httomolibgpu 3.0__tar.gz → 3.1.1__tar.gz

{httomolibgpu-3.0/httomolibgpu.egg-info → httomolibgpu-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 3.0
+Version: 3.1.1
 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
@@ -19,7 +19,6 @@ Requires-Dist: scipy
 Requires-Dist: pillow
 Requires-Dist: scikit-image
 Requires-Dist: tomobar
-Requires-Dist: ccpi-regularisation-cupy
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

{httomolibgpu-3.0 → httomolibgpu-3.1.1}/httomolibgpu/__init__.py

@@ -4,11 +4,12 @@ from httomolibgpu.misc.morph import sino_360_to_180, data_resampler
 from httomolibgpu.misc.rescale import rescale_to_int
 from httomolibgpu.prep.alignment import distortion_correction_proj_discorpy
 from httomolibgpu.prep.normalize import normalize
-from httomolibgpu.prep.phase import paganin_filter_savu, paganin_filter_tomopy
+from httomolibgpu.prep.phase import paganin_filter_tomopy
 from httomolibgpu.prep.stripe import (
     remove_stripe_based_sorting,
     remove_stripe_ti,
     remove_all_stripe,
+    raven_filter,
 )
 
 from httomolibgpu.recon.algorithm import (
@@ -17,6 +18,7 @@ from httomolibgpu.recon.algorithm import (
     LPRec3d_tomobar,
     SIRT3d_tomobar,
     CGLS3d_tomobar,
+    FISTA3d_tomobar,
 )
 
 from httomolibgpu.recon.rotation import find_center_vo, find_center_360, find_center_pc

{httomolibgpu-3.0 → httomolibgpu-3.1.1}/httomolibgpu/misc/denoise.py

@@ -21,7 +21,6 @@
 """Module for data denoising. For more detailed information see :ref:`data_denoising_module`."""
 
 import numpy as np
-from typing import Union, Optional
 
 from httomolibgpu import cupywrapper
 
@@ -33,7 +32,7 @@ from unittest.mock import Mock
 from httomolibgpu.misc.supp_func import data_checker
 
 if cupy_run:
-    from ccpi.filters.regularisersCuPy import ROF_TV, PD_TV
+    from tomobar.regularisersCuPy import ROF_TV_cupy, PD_TV_cupy
 else:
     ROF_TV = Mock()
     PD_TV = Mock()
@@ -47,10 +46,11 @@ __all__ = [
 
 def total_variation_ROF(
     data: cp.ndarray,
-    regularisation_parameter: Optional[float] = 1e-05,
-    iterations: Optional[int] = 3000,
-    time_marching_parameter: Optional[float] = 0.001,
-    gpu_id: Optional[int] = 0,
+    regularisation_parameter: float = 1e-05,
+    iterations: int = 3000,
+    time_marching_parameter: float = 0.001,
+    gpu_id: int = 0,
+    half_precision: bool = False,
 ) -> cp.ndarray:
     """
     Total Variation using Rudin-Osher-Fatemi (ROF) :cite:`rudin1992nonlinear` explicit iteration scheme to perform edge-preserving image denoising.
@@ -62,14 +62,16 @@ def total_variation_ROF(
     ----------
     data : cp.ndarray
         Input CuPy 3D array of float32 data type.
-    regularisation_parameter : float, optional
+    regularisation_parameter : float
         Regularisation parameter to control the level of smoothing. Defaults to 1e-05.
-    iterations : int, optional
+    iterations : int
         The number of iterations. Defaults to 3000.
-    time_marching_parameter : float, optional
+    time_marching_parameter : float
         Time marching parameter, needs to be small to ensure convergence. Defaults to 0.001.
-    gpu_id : int, optional
+    gpu_id : int
         GPU device index to perform processing on. Defaults to 0.
+    half_precision : bool
+        Perform faster computation in half-precision with a very minimal sacrifice in quality. Defaults to False.
 
     Returns
     -------
@@ -84,19 +86,25 @@ def total_variation_ROF(
 
     data = data_checker(data, verbosity=True, method_name="total_variation_ROF")
 
-    return ROF_TV(
-        data, regularisation_parameter, iterations, time_marching_parameter, gpu_id
+    return ROF_TV_cupy(
+        data,
+        regularisation_parameter,
+        iterations,
+        time_marching_parameter,
+        gpu_id,
+        half_precision,
     )
 
 
 def total_variation_PD(
     data: cp.ndarray,
-    regularisation_parameter: Optional[float] = 1e-05,
-    iterations: Optional[int] = 1000,
-    isotropic: Optional[bool] = True,
-    nonnegativity: Optional[bool] = False,
-    lipschitz_const: Optional[float] = 8.0,
-    gpu_id: Optional[int] = 0,
+    regularisation_parameter: float = 1e-05,
+    iterations: int = 1000,
+    isotropic: bool = True,
+    nonnegativity: bool = False,
+    lipschitz_const: float = 8.0,
+    gpu_id: int = 0,
+    half_precision: bool = False,
 ) -> cp.ndarray:
     """
     Primal Dual algorithm for non-smooth convex Total Variation functional :cite:`chan1999nonlinear`. See more in :ref:`method_total_variation_PD`.
@@ -117,6 +125,8 @@ def total_variation_PD(
         Lipschitz constant to control convergence. Defaults to 8.
     gpu_id : int
         GPU device index to perform processing on. Defaults to 0.
+    half_precision : bool
+        Perform faster computation in half-precision with a very minimal sacrifice in quality. Defaults to False.
 
     Returns
     -------
@@ -139,7 +149,7 @@ def total_variation_PD(
     if nonnegativity:
         nonneg = 1
 
-    return PD_TV(
+    return PD_TV_cupy(
         data,
         regularisation_parameter,
         iterations,
@@ -147,4 +157,5 @@ def total_variation_PD(
         nonneg,
         lipschitz_const,
         gpu_id,
+        half_precision,
     )

{httomolibgpu-3.0 → httomolibgpu-3.1.1}/httomolibgpu/misc/supp_func.py

@@ -159,7 +159,7 @@ def data_checker(
     data: cp.ndarray,
     verbosity: bool = True,
     method_name: Optional[str] = None,
-) -> bool:
+) -> cp.ndarray:
     """
     Function that performs the variety of checks on input data, in some cases also correct the data and prints warnings.
     Currently it checks for: the presence of infs and nans in data.

{httomolibgpu-3.0 → httomolibgpu-3.1.1}/httomolibgpu/prep/phase.py

@@ -29,10 +29,8 @@ cupy_run = cupywrapper.cupy_run
 from unittest.mock import Mock
 
 if cupy_run:
-    from httomolibgpu.cuda_kernels import load_cuda_module
     from cupyx.scipy.fft import fft2, ifft2, fftshift
 else:
-    load_cuda_module = Mock()
     fft2 = Mock()
     ifft2 = Mock()
     fftshift = Mock()
@@ -44,225 +42,10 @@ import math
 from httomolibgpu.misc.supp_func import data_checker
 
 __all__ = [
-    "paganin_filter_savu",
     "paganin_filter_tomopy",
 ]
 
 
-## %%%%%%%%%%%%%%%%%%%%%%% paganin_filter %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
-#: CuPy implementation of Paganin filter from Savu
-def paganin_filter_savu(
-    data: cp.ndarray,
-    ratio: float = 250.0,
-    energy: float = 53.0,
-    distance: float = 1.0,
-    resolution: float = 1.28,
-    pad_y: int = 100,
-    pad_x: int = 100,
-    pad_method: str = "edge",
-    increment: float = 0.0,
-) -> cp.ndarray:
-    """
-    Apply Paganin filter (for denoising or contrast enhancement) to
-    projections.
-
-    Parameters
-    ----------
-    data : cp.ndarray
-        The stack of projections to filter.
-
-    ratio : float, optional
-        Ratio of delta/beta.
-
-    energy : float, optional
-        Beam energy in keV.
-
-    distance : float, optional
-        Distance from sample to detector in metres.
-
-    resolution : float, optional
-        Pixel size in microns.
-
-    pad_y : int, optional
-        Pad the top and bottom of projections.
-
-    pad_x : int, optional
-        Pad the left and right of projections.
-
-    pad_method : str, optional
-        Numpy pad method to use.
-
-    increment : float, optional
-        Increment all values by this amount before taking the log.
-
-    Returns
-    -------
-    cp.ndarray
-        The stack of filtered projections.
-    """
-    # Check the input data is valid
-    if data.ndim != 3:
-        raise ValueError(
-            f"Invalid number of dimensions in data: {data.ndim},"
-            " please provide a stack of 2D projections."
-        )
-
-    data = data_checker(data, verbosity=True, method_name="paganin_filter_savu")
-
-    # Setup various values for the filter
-    _, height, width = data.shape
-    micron = 1e-6
-    keV = 1000.0
-    energy *= keV
-    resolution *= micron
-    wavelength = (1240.0 / energy) * 1e-9
-
-    height1 = height + 2 * pad_y
-    width1 = width + 2 * pad_x
-
-    # Define the paganin filter, taking into account the padding that will be
-    # applied to the projections (if any)
-
-    # Using raw kernel her as indexing is direct and it avoids a lot of temporaries
-    # and tiny kernels
-    module = load_cuda_module("paganin_filter_gen")
-    kernel = module.get_function("paganin_filter_gen")
-
-    # Apply padding to all the 2D projections
-    # Note: this takes considerable time on GPU...
-    data = cp.pad(data, ((0, 0), (pad_y, pad_y), (pad_x, pad_x)), mode=pad_method)
-
-    precond_kernel_float = cp.ElementwiseKernel(
-        "T data",
-        "T out",
-        """
-        if (isnan(data)) {
-            out = T(0);
-        } else if (isinf(data)) {
-            out = data < 0.0 ? -3.402823e38f : 3.402823e38f;  // FLT_MAX, not available in cupy
-        } else if (data == 0.0) {
-            out = 1.0;
-        } else {
-            out = data;
-        }
-        """,
-        name="paganin_precond_float",
-        no_return=True,
-    )
-    precond_kernel_int = cp.ElementwiseKernel(
-        "T data",
-        "T out",
-        """out = data == 0 ? 1 : data""",
-        name="paganin_precond_int",
-        no_return=True,
-    )
-
-    if data.dtype in (cp.float32, cp.float64):
-        precond_kernel_float(data, data)
-    else:
-        precond_kernel_int(data, data)
-
-    # avoid normalising in both directions - we include multiplier in the post_kernel
-    data = cp.asarray(data, dtype=cp.complex64)
-    data = fft2(data, axes=(-2, -1), overwrite_x=True, norm="backward")
-
-    # prepare filter here, while the GPU is busy with the FFT
-    filtercomplex = cp.empty((height1, width1), dtype=cp.complex64)
-    bx = 16
-    by = 8
-    gx = (width1 + bx - 1) // bx
-    gy = (height1 + by - 1) // by
-    kernel(
-        grid=(gx, gy, 1),
-        block=(bx, by, 1),
-        args=(
-            cp.int32(width1),
-            cp.int32(height1),
-            cp.float32(resolution),
-            cp.float32(wavelength),
-            cp.float32(distance),
-            cp.float32(ratio),
-            filtercomplex,
-        ),
-    )
-    data *= filtercomplex
-
-    data = ifft2(data, axes=(-2, -1), overwrite_x=True, norm="forward")
-
-    post_kernel = cp.ElementwiseKernel(
-        "C pci1, raw float32 increment, raw float32 ratio, raw float32 fft_scale",
-        "T out",
-        "out = -0.5 * ratio * log(abs(pci1) * fft_scale + increment)",
-        name="paganin_post_proc",
-        no_return=True,
-    )
-    fft_scale = 1.0 / (data.shape[1] * data.shape[2])
-    res = cp.empty((data.shape[0], height, width), dtype=cp.float32)
-    post_kernel(
-        data[:, pad_y : pad_y + height, pad_x : pad_x + width],
-        np.float32(increment),
-        np.float32(ratio),
-        np.float32(fft_scale),
-        res,
-    )
-    return res
-
-
-def _wavelength(energy: float) -> float:
-    SPEED_OF_LIGHT = 299792458e2  # [cm/s]
-    PLANCK_CONSTANT = 6.58211928e-19  # [keV*s]
-    return 2 * math.pi * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy
-
-
-def _reciprocal_grid(pixel_size: float, shape_proj: tuple) -> cp.ndarray:
-    """
-    Calculate reciprocal grid.
-
-    Parameters
-    ----------
-    pixel_size : float
-        Detector pixel size in cm.
-    shape_proj : tuple
-        Shape of the reciprocal grid along x and y axes.
-
-    Returns
-    -------
-    ndarray
-        Grid coordinates.
-    """
-    # Sampling in reciprocal space.
-    indx = _reciprocal_coord(pixel_size, shape_proj[0])
-    indy = _reciprocal_coord(pixel_size, shape_proj[1])
-    indx_sq = cp.square(indx)
-    indy_sq = cp.square(indy)
-
-    return cp.add.outer(indx_sq, indy_sq)
-
-
-def _reciprocal_coord(pixel_size: float, num_grid: int) -> cp.ndarray:
-    """
-    Calculate reciprocal grid coordinates for a given pixel size
-    and discretization.
-
-    Parameters
-    ----------
-    pixel_size : float
-        Detector pixel size in cm.
-    num_grid : int
-        Size of the reciprocal grid.
-
-    Returns
-    -------
-    ndarray
-        Grid coordinates.
-    """
-    n = num_grid - 1
-    rc = cp.arange(-n, num_grid, 2, dtype=cp.float32)
-    rc *= 2 * math.pi / (n * pixel_size)
-    return rc
-
-
-##-------------------------------------------------------------##
 ##-------------------------------------------------------------##
 # Adaptation of retrieve_phase (Paganin filter) from TomoPy
 def paganin_filter_tomopy(
@@ -287,7 +70,7 @@ def paganin_filter_tomopy(
     energy : float, optional
         Energy of incident wave in keV.
     alpha : float, optional
-        Regularization parameter, the ratio of delta/beta. Larger values lead to more smoothing.
+        Regularization parameter, the ratio of delta/beta. Smaller values lead to less noise and more blur.
 
     Returns
     -------
@@ -412,3 +195,57 @@ def _pad_projections_to_second_power(
 def _paganin_filter_factor2(energy, dist, alpha, w2):
     # Alpha represents the ratio of delta/beta.
     return 1 / (_wavelength(energy) * dist * w2 / (4 * math.pi) + alpha)
+
+
+def _wavelength(energy: float) -> float:
+    SPEED_OF_LIGHT = 299792458e2  # [cm/s]
+    PLANCK_CONSTANT = 6.58211928e-19  # [keV*s]
+    return 2 * math.pi * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy
+
+
+def _reciprocal_grid(pixel_size: float, shape_proj: tuple) -> cp.ndarray:
+    """
+    Calculate reciprocal grid.
+
+    Parameters
+    ----------
+    pixel_size : float
+        Detector pixel size in cm.
+    shape_proj : tuple
+        Shape of the reciprocal grid along x and y axes.
+
+    Returns
+    -------
+    ndarray
+        Grid coordinates.
+    """
+    # Sampling in reciprocal space.
+    indx = _reciprocal_coord(pixel_size, shape_proj[0])
+    indy = _reciprocal_coord(pixel_size, shape_proj[1])
+    indx_sq = cp.square(indx)
+    indy_sq = cp.square(indy)
+
+    return cp.add.outer(indx_sq, indy_sq)
+
+
+def _reciprocal_coord(pixel_size: float, num_grid: int) -> cp.ndarray:
+    """
+    Calculate reciprocal grid coordinates for a given pixel size
+    and discretization.
+
+    Parameters
+    ----------
+    pixel_size : float
+        Detector pixel size in cm.
+    num_grid : int
+        Size of the reciprocal grid.
+
+    Returns
+    -------
+    ndarray
+        Grid coordinates.
+    """
+    n = num_grid - 1
+    rc = cp.arange(-n, num_grid, 2, dtype=cp.float32)
+    rc *= 2 * math.pi / (n * pixel_size)
+    return rc

{httomolibgpu-3.0 → httomolibgpu-3.1.1}/httomolibgpu/prep/stripe.py

@@ -143,8 +143,8 @@ def remove_stripe_ti(
 
     _, _, dx_orig = data.shape
     if (dx_orig % 2) != 0:
-        # the horizontal detector size is odd, data needs to be padded/cropped, for now raising the error
-        raise ValueError("The horizontal detector size must be even")
+        # if the horizontal detector size is odd, the data needs to be padded
+        data = cp.pad(data, ((0, 0), (0, 0), (0, 1)), mode="edge")
 
     gamma = beta * ((1 - beta) / (1 + beta)) ** cp.abs(
         cp.fft.fftfreq(data.shape[-1]) * data.shape[-1]
@@ -154,7 +154,11 @@ def remove_stripe_ti(
     v = v - v[:, 0:1]
     v = cp.fft.irfft(cp.fft.rfft(v) * cp.fft.rfft(gamma)).astype(data.dtype)
     data[:] += v
-    return data
+    if (dx_orig % 2) != 0:
+        # unpad
+        return data[:, :, :-1]
+    else:
+        return data
 
 
 ######## Optimized version for Vo-all ring removal in tomopy########

{httomolibgpu-3.0 → httomolibgpu-3.1.1}/httomolibgpu/recon/algorithm.py

@@ -37,8 +37,8 @@ else:
     RecToolsDIRCuPy = Mock()
     RecToolsIRCuPy = Mock()
 
-from numpy import float32, complex64
-from typing import Optional, Type
+from numpy import float32
+from typing import Optional, Type, Union
 
 from httomolibgpu.misc.supp_func import data_checker
 
@@ -49,6 +49,7 @@ __all__ = [
     "LPRec3d_tomobar",
     "SIRT3d_tomobar",
     "CGLS3d_tomobar",
+    "FISTA3d_tomobar",
 ]
 
 input_data_axis_labels = ["angles", "detY", "detX"]  # set the labels of the input data
@@ -59,7 +60,7 @@ def FBP2d_astra(
     data: np.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
-    detector_pad: int = 0,
+    detector_pad: Union[bool, int] = False,
     filter_type: str = "ram-lak",
     filter_parameter: Optional[float] = None,
     filter_d: Optional[float] = None,
@@ -81,8 +82,9 @@ def FBP2d_astra(
         An array of angles given in radians.
     center : float, optional
         The center of rotation (CoR).
-    detector_pad : int
-        Detector width padding with edge values to remove circle/arc type artifacts in the reconstruction.
+    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.
     filter_type: str
         Type of projection filter, see ASTRA's API for all available options for filters.
     filter_parameter: float, optional
@@ -95,7 +97,7 @@ def FBP2d_astra(
     recon_mask_radius: float
         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.
-        It is recommended to keep the value in the range [0.7-1.0].
+        To implement the cropping one can use the range [0.7-1.0] or set to 2.0 when no cropping required.
     neglog: bool
         Take negative logarithm on input data to convert to attenuation coefficient or a density of the scanned object. Defaults to False,
         assuming that the negative log is taken either in normalisation procedure on with Paganin filter application.
@@ -119,7 +121,7 @@ def FBP2d_astra(
 
     detY_size = data_shape[1]
     reconstruction = np.empty(
-        (recon_size, detY_size, recon_size), dtype=np.float32(), order="C"
+        (recon_size, detY_size, recon_size), dtype=float32, order="C"
     )
     _take_neg_log_np(data) if neglog else data
 
@@ -142,7 +144,7 @@ def FBP3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
-    detector_pad: int = 0,
+    detector_pad: Union[bool, int] = False,
     filter_freq_cutoff: float = 0.35,
     recon_size: Optional[int] = None,
     recon_mask_radius: Optional[float] = 0.95,
@@ -152,7 +154,7 @@ def FBP3d_tomobar(
     """
     Perform Filtered Backprojection (FBP) reconstruction using ASTRA toolbox :cite:`van2016fast` and
     ToMoBAR :cite:`kazantsev2020tomographic` wrappers.
-    This is a 3D recon from the CuPy array directly and using a custom built SINC filter for filtration in Fourier space, 
+    This is a 3D recon from the CuPy array directly and using a custom built SINC filter for filtration in Fourier space,
     see more in :ref:`method_FBP3d_tomobar`.
 
     Parameters
@@ -163,17 +165,18 @@ def FBP3d_tomobar(
         An array of angles given in radians.
     center : float, optional
         The center of rotation (CoR).
-    detector_pad : int
-        Detector width padding with edge values to remove circle/arc type artifacts in the reconstruction.
+    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.
     filter_freq_cutoff : float
-        Cutoff frequency parameter for the SINC filter, the lower values may produce better contrast but noisy reconstruction. The filter change will also affect the dynamic range of the reconstructed image. 
+        Cutoff frequency parameter for the SINC filter, the lower values may produce better contrast but noisy reconstruction. The filter change will also affect the dynamic range of the reconstructed image.
     recon_size : int, optional
         The [recon_size, recon_size] shape of the reconstructed slice in pixels.
         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.
-        It is recommended to keep the value in the range [0.7-1.0].
+        To implement the cropping one can use the range [0.7-1.0] or set to 2.0 when no cropping required.
     neglog: bool
         Take negative logarithm on input data to convert to attenuation coefficient or a density of the scanned object. Defaults to False,
         assuming that the negative log is taken either in normalisation procedure on with Paganin filter application.
@@ -206,11 +209,15 @@ def LPRec3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
-    detector_pad: int = 0,
+    detector_pad: Union[bool, int] = False,
     filter_type: str = "shepp",
     filter_freq_cutoff: float = 1.0,
     recon_size: Optional[int] = None,
-    recon_mask_radius: Optional[float] = 0.95,
+    recon_mask_radius: float = 0.95,
+    power_of_2_oversampling: Optional[bool] = True,
+    power_of_2_cropping: Optional[bool] = True,
+    min_mem_usage_filter: Optional[bool] = False,
+    min_mem_usage_ifft2: Optional[bool] = False,
     neglog: bool = False,
 ) -> cp.ndarray:
     """
@@ -226,8 +233,9 @@ def LPRec3d_tomobar(
         An array of angles given in radians.
     center : float, optional
         The center of rotation (CoR).
-    detector_pad : int
-        Detector width padding with edge values to remove circle/arc type artifacts in the reconstruction.
+    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.
     filter_type : str
         Filter type, the accepted strings are: none, ramp, shepp, cosine, cosine2, hamming, hann, parzen.
     filter_freq_cutoff : float
@@ -235,10 +243,10 @@ def LPRec3d_tomobar(
     recon_size : int, optional
         The [recon_size, recon_size] shape of the reconstructed slice in pixels.
         By default (None), the reconstructed size will be the dimension of the horizontal detector.
-    recon_mask_radius: float, optional
+    recon_mask_radius: float
         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.
-        It is recommended to keep the value in the range [0.7-1.0].
+        To implement the cropping one can use the range [0.7-1.0] or set to 2.0 when no cropping required.
     neglog: bool
         Take negative logarithm on input data to convert to attenuation coefficient or a density of the scanned object. Defaults to False,
         assuming that the negative log is taken either in normalisation procedure on with Paganin filter application.
@@ -261,6 +269,10 @@ def LPRec3d_tomobar(
         data_axes_labels_order=input_data_axis_labels,
         filter_type=filter_type,
         cutoff_freq=filter_freq_cutoff,
+        power_of_2_oversampling=power_of_2_oversampling,
+        power_of_2_cropping=power_of_2_cropping,
+        min_mem_usage_filter=min_mem_usage_filter,
+        min_mem_usage_ifft2=min_mem_usage_ifft2,
     )
     cp._default_memory_pool.free_all_blocks()
     return cp.require(cp.swapaxes(reconstruction, 0, 1), requirements="C")
@@ -271,10 +283,11 @@ def SIRT3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
-    detector_pad: int = 0,
+    detector_pad: Union[bool, int] = False,
     recon_size: Optional[int] = None,
-    iterations: Optional[int] = 300,
-    nonnegativity: Optional[bool] = True,
+    recon_mask_radius: float = 0.95,
+    iterations: int = 300,
+    nonnegativity: bool = True,
     neglog: bool = False,
     gpu_id: int = 0,
 ) -> cp.ndarray:
@@ -292,19 +305,24 @@ def SIRT3d_tomobar(
         An array of angles given in radians.
     center : float, optional
         The center of rotation (CoR).
-    detector_pad : int
-        Detector width padding with edge values to remove circle/arc type artifacts in the reconstruction.
+    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 [recon_size, recon_size] shape of the reconstructed slice in pixels.
         By default (None), the reconstructed size will be the dimension of the horizontal detector.
-    iterations : int, optional
+    recon_mask_radius: float
+        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 2.0 when no cropping required.
+    iterations : int
         The number of SIRT iterations.
-    nonnegativity : bool, optional
+    nonnegativity : bool
         Impose nonnegativity constraint on reconstructed image.
     neglog: bool
         Take negative logarithm on input data to convert to attenuation coefficient or a density of the scanned object. Defaults to False,
         assuming that the negative log is taken either in normalisation procedure on with Paganin filter application.
-    gpu_id : int, optional
+    gpu_id : int
         A GPU device index to perform operation on.
 
     Returns
@@ -331,6 +349,7 @@ def SIRT3d_tomobar(
     _algorithm_ = {
         "iterations": iterations,
         "nonnegativity": nonnegativity,
+        "recon_mask_radius": recon_mask_radius,
     }
     reconstruction = RecToolsCP.SIRT(_data_, _algorithm_)
     cp._default_memory_pool.free_all_blocks()
@@ -342,10 +361,11 @@ def CGLS3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
-    detector_pad: int = 0,
+    detector_pad: Union[bool, int] = False,
     recon_size: Optional[int] = None,
-    iterations: Optional[int] = 20,
-    nonnegativity: Optional[bool] = True,
+    recon_mask_radius: float = 0.95,
+    iterations: int = 20,
+    nonnegativity: bool = True,
     neglog: bool = False,
     gpu_id: int = 0,
 ) -> cp.ndarray:
@@ -363,14 +383,19 @@ def CGLS3d_tomobar(
         An array of angles given in radians.
     center : float, optional
         The center of rotation (CoR).
-    detector_pad : int
-        Detector width padding with edge values to remove circle/arc type artifacts in the reconstruction.
+    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 [recon_size, recon_size] shape of the reconstructed slice in pixels.
         By default (None), the reconstructed size will be the dimension of the horizontal detector.
-    iterations : int, optional
+    recon_mask_radius: float
+        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 2.0 when no cropping required.
+    iterations : int
         The number of CGLS iterations.
-    nonnegativity : bool, optional
+    nonnegativity : bool
         Impose nonnegativity constraint on reconstructed image.
     neglog: bool
         Take negative logarithm on input data to convert to attenuation coefficient or a density of the scanned object. Defaults to False,
@@ -393,18 +418,119 @@ def CGLS3d_tomobar(
         "projection_norm_data": _take_neg_log(data) if neglog else data,
         "data_axes_labels_order": input_data_axis_labels,
     }  # data dictionary
-    _algorithm_ = {"iterations": iterations, "nonnegativity": nonnegativity}
+    _algorithm_ = {
+        "iterations": iterations,
+        "nonnegativity": nonnegativity,
+        "recon_mask_radius": recon_mask_radius,
+    }
     reconstruction = RecToolsCP.CGLS(_data_, _algorithm_)
     cp._default_memory_pool.free_all_blocks()
     return cp.require(cp.swapaxes(reconstruction, 0, 1), requirements="C")
 
 
+## %%%%%%%%%%%%%%%%%%%%%%% FISTA reconstruction %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
+def FISTA3d_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: float = 0.95,
+    iterations: int = 20,
+    subsets_number: int = 6,
+    regularisation_type: str = "PD_TV",
+    regularisation_parameter: float = 0.000001,
+    regularisation_iterations: int = 50,
+    regularisation_half_precision: bool = True,
+    nonnegativity: bool = True,
+    neglog: bool = False,
+    gpu_id: int = 0,
+) -> cp.ndarray:
+    """
+    A Fast Iterative Shrinkage-Thresholding Algorithm :cite:`beck2009fast` with various types of regularisation or
+    denoising operations :cite:`kazantsev2019ccpi` (currently accepts ROF_TV and PD_TV regularisations only).
+
+    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 [recon_size, recon_size] shape of the reconstructed slice in pixels.
+        By default (None), the reconstructed size will be the dimension of the horizontal detector.
+    recon_mask_radius: float
+        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 2.0 when no cropping required.
+    iterations : int
+        The number of FISTA algorithm iterations.
+    subsets_number: int
+        The number of the ordered subsets to accelerate convergence. Keep the value bellow 10 to avoid divergence.
+    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.
+    neglog: bool
+        Take negative logarithm on input data to convert to attenuation coefficient or a density of the scanned object. Defaults to False,
+        assuming that the negative log is taken either in normalisation procedure on with Paganin filter application.
+    gpu_id : int
+        A GPU device index to perform operation on.
+
+    Returns
+    -------
+    cp.ndarray
+        The FISTA reconstructed volume as a CuPy array.
+    """
+    data = data_checker(data, verbosity=True, method_name="FISTA3d_tomobar")
+
+    RecToolsCP = _instantiate_iterative_recon_class(
+        data, angles, center, detector_pad, recon_size, gpu_id, datafidelity="LS"
+    )
+
+    _data_ = {
+        "projection_norm_data": _take_neg_log(data) if neglog else data,
+        "OS_number": subsets_number,
+        "data_axes_labels_order": input_data_axis_labels,
+    }
+    lc = RecToolsCP.powermethod(_data_)  # calculate Lipschitz constant (run once)
+
+    _algorithm_ = {
+        "iterations": iterations,
+        "lipschitz_const": lc.get(),
+        "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.FISTA(_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,
     angles: np.ndarray,
     center: Optional[float] = None,
-    detector_pad: int = 0,
+    detector_pad: Union[bool, int] = False,
     recon_size: Optional[int] = None,
     gpu_id: int = 0,
 ) -> Type:
@@ -414,7 +540,7 @@ def _instantiate_direct_recon_class(
         data (cp.ndarray): data array
         angles (np.ndarray): angles
         center (Optional[float], optional): center of recon. Defaults to None.
-        detector_pad (int): Detector width padding. Defaults to 0.
+        detector_pad : (Union[bool, int]) : Detector width padding. Defaults to False.
         recon_size (Optional[int], optional): recon_size. Defaults to None.
         gpu_id (int, optional): gpu ID. Defaults to 0.
 
@@ -425,6 +551,10 @@ def _instantiate_direct_recon_class(
         center = data.shape[2] // 2  # making a crude guess
     if recon_size is None:
         recon_size = data.shape[2]
+    if detector_pad is True:
+        detector_pad = __estimate_detectorHoriz_padding(data.shape[2])
+    elif detector_pad is False:
+        detector_pad = 0
     RecToolsCP = RecToolsDIRCuPy(
         DetectorsDimH=data.shape[2],  # Horizontal detector dimension
         DetectorsDimH_pad=detector_pad,  # padding for horizontal detector
@@ -444,7 +574,7 @@ def _instantiate_direct_recon2d_class(
     data: np.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
-    detector_pad: int = 0,
+    detector_pad: Union[bool, int] = False,
     recon_size: Optional[int] = None,
     gpu_id: int = 0,
 ) -> Type:
@@ -454,7 +584,7 @@ def _instantiate_direct_recon2d_class(
         data (cp.ndarray): data array
         angles (np.ndarray): angles
         center (Optional[float], optional): center of recon. Defaults to None.
-        detector_pad (int): Detector width padding. Defaults to 0.
+        detector_pad : (Union[bool, int]) : Detector width padding. Defaults to False.
         recon_size (Optional[int], optional): recon_size. Defaults to None.
         gpu_id (int, optional): gpu ID. Defaults to 0.
 
@@ -465,6 +595,10 @@ def _instantiate_direct_recon2d_class(
         center = data.shape[2] // 2  # making a crude guess
     if recon_size is None:
         recon_size = data.shape[2]
+    if detector_pad is True:
+        detector_pad = __estimate_detectorHoriz_padding(data.shape[2])
+    elif detector_pad is False:
+        detector_pad = 0
     RecTools = RecToolsDIR(
         DetectorsDimH=data.shape[2],  # Horizontal detector dimension
         DetectorsDimH_pad=detector_pad,  # padding for horizontal detector
@@ -483,7 +617,7 @@ def _instantiate_iterative_recon_class(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
-    detector_pad: int = 0,
+    detector_pad: Union[bool, int] = False,
     recon_size: Optional[int] = None,
     gpu_id: int = 0,
     datafidelity: str = "LS",
@@ -494,7 +628,7 @@ def _instantiate_iterative_recon_class(
         data (cp.ndarray): data array
         angles (np.ndarray): angles
         center (Optional[float], optional): center of recon. Defaults to None.
-        detector_pad (int): Detector width padding. Defaults to 0.
+        detector_pad : (Union[bool, int]) : Detector width padding. Defaults to False.
         recon_size (Optional[int], optional): recon_size. Defaults to None.
         datafidelity (str, optional): Data fidelity
         gpu_id (int, optional): gpu ID. Defaults to 0.
@@ -506,6 +640,10 @@ def _instantiate_iterative_recon_class(
         center = data.shape[2] // 2  # making a crude guess
     if recon_size is None:
         recon_size = data.shape[2]
+    if detector_pad is True:
+        detector_pad = __estimate_detectorHoriz_padding(data.shape[2])
+    elif detector_pad is False:
+        detector_pad = 0
     RecToolsCP = RecToolsIRCuPy(
         DetectorsDimH=data.shape[2],  # Horizontal detector dimension
         DetectorsDimH_pad=detector_pad,  # padding for horizontal detector
@@ -537,3 +675,10 @@ def _take_neg_log_np(data: np.ndarray) -> np.ndarray:
     data[np.isnan(data)] = 6.0
     data[np.isinf(data)] = 0
     return data
+
+
+def __estimate_detectorHoriz_padding(detX_size) -> int:
+    det_half = detX_size // 2
+    padded_value_exact = int(np.sqrt(2 * (det_half**2))) - det_half
+    padded_add_margin = int(0.1 * padded_value_exact)
+    return padded_value_exact + padded_add_margin

{httomolibgpu-3.0 → httomolibgpu-3.1.1/httomolibgpu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 3.0
+Version: 3.1.1
 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
@@ -19,7 +19,6 @@ Requires-Dist: scipy
 Requires-Dist: pillow
 Requires-Dist: scikit-image
 Requires-Dist: tomobar
-Requires-Dist: ccpi-regularisation-cupy
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

{httomolibgpu-3.0 → httomolibgpu-3.1.1}/httomolibgpu.egg-info/SOURCES.txt

@@ -14,7 +14,6 @@ httomolibgpu/cuda_kernels/calc_metrics.cu
 httomolibgpu/cuda_kernels/center_360_shifts.cu
 httomolibgpu/cuda_kernels/generate_mask.cu
 httomolibgpu/cuda_kernels/median_kernel.cu
-httomolibgpu/cuda_kernels/paganin_filter_gen.cu
 httomolibgpu/cuda_kernels/raven_filter.cu
 httomolibgpu/cuda_kernels/remove_nan_inf.cu
 httomolibgpu/misc/__init__.py

{httomolibgpu-3.0 → httomolibgpu-3.1.1}/httomolibgpu.egg-info/requires.txt

@@ -5,7 +5,6 @@ scipy
 pillow
 scikit-image
 tomobar
-ccpi-regularisation-cupy
 
 [dev]
 pytest

{httomolibgpu-3.0 → httomolibgpu-3.1.1}/pyproject.toml

@@ -44,7 +44,6 @@ dependencies = [
     "pillow",
     "scikit-image",
     "tomobar",
-    "ccpi-regularisation-cupy",
 ]
 
 [project.optional-dependencies]

httomolibgpu-3.0/httomolibgpu/cuda_kernels/paganin_filter_gen.cu

@@ -1,37 +0,0 @@
-#include <cupy/complex.cuh>
-
-#ifndef M_PI
-#define M_PI 3.1415926535897932384626433832795f
-#endif
-
-extern "C" __global__ void
-paganin_filter_gen(int width1, int height1, float resolution, float wavelength,
-                   float distance, float ratio, complex<float> *filtercomplex) {
-  int px = threadIdx.x + blockIdx.x * blockDim.x;
-  int py = threadIdx.y + blockIdx.y * blockDim.y;
-  if (px >= width1)
-    return;
-  if (py >= height1)
-    return;
-
-  float dpx = 1.0f / (width1 * resolution);
-  float dpy = 1.0f / (height1 * resolution);
-  int centerx = (width1 + 1) / 2 - 1;
-  int centery = (height1 + 1) / 2 - 1;
-
-  float pxx = (px - centerx) * dpx;
-  float pyy = (py - centery) * dpy;
-  float pd = (pxx * pxx + pyy * pyy) * wavelength * distance * M_PI;
-             ;
-  float filter1 = 1.0f + ratio * pd;
-
-  complex<float> value = 1.0f / complex<float>(filter1, filter1);
-
-  // ifftshifting positions
-  int xshift = (width1 + 1) / 2;
-  int yshift = (height1 + 1) / 2;
-  int outX = (px + xshift) % width1;
-  int outY = (py + yshift) % height1;
-
-  filtercomplex[outY * width1 + outX] = value;
-}