httomolibgpu 2.7.1__py3-none-any.whl → 3.1__py3-none-any.whl

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/misc/corr.py

@@ -114,7 +114,7 @@ def median_filter(
 
 
 def remove_outlier(
-    data: cp.ndarray, kernel_size: int = 3, dif: float = 0.1
+    data: cp.ndarray, kernel_size: int = 3, dif: float = 1000
 ) -> cp.ndarray:
     """Selectively applies 3D median filter to a 3D CuPy array to remove outliers. Also called a dezinger.
     For more detailed information, see :ref:`method_outlier_removal`.
@@ -126,8 +126,8 @@ def remove_outlier(
     kernel_size : int, optional
         The size of the filter's kernel (a diameter).
     dif : float, optional
-        Expected difference value between outlier value and the
-        median value of the array.
+        Expected difference value between the outlier value (central voxel) and the
+        median value of the neighbourhood. Lower values lead to median filtering.
 
     Returns
     -------

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/misc/rescale.py

@@ -24,32 +24,32 @@ import numpy as np
 from httomolibgpu import cupywrapper
 
 cp = cupywrapper.cp
-cupy_run = cupywrapper.cupy_run
 
 from typing import Literal, Optional, Tuple, Union
 
 from httomolibgpu.misc.supp_func import data_checker
 
+
 __all__ = [
     "rescale_to_int",
 ]
 
 
 def rescale_to_int(
-    data: Union[np.ndarray, cp.ndarray],
+    data: cp.ndarray,
     perc_range_min: float = 0.0,
     perc_range_max: float = 100.0,
     bits: Literal[8, 16, 32] = 8,
     glob_stats: Optional[Tuple[float, float, float, int]] = None,
-) -> Union[np.ndarray, cp.ndarray]:
+) -> cp.ndarray:
     """
     Rescales the data given as float32 type and converts it into the range of an unsigned integer type
     with the given number of bits. For more detailed information and examples, see :ref:`method_rescale_to_int`.
 
     Parameters
     ----------
-    data : Union[np.ndarray, cp.ndarray]
-        Input data as a numpy or cupy array (the function is cpu-gpu agnostic)
+    data : cp.ndarray
+        Input data as a cupy array
     perc_range_min: float, optional
         The lower cutoff point in the input data, in percent of the data range (defaults to 0).
         The lower bound is computed as min + perc_range_min/100*(max-min)
@@ -69,7 +69,7 @@ def rescale_to_int(
 
     Returns
     -------
-    Union[np.ndarray, cp.ndarray]
+    cp.ndarray
         The original data, clipped to the range specified with the perc_range_min and
         perc_range_max, and scaled to the full range of the output integer type
     """
@@ -82,18 +82,13 @@ def rescale_to_int(
 
     data = data_checker(data, verbosity=True, method_name="rescale_to_int")
 
-    if cupy_run:
-        xp = cp.get_array_module(data)
-    else:
-        import numpy as xp
-
     # get the min and max integer values of the output type
-    output_min = xp.iinfo(output_dtype).min
-    output_max = xp.iinfo(output_dtype).max
+    output_min = cp.iinfo(output_dtype).min
+    output_max = cp.iinfo(output_dtype).max
 
     if not isinstance(glob_stats, tuple):
-        min_value = float(xp.min(data))
-        max_value = float(xp.max(data))
+        min_value = float(cp.min(data))
+        max_value = float(cp.max(data))
     else:
         min_value = glob_stats[0]
         max_value = glob_stats[1]
@@ -102,32 +97,21 @@ def rescale_to_int(
     input_min = (perc_range_min * (range_intensity) / 100) + min_value
     input_max = (perc_range_max * (range_intensity) / 100) + min_value
 
+    factor = cp.float32(1.0)
     if (input_max - input_min) != 0.0:
-        factor = xp.float32((output_max - output_min) / (input_max - input_min))
-    else:
-        factor = 1.0
-
-    res = xp.empty(data.shape, dtype=output_dtype)
-    if xp.__name__ == "numpy":
-        if input_max == pow(2, 32):
-            input_max -= 1
-        res = np.copy(data.astype(float))
-        res[data.astype(float) < input_min] = int(input_min)
-        res[data.astype(float) > input_max] = int(input_max)
-        res -= input_min
-        res *= factor
-        res = output_dtype(res)
-    else:
-        rescale_kernel = cp.ElementwiseKernel(
-            "T x, raw T input_min, raw T input_max, raw T factor",
-            "O out",
-            """
-            T x_clean = isnan(x) || isinf(x) ? T(0) : x;
-            T x_clipped = x_clean < input_min ? input_min : (x_clean > input_max ? input_max : x_clean);
-            T x_rebased = x_clipped - input_min;
-            out = O(x_rebased * factor);
-            """,
-            "rescale_to_int",
-        )
-        rescale_kernel(data, input_min, input_max, factor, res)
+        factor = cp.float32((output_max - output_min) / (input_max - input_min))
+
+    res = cp.empty(data.shape, dtype=output_dtype)
+    rescale_kernel = cp.ElementwiseKernel(
+        "T x, raw T input_min, raw T input_max, raw T factor",
+        "O out",
+        """
+        T x_clean = isnan(x) || isinf(x) ? T(0) : x;
+        T x_clipped = x_clean < input_min ? input_min : (x_clean > input_max ? input_max : x_clean);
+        T x_rebased = x_clipped - input_min;
+        out = O(x_rebased * factor);
+        """,
+        "rescale_to_int",
+    )
+    rescale_kernel(data, input_min, input_max, factor, res)
     return res

httomolibgpu/misc/supp_func.py

@@ -159,10 +159,10 @@ 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. 
+    Currently it checks for: the presence of infs and nans in data.
 
     Parameters
     ----------

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/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/recon/algorithm.py

@@ -18,7 +18,7 @@
 # Created By  : Tomography Team at DLS <scientificsoftware@diamond.ac.uk>
 # Changes relative to ToMoBAR 2024.01 version
 # ---------------------------------------------------------------------------
-"""Module for tomographic reconstruction"""
+"""Module for tomographic reconstruction. For more detailed information see :ref:`image_reconstruction_module`"""
 
 import numpy as np
 from httomolibgpu import cupywrapper
@@ -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,6 +60,7 @@ def FBP2d_astra(
     data: np.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
+    detector_pad: Union[bool, int] = False,
     filter_type: str = "ram-lak",
     filter_parameter: Optional[float] = None,
     filter_d: Optional[float] = None,
@@ -70,8 +72,7 @@ def FBP2d_astra(
     """
     Perform Filtered Backprojection (FBP) reconstruction slice-by-slice (2d) using ASTRA toolbox :cite:`van2016fast` and
     ToMoBAR :cite:`kazantsev2020tomographic` wrappers.
-    This is a 2D recon using ASTRA's API for the FBP method, see for more parameters ASTRA's documentation here:
-    https://astra-toolbox.com/docs/algs/FBP_CUDA.html.
+    This is a 2D recon using ASTRA's API for the FBP_CUDA method, see more in :ref:`method_FBP2d_astra`.
 
     Parameters
     ----------
@@ -81,6 +82,9 @@ def FBP2d_astra(
         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.
     filter_type: str
         Type of projection filter, see ASTRA's API for all available options for filters.
     filter_parameter: float, optional
@@ -93,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.
@@ -112,12 +116,12 @@ def FBP2d_astra(
         recon_size = data_shape[2]
 
     RecTools = _instantiate_direct_recon2d_class(
-        data, angles, center, recon_size, gpu_id
+        data, angles, center, detector_pad, recon_size, gpu_id
     )
 
     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
 
@@ -140,6 +144,7 @@ def FBP3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
+    detector_pad: Union[bool, int] = False,
     filter_freq_cutoff: float = 0.35,
     recon_size: Optional[int] = None,
     recon_mask_radius: Optional[float] = 0.95,
@@ -149,7 +154,8 @@ 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
     ----------
@@ -159,15 +165,18 @@ def FBP3d_tomobar(
         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.
     filter_freq_cutoff : float
-        Cutoff frequency parameter for the SINC filter, the lower values produce better contrast but noisy reconstruction.
+        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.
@@ -182,7 +191,7 @@ def FBP3d_tomobar(
     data = data_checker(data, verbosity=True, method_name="FBP3d_tomobar")
 
     RecToolsCP = _instantiate_direct_recon_class(
-        data, angles, center, recon_size, gpu_id
+        data, angles, center, detector_pad, recon_size, gpu_id
     )
 
     reconstruction = RecToolsCP.FBP(
@@ -200,16 +209,20 @@ def LPRec3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
+    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,
+    min_mem_usage_filter: Optional[bool] = False,
+    min_mem_usage_ifft2: Optional[bool] = False,
     neglog: bool = False,
 ) -> cp.ndarray:
     """
     Fourier direct inversion in 3D on unequally spaced (also called as Log-Polar) grids using
     CuPy array as an input. This implementation follows V. Nikitin's CUDA-C implementation and TomoCuPy package.
-    :cite:`andersson2016fast`.
+    :cite:`andersson2016fast`, see more in :ref:`method_LPRec3d_tomobar`.
 
     Parameters
     ----------
@@ -219,17 +232,20 @@ def LPRec3d_tomobar(
         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.
     filter_type : str
         Filter type, the accepted strings are: none, ramp, shepp, cosine, cosine2, hamming, hann, parzen.
     filter_freq_cutoff : float
-        Cutoff frequency parameter for a filter. The higher values increase the resolution but also amplify the noise.
+        Cutoff frequency parameter for a filter.
     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.
@@ -242,7 +258,9 @@ def LPRec3d_tomobar(
 
     data = data_checker(data, verbosity=True, method_name="LPRec3d_tomobar")
 
-    RecToolsCP = _instantiate_direct_recon_class(data, angles, center, recon_size, 0)
+    RecToolsCP = _instantiate_direct_recon_class(
+        data, angles, center, detector_pad, recon_size, 0
+    )
 
     reconstruction = RecToolsCP.FOURIER_INV(
         _take_neg_log(data) if neglog else data,
@@ -250,6 +268,9 @@ 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,
+        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")
@@ -260,9 +281,11 @@ def SIRT3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
+    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:
@@ -280,17 +303,24 @@ def SIRT3d_tomobar(
         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.
-    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
@@ -304,6 +334,7 @@ def SIRT3d_tomobar(
         data,
         angles,
         center,
+        detector_pad,
         recon_size,
         gpu_id,
         datafidelity="LS",
@@ -316,6 +347,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()
@@ -327,9 +359,11 @@ def CGLS3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
+    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:
@@ -347,12 +381,19 @@ def CGLS3d_tomobar(
         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.
-    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,
@@ -368,24 +409,126 @@ def CGLS3d_tomobar(
     data = data_checker(data, verbosity=True, method_name="CGLS3d_tomobar")
 
     RecToolsCP = _instantiate_iterative_recon_class(
-        data, angles, center, recon_size, gpu_id, datafidelity="LS"
+        data, angles, center, detector_pad, recon_size, gpu_id, datafidelity="LS"
     )
 
     _data_ = {
         "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: Union[bool, int] = False,
     recon_size: Optional[int] = None,
     gpu_id: int = 0,
 ) -> Type:
@@ -395,6 +538,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 : (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.
 
@@ -405,8 +549,13 @@ 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
         DetectorsDimV=data.shape[1],  # Vertical detector dimension (3D case)
         CenterRotOffset=data.shape[2] / 2
         - center
@@ -423,6 +572,7 @@ def _instantiate_direct_recon2d_class(
     data: np.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
+    detector_pad: Union[bool, int] = False,
     recon_size: Optional[int] = None,
     gpu_id: int = 0,
 ) -> Type:
@@ -432,6 +582,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 : (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.
 
@@ -442,8 +593,13 @@ 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
         DetectorsDimV=None,  # 2d case
         CenterRotOffset=data.shape[2] / 2
         - center
@@ -459,6 +615,7 @@ def _instantiate_iterative_recon_class(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
+    detector_pad: Union[bool, int] = False,
     recon_size: Optional[int] = None,
     gpu_id: int = 0,
     datafidelity: str = "LS",
@@ -469,6 +626,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 : (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.
@@ -480,8 +638,13 @@ 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
         DetectorsDimV=data.shape[1],  # Vertical detector dimension (3D case)
         CenterRotOffset=data.shape[2] / 2
         - center
@@ -510,3 +673,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-2.7.1.dist-info → httomolibgpu-3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 2.7.1
+Version: 3.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"
@@ -71,7 +70,7 @@ Conda environment
 
    $ conda create --name httomolibgpu # create a fresh conda environment
    $ conda activate httomolibgpu # activate the environment
-   $ conda install -c conda-forge cupy==12.3.0 # for linux users
+   $ conda install conda-forge::cupy==12.3.0
    $ pip install httomolibgpu
 
 Setup the development environment:

{httomolibgpu-2.7.1.dist-info → httomolibgpu-3.1.dist-info}/RECORD

@@ -1,29 +1,28 @@
-httomolibgpu/__init__.py,sha256=nLXdPpzb6smp80bCciANQHJq0o-mmMJkuga-PitGmzw,820
+httomolibgpu/__init__.py,sha256=sz3ia5rSjC4lj6Xw4VZekh3OxmeVB2E2747bzyHqQdY,838
 httomolibgpu/cupywrapper.py,sha256=6ITGJ2Jw5I5kVmKEL5LlsnLRniEqqBLsHiAjvLtk0Xk,493
 httomolibgpu/cuda_kernels/__init__.py,sha256=VQNMaGcVDwiE-C64FfLtubHpLriLG0Y3_QnjHBSHrN0,884
 httomolibgpu/cuda_kernels/calc_metrics.cu,sha256=oV7ZPcwjWafmZjbNsUkBYPvOViJ_nX3zBoOAuPCmIrA,11335
 httomolibgpu/cuda_kernels/center_360_shifts.cu,sha256=Ya_8hxjXGtPBsPY3qfGJaugwnYrTFjFFretRcLiUfFQ,1631
 httomolibgpu/cuda_kernels/generate_mask.cu,sha256=3il3r1J2cnTCd3UXO4GWGfBgGxj4pvrZnXviW_SXpO0,2650
 httomolibgpu/cuda_kernels/median_kernel.cu,sha256=EECLUCoJkT9GQ9Db_FF6fYOG6cDSiAePTRZNxE4VZ68,1692
-httomolibgpu/cuda_kernels/paganin_filter_gen.cu,sha256=REvnVqsg-Frev7S_SBi8jKVFHPwWlIxGfCV4NUJaO58,1099
 httomolibgpu/cuda_kernels/raven_filter.cu,sha256=KX2TM_9tMpvoGCHezDNWYABCnv2cT9mlMo4IhxRUac0,1437
 httomolibgpu/cuda_kernels/remove_nan_inf.cu,sha256=gv0ihkf6A_D_po9x7pmgFsQFhwZ1dB_HYc_0Tu-bpUU,630
 httomolibgpu/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-httomolibgpu/misc/corr.py,sha256=ZRkDv_RmrRbL-Mr3uNaj2joEjcq6ImRlTDrWD75EtXw,4597
-httomolibgpu/misc/denoise.py,sha256=6dpsEjnkew-hG6BxR2crTQLfPLhqs2jvrCiJ3XJolYw,4728
+httomolibgpu/misc/corr.py,sha256=1tUjwMku-MAPiLaH9IFe3zmF0p6rJFLruoObXSZelXY,4665
+httomolibgpu/misc/denoise.py,sha256=l5FVdpur1I6YQcJJBfYTKjEsiDNyRYtpdOQZ7ZHicJw,4997
 httomolibgpu/misc/morph.py,sha256=AlLk_kGFHF6vNrdICMpsXmTUDnCc7ey97-_DqwZb3Wc,7475
-httomolibgpu/misc/rescale.py,sha256=ODO-WI3jmfyVIcfMsD_Pb39hUt4YiHqIWncpemuFhks,5058
-httomolibgpu/misc/supp_func.py,sha256=g68-YLg8sHcq7qZEC5LbgbTF2iHslQnU1BUg6mLxvjg,6228
+httomolibgpu/misc/rescale.py,sha256=K4VQ1AdxOAhe8tTSVb9VXVZsjBap5VlOtxHVdf9MU08,4416
+httomolibgpu/misc/supp_func.py,sha256=yDzNmRlIlIikQ4sKd2y9trQ9yQtblECmQ2JM5vmIY5I,6233
 httomolibgpu/prep/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 httomolibgpu/prep/alignment.py,sha256=BuFTfLZD5_THQAKP_ikQ3fRE8JpN-JItGllZgrHRU5s,5657
 httomolibgpu/prep/normalize.py,sha256=ozVUAs4UY2DY7MQtJKllUgahp_4wRFKPuc_3iQl6bCE,4879
-httomolibgpu/prep/phase.py,sha256=KyzLJKq6ft1WexvjojpDiVwyCSGkar6DMOQEawW_olo,12043
-httomolibgpu/prep/stripe.py,sha256=-KRZHMSs2xkfCzPQGOl2RbLtV3VAr7tulMui36brdP8,15093
+httomolibgpu/prep/phase.py,sha256=zIuAVqlnHVqcDUBtj40NRBoHaO7O2KqGZ5CCUABRXBQ,7282
+httomolibgpu/prep/stripe.py,sha256=YgOVb7Z5H7NFM3d2Y1jfNNwwj7ZMDv9nMZMMCvdBnVM,15150
 httomolibgpu/recon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-httomolibgpu/recon/algorithm.py,sha256=Lqp3o8e_P-PyOTssqlmdFO0k0fArc5pNM_0i8rQFT2E,19460
+httomolibgpu/recon/algorithm.py,sha256=EL0Y5xVkXR4tau5BYkEesekLxfSneIWmDdgEjfHDQ0o,27978
 httomolibgpu/recon/rotation.py,sha256=k_E0lBRprJz6AGclagIkrzk_9dipADxPtL5BxrggSwM,27729
-httomolibgpu-2.7.1.dist-info/licenses/LICENSE,sha256=bXeLsgelPUUXw8HCIYiVC97Dpjhm2nB54m7TACdH8ng,48032
-httomolibgpu-2.7.1.dist-info/METADATA,sha256=2TTgpJesuIdRsJ-6cG36ZrpbLN7IxiulljVWN3MBZo4,3401
-httomolibgpu-2.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-httomolibgpu-2.7.1.dist-info/top_level.txt,sha256=nV0Ty_YvSPVd1O6MNWuIplD0w1nwk5hT76YgBZ-bzUw,13
-httomolibgpu-2.7.1.dist-info/RECORD,,
+httomolibgpu-3.1.dist-info/licenses/LICENSE,sha256=bXeLsgelPUUXw8HCIYiVC97Dpjhm2nB54m7TACdH8ng,48032
+httomolibgpu-3.1.dist-info/METADATA,sha256=fVcG2CipC75a2sSwXNFl9OPxNLmZHTC24VDCcnhX7gI,3339
+httomolibgpu-3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+httomolibgpu-3.1.dist-info/top_level.txt,sha256=nV0Ty_YvSPVd1O6MNWuIplD0w1nwk5hT76YgBZ-bzUw,13
+httomolibgpu-3.1.dist-info/RECORD,,

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;
-}