httomolibgpu 2.3.2__py3-none-any.whl → 2.5__py3-none-any.whl

httomolibgpu/__init__.py

@@ -11,5 +11,12 @@ from httomolibgpu.prep.stripe import (
     remove_all_stripe,
 )
 
-from httomolibgpu.recon.algorithm import FBP, LPRec, SIRT, CGLS
+from httomolibgpu.recon.algorithm import (
+    FBP2d_astra,
+    FBP3d_tomobar,
+    LPRec3d_tomobar,
+    SIRT3d_tomobar,
+    CGLS3d_tomobar,
+)
+
 from httomolibgpu.recon.rotation import find_center_vo, find_center_360, find_center_pc

httomolibgpu/misc/morph.py

@@ -112,7 +112,7 @@ def data_resampler(
 
     Parameters
     ----------
-    data : cp.ndarray 
+    data : cp.ndarray
         3d cupy array.
     newshape : list
         2d list that defines the 2D slice shape of new shape data.

httomolibgpu/prep/normalize.py

@@ -43,6 +43,8 @@ def normalize(
     data: cp.ndarray,
     flats: cp.ndarray,
     darks: cp.ndarray,
+    flats_multiplier: float = 1.0,
+    darks_multiplier: float = 1.0,
     cutoff: float = 10.0,
     minus_log: bool = True,
     nonnegativity: bool = False,
@@ -60,13 +62,17 @@ def normalize(
         3D flat field data as a CuPy array.
     darks : cp.ndarray
         3D dark field data as a CuPy array.
-    cutoff : float, optional
+    flats_multiplier: float
+        A multiplier to apply to flats, can work as an intensity compensation constant.
+    darks_multiplier: float
+        A multiplier to apply to darks, can work as an intensity compensation constant.
+    cutoff : float
         Permitted maximum value for the normalised data.
-    minus_log : bool, optional
+    minus_log : bool
         Apply negative log to the normalised data.
-    nonnegativity : bool, optional
+    nonnegativity : bool
         Remove negative values in the normalised data.
-    remove_nans : bool, optional
+    remove_nans : bool
         Remove NaN and Inf values in the normalised data.
 
     Returns
@@ -82,6 +88,9 @@ def normalize(
     mean(darks, axis=0, dtype=float32, out=dark0)
     mean(flats, axis=0, dtype=float32, out=flat0)
 
+    dark0 *= darks_multiplier
+    flat0 *= flats_multiplier
+
     kernel_name = "normalisation"
     kernel = r"""
         float denom = float(flats) - float(darks);

httomolibgpu/prep/stripe.py

@@ -58,7 +58,7 @@ def remove_stripe_based_sorting(
 ) -> Union[cp.ndarray, np.ndarray]:
     """
     Remove full and partial stripe artifacts from sinogram using Nghia Vo's
-    approach, see :cite:`vo2018superior`. This algorithm works particularly
+    approach, see :ref:`method_remove_stripe_based_sorting` and :cite:`vo2018superior`. This algorithm works particularly
     well for removing partial stripes.
 
     Steps of the algorithm: 1. Sort each column of the sinogram by its grayscale values.
@@ -119,7 +119,7 @@ def remove_stripe_ti(
 ) -> Union[cp.ndarray, np.ndarray]:
     """
     Removes stripes with the method of V. Titarenko (TomoCuPy implementation).
-    See :cite:`titarenko2010analytical`.
+    See :ref:`method_remove_stripe_ti` and :cite:`titarenko2010analytical`.
 
     Parameters
     ----------
@@ -179,7 +179,7 @@ def remove_all_stripe(
 ) -> cp.ndarray:
     """
     Remove all types of stripe artifacts from sinogram using Nghia Vo's
-    approach, see :cite:`vo2018superior` (combination of algorithm 3,4,5, and 6).
+    approach, see :ref:`method_remove_all_stripe` and :cite:`vo2018superior` (combination of algorithm 3,4,5, and 6).
 
     Parameters
     ----------
@@ -205,40 +205,12 @@ def remove_all_stripe(
     for m in range(data.shape[1]):
         sino = data[:, m, :]
         sino = _rs_dead(sino, snr, la_size, matindex)
-        sino = _rs_sort2(sino, sm_size, matindex, dim)
+        sino = _rs_sort(sino, sm_size, dim)
         sino = cp.nan_to_num(sino)
         data[:, m, :] = sino
     return data
 
 
-def _rs_sort2(sinogram, size, matindex, dim):
-    """
-    Remove stripes using the sorting technique.
-    """
-    sinogram = cp.transpose(sinogram)
-    matcomb = cp.asarray(cp.dstack((matindex, sinogram)))
-
-    # matsort = cp.asarray([row[row[:, 1].argsort()] for row in matcomb])
-    ids = cp.argsort(matcomb[:, :, 1], axis=1)
-    matsort = matcomb.copy()
-    matsort[:, :, 0] = cp.take_along_axis(matsort[:, :, 0], ids, axis=1)
-    matsort[:, :, 1] = cp.take_along_axis(matsort[:, :, 1], ids, axis=1)
-    if dim == 1:
-        matsort[:, :, 1] = median_filter(matsort[:, :, 1], (size, 1))
-    else:
-        matsort[:, :, 1] = median_filter(matsort[:, :, 1], (size, size))
-
-    # matsortback = cp.asarray([row[row[:, 0].argsort()] for row in matsort])
-
-    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 = matsortback[:, :, 1]
-    return cp.transpose(sino_corrected)
-
-
 def _mpolyfit(x, y):
     n = len(x)
     x_mean = cp.mean(x)
@@ -261,8 +233,6 @@ def _detect_stripe(listdata, snr):
     listsorted = cp.sort(listdata)[::-1]
     xlist = cp.arange(0, numdata, 1.0)
     ndrop = cp.int16(0.25 * numdata)
-    # (_slope, _intercept) = cp.polyfit(xlist[ndrop:-ndrop - 1],
-    #   listsorted[ndrop:-ndrop - 1], 1)
     (_slope, _intercept) = _mpolyfit(
         xlist[ndrop : -ndrop - 1], listsorted[ndrop : -ndrop - 1]
     )
@@ -293,11 +263,6 @@ def _rs_large(sinogram, snr, size, matindex, drop_ratio=0.1, norm=True):
     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 = cp.divide(list1,
-    #                      list2,
-    #                      out=cp.ones_like(list1),
-    #                      where=list2 != 0)
-
     listfact = list1 / list2
 
     # Locate stripes
@@ -310,14 +275,12 @@ def _rs_large(sinogram, snr, size, matindex, drop_ratio=0.1, norm=True):
     sinogram1 = cp.transpose(sinogram)
     matcombine = cp.asarray(cp.dstack((matindex, sinogram1)))
 
-    # matsort = cp.asarray([row[row[:, 1].argsort()] for row in matcombine])
     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)
-    # matsortback = cp.asarray([row[row[:, 0].argsort()] for row in matsort])
     ids = cp.argsort(matsort[:, :, 0], axis=1)
     matsortback = matsort.copy()
     matsortback[:, :, 0] = cp.take_along_axis(matsortback[:, :, 0], ids, axis=1)
@@ -330,12 +293,9 @@ def _rs_large(sinogram, snr, size, matindex, drop_ratio=0.1, norm=True):
 
 
 def _rs_dead(sinogram, snr, size, matindex, norm=True):
-    """
-    Remove unresponsive and fluctuating stripes.
-    """
+    """remove unresponsive and fluctuating stripes"""
     sinogram = cp.copy(sinogram)  # Make it mutable
     (nrow, _) = sinogram.shape
-    # sinosmooth = cp.apply_along_axis(uniform_filter1d, 0, sinogram, 10)
     sinosmooth = uniform_filter1d(sinogram, 10, axis=0)
 
     listdiff = cp.sum(cp.abs(sinogram - sinosmooth), axis=0)
@@ -344,22 +304,22 @@ def _rs_dead(sinogram, snr, size, matindex, norm=True):
     listfact = listdiff / listdiffbck
 
     listmask = _detect_stripe(listfact, snr)
+    del listfact
     listmask = binary_dilation(listmask, iterations=1).astype(listmask.dtype)
     listmask[0:2] = 0.0
     listmask[-2:] = 0.0
-    listx = cp.where(listmask < 1.0)[0]
-    listy = cp.arange(nrow)
-    matz = sinogram[:, listx]
 
+    listx = cp.where(listmask < 1.0)[0]
     listxmiss = cp.where(listmask > 0.0)[0]
+    del listmask
 
-    # finter = interpolate.interp2d(listx.get(), listy.get(), matz.get(), kind='linear')
     if len(listxmiss) > 0:
-        # sinogram_c[:, listxmiss.get()] = finter(listxmiss.get(), listy.get())
         ids = cp.searchsorted(listx, listxmiss)
-        sinogram[:, listxmiss] = matz[:, ids - 1] + (listxmiss - listx[ids - 1]) * (
-            matz[:, ids] - matz[:, ids - 1]
-        ) / (listx[ids] - listx[ids - 1])
+        weights = (listxmiss - listx[ids - 1]) / (listx[ids] - listx[ids - 1])
+        # direct interpolation without making an extra copy
+        sinogram[:, listxmiss] = sinogram[:, listx[ids - 1]] + weights * (
+            sinogram[:, listx[ids]] - sinogram[:, listx[ids - 1]]
+        )
 
     # Remove residual stripes
     if norm is True:
@@ -455,7 +415,7 @@ def raven_filter(
     # Removing padding
     data = data[pad_y : height - pad_y, :, pad_x : width - pad_x].real
 
-    return data
+    return cp.require(data, requirements="C")
 
 
 def _create_matindex(nrow, ncol):

httomolibgpu/recon/algorithm.py

@@ -28,6 +28,8 @@ cupy_run = cupywrapper.cupy_run
 
 from unittest.mock import Mock
 
+from tomobar.methodsDIR import RecToolsDIR
+
 if cupy_run:
     from tomobar.methodsDIR_CuPy import RecToolsDIRCuPy
     from tomobar.methodsIR_CuPy import RecToolsIRCuPy
@@ -40,23 +42,104 @@ from typing import Optional, Type
 
 
 __all__ = [
-    "FBP",
-    "LPRec",
-    "SIRT",
-    "CGLS",
+    "FBP2d_astra",
+    "FBP3d_tomobar",
+    "LPRec3d_tomobar",
+    "SIRT3d_tomobar",
+    "CGLS3d_tomobar",
 ]
 
 input_data_axis_labels = ["angles", "detY", "detX"]  # set the labels of the input data
 
 
+## %%%%%%%%%%%%%%%%%%%%%%% FBP2d_astra reconstruction %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
+def FBP2d_astra(
+    data: np.ndarray,
+    angles: np.ndarray,
+    center: Optional[float] = None,
+    filter_type: str = "ram-lak",
+    filter_parameter: Optional[float] = None,
+    filter_d: Optional[float] = None,
+    recon_size: Optional[int] = None,
+    recon_mask_radius: float = 0.95,
+    neglog: bool = False,
+    gpu_id: int = 0,
+) -> np.ndarray:
+    """
+    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.
+
+    Parameters`
+    ----------
+    data : np.ndarray
+        Projection data as a 3d numpy array.
+    angles : np.ndarray
+        An array of angles given in radians.
+    center : float, optional
+        The center of rotation (CoR).
+    filter_type: str
+        Type of projection filter, see ASTRA's API for all available options for filters.
+    filter_parameter: float, optional
+        Parameter value for the 'tukey', 'gaussian', 'blackman' and 'kaiser' filter types.
+    filter_d: float, optional
+        D parameter value for 'shepp-logan', 'cosine', 'hamming' and 'hann' filter types.
+    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.
+        It is recommended to keep the value in the range [0.7-1.0].
+    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
+    -------
+    np.ndarray
+        The FBP reconstructed volume as a numpy array.
+    """
+    data_shape = np.shape(data)
+    if recon_size is None:
+        recon_size = data_shape[2]
+
+    RecTools = _instantiate_direct_recon2d_class(
+        data, angles, center, recon_size, gpu_id
+    )
+
+    detY_size = data_shape[1]
+    reconstruction = np.empty(
+        (recon_size, detY_size, recon_size), dtype=np.float32(), order="C"
+    )
+    _take_neg_log_np(data) if neglog else data
+
+    # loop over detY slices
+    for slice_index in range(0, detY_size):
+        reconstruction[:, slice_index, :] = np.flipud(
+            RecTools.FBP(
+                data[:, slice_index, :],
+                filter_type=filter_type,
+                filter_parameter=filter_parameter,
+                filter_d=filter_d,
+                recon_mask_radius=recon_mask_radius,
+            )
+        )
+    return reconstruction
+
+
 ## %%%%%%%%%%%%%%%%%%%%%%% FBP reconstruction %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
-def FBP(
+def FBP3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
-    filter_freq_cutoff: Optional[float] = 0.35,
+    filter_freq_cutoff: float = 0.35,
     recon_size: Optional[int] = None,
     recon_mask_radius: Optional[float] = 0.95,
+    neglog: bool = False,
     gpu_id: int = 0,
 ) -> cp.ndarray:
     """
@@ -67,7 +150,7 @@ def FBP(
     Parameters
     ----------
     data : cp.ndarray
-        Projection data as a CuPy array.
+        Projection data as a 3d CuPy array.
     angles : np.ndarray
         An array of angles given in radians.
     center : float, optional
@@ -77,24 +160,27 @@ def FBP(
     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
+    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].
+    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 FBP reconstructed volume as a CuPy array.
+        FBP reconstructed volume as a CuPy array.
     """
     RecToolsCP = _instantiate_direct_recon_class(
         data, angles, center, recon_size, gpu_id
     )
 
     reconstruction = RecToolsCP.FBP(
-        data,
+        _take_neg_log(data) if neglog else data,
         cutoff_freq=filter_freq_cutoff,
         recon_mask_radius=recon_mask_radius,
         data_axes_labels_order=input_data_axis_labels,
@@ -104,12 +190,13 @@ def FBP(
 
 
 ## %%%%%%%%%%%%%%%%%%%%%%% LPRec  %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
-def LPRec(
+def LPRec3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
     recon_size: Optional[int] = None,
     recon_mask_radius: Optional[float] = 0.95,
+    neglog: bool = False,
 ) -> cp.ndarray:
     """
     Fourier direct inversion in 3D on unequally spaced (also called as Log-Polar) grids using
@@ -119,7 +206,7 @@ def LPRec(
     Parameters
     ----------
     data : cp.ndarray
-        Projection data as a CuPy array.
+        Projection data as a 3d CuPy array.
     angles : np.ndarray
         An array of angles given in radians.
     center : float, optional
@@ -127,10 +214,13 @@ def LPRec(
     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
+    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].
+    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.
 
     Returns
     -------
@@ -140,7 +230,7 @@ def LPRec(
     RecToolsCP = _instantiate_direct_recon_class(data, angles, center, recon_size, 0)
 
     reconstruction = RecToolsCP.FOURIER_INV(
-        data,
+        _take_neg_log(data) if neglog else data,
         recon_mask_radius=recon_mask_radius,
         data_axes_labels_order=input_data_axis_labels,
     )
@@ -149,19 +239,21 @@ def LPRec(
 
 
 ## %%%%%%%%%%%%%%%%%%%%%%% SIRT reconstruction %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
-def SIRT(
+def SIRT3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
     recon_size: Optional[int] = None,
     iterations: Optional[int] = 300,
     nonnegativity: Optional[bool] = True,
+    neglog: bool = False,
     gpu_id: int = 0,
 ) -> cp.ndarray:
     """
     Perform Simultaneous Iterative Recostruction Technique (SIRT) using ASTRA toolbox :cite:`van2016fast` and
     ToMoBAR :cite:`kazantsev2020tomographic` wrappers.
-    This is 3D recon directly from a CuPy array while using ASTRA GPUlink capability.
+    This is 3D recon directly from a CuPy array while using ASTRA GPUlink capability to avoid host-device
+    transactions for projection and backprojection.
 
     Parameters
     ----------
@@ -178,6 +270,9 @@ def SIRT(
         The number of SIRT iterations.
     nonnegativity : bool, optional
         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
         A GPU device index to perform operation on.
 
@@ -187,11 +282,16 @@ def SIRT(
         The SIRT reconstructed volume as a CuPy array.
     """
     RecToolsCP = _instantiate_iterative_recon_class(
-        data, angles, center, recon_size, gpu_id, datafidelity="LS"
+        data,
+        angles,
+        center,
+        recon_size,
+        gpu_id,
+        datafidelity="LS",
     )
 
     _data_ = {
-        "projection_norm_data": data,
+        "projection_norm_data": _take_neg_log(data) if neglog else data,
         "data_axes_labels_order": input_data_axis_labels,
     }  # data dictionary
     _algorithm_ = {
@@ -204,19 +304,21 @@ def SIRT(
 
 
 ## %%%%%%%%%%%%%%%%%%%%%%% CGLS reconstruction %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
-def CGLS(
+def CGLS3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
     recon_size: Optional[int] = None,
     iterations: Optional[int] = 20,
     nonnegativity: Optional[bool] = True,
+    neglog: bool = False,
     gpu_id: int = 0,
 ) -> cp.ndarray:
     """
-    Perform Congugate Gradient Least Squares (CGLS) using ASTRA toolbox :cite:`van2016fast` and
+    Perform Conjugate Gradient Least Squares (CGLS) using ASTRA toolbox :cite:`van2016fast` and
     ToMoBAR :cite:`kazantsev2020tomographic` wrappers.
-    This is 3D recon directly from a CuPy array while using ASTRA GPUlink capability.
+    This is 3D recon directly from a CuPy array while using ASTRA GPUlink capability to avoid host-device
+    transactions for projection and backprojection.
 
     Parameters
     ----------
@@ -233,6 +335,9 @@ def CGLS(
         The number of CGLS iterations.
     nonnegativity : bool, optional
         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
         A GPU device index to perform operation on.
 
@@ -246,7 +351,7 @@ def CGLS(
     )
 
     _data_ = {
-        "projection_norm_data": 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}
@@ -292,6 +397,43 @@ def _instantiate_direct_recon_class(
     return RecToolsCP
 
 
+## %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
+def _instantiate_direct_recon2d_class(
+    data: np.ndarray,
+    angles: np.ndarray,
+    center: Optional[float] = None,
+    recon_size: Optional[int] = None,
+    gpu_id: int = 0,
+) -> Type:
+    """instantiate ToMoBAR's direct recon class for 2d reconstruction
+
+    Args:
+        data (cp.ndarray): data array
+        angles (np.ndarray): angles
+        center (Optional[float], optional): center of recon. Defaults to None.
+        recon_size (Optional[int], optional): recon_size. Defaults to None.
+        gpu_id (int, optional): gpu ID. Defaults to 0.
+
+    Returns:
+        Type[RecToolsDIR]: an instance of the direct recon class
+    """
+    if center is None:
+        center = data.shape[2] // 2  # making a crude guess
+    if recon_size is None:
+        recon_size = data.shape[2]
+    RecTools = RecToolsDIR(
+        DetectorsDimH=data.shape[2],  # Horizontal detector dimension
+        DetectorsDimV=None,  # 2d case
+        CenterRotOffset=data.shape[2] / 2
+        - center
+        - 0.5,  # Center of Rotation scalar or a vector
+        AnglesVec=-angles,  # A vector of projection angles in radians
+        ObjSize=recon_size,  # Reconstructed object dimensions (scalar)
+        device_projector=gpu_id,
+    )
+    return RecTools
+
+
 def _instantiate_iterative_recon_class(
     data: cp.ndarray,
     angles: np.ndarray,
@@ -329,3 +471,21 @@ def _instantiate_iterative_recon_class(
         device_projector=gpu_id,
     )
     return RecToolsCP
+
+
+def _take_neg_log(data: cp.ndarray) -> cp.ndarray:
+    """Taking negative log"""
+    data[data <= 0] = 1
+    data = -cp.log(data)
+    data[cp.isnan(data)] = 6.0
+    data[cp.isinf(data)] = 0
+    return data
+
+
+def _take_neg_log_np(data: np.ndarray) -> np.ndarray:
+    """Taking negative log"""
+    data[data <= 0] = 1
+    data = -np.log(data)
+    data[np.isnan(data)] = 6.0
+    data[np.isinf(data)] = 0
+    return data

{httomolibgpu-2.3.2.dist-info → httomolibgpu-2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 2.3.2
+Version: 2.5
 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,6 +19,7 @@ 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"
@@ -32,6 +33,7 @@ Requires-Dist: imageio; extra == "dev"
 Requires-Dist: h5py; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pyfftw; extra == "dev"
+Dynamic: license-file
 
 HTTomolibGPU is a library of GPU accelerated methods for tomography
 --------------------------------------------------------------------
@@ -49,19 +51,28 @@ Although **HTTomolibGPU** can be used as a stand-alone library, it has been spec
 its backend for data processing. HTTomo is a user interface (UI) written in Python for fast big tomographic data processing using
 MPI protocols or as well serially.
 
-Install HTTomolibGPU as a PyPi package
-=========================================================
+Installation
+============
+
+HTTomolibGPU is available on PyPI, so it can be installed into either a virtual environment or
+a conda environment.
+
+Virtual environment
+~~~~~~~~~~~~~~~~~~~
 .. code-block:: console
 
+   $ python -m venv httomolibgpu
+   $ source httomolibgpu/bin/activate
    $ pip install httomolibgpu
 
-Install HTTomolibGPU as a pre-built conda Python package
-=========================================================
+Conda environment
+~~~~~~~~~~~~~~~~~
 .. code-block:: console
 
    $ conda create --name httomolibgpu # create a fresh conda environment
    $ conda activate httomolibgpu # activate the environment
-   $ conda install -c httomo httomolibgpu -c conda-forge # for linux users
+   $ conda install -c conda-forge cupy==12.3.0 # for linux users
+   $ pip install httomolibgpu
 
 Setup the development environment:
 ==================================
@@ -69,14 +80,6 @@ Setup the development environment:
 .. code-block:: console
 
    $ git clone git@github.com:DiamondLightSource/httomolibgpu.git # clone the repo
-   $ conda env create --name httomolibgpu --file conda/environment.yml # install dependencies
+   $ conda env create --name httomolibgpu -c conda-forge cupy==12.3.0 # install dependencies
    $ conda activate httomolibgpu # activate the environment
-   $ pip install -e .[dev] # editable/development mode
-
-Build HTTomolibGPU as a conda Python package
-============================================
-
-.. code-block:: console
-
-   $ conda build conda/recipe/ -c conda-forge -c httomo
-
+   $ pip install -e ./httomolibgpu[dev] # editable/development mode

{httomolibgpu-2.3.2.dist-info → httomolibgpu-2.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-httomolibgpu/__init__.py,sha256=uGzTIzYjxYoXpaMoy60f_5niLS_FF_ayuF_s0pihlps,741
+httomolibgpu/__init__.py,sha256=nLXdPpzb6smp80bCciANQHJq0o-mmMJkuga-PitGmzw,820
 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
@@ -10,18 +10,18 @@ httomolibgpu/cuda_kernels/raven_filter.cu,sha256=KX2TM_9tMpvoGCHezDNWYABCnv2cT9m
 httomolibgpu/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 httomolibgpu/misc/corr.py,sha256=0_jMX_Pc962aGZlHZW2cp7KJFJiAY065f45S9ruWMTY,4440
 httomolibgpu/misc/denoise.py,sha256=-5QKP_cJQTzaVydQPlBOFfkdoEWvy5mBqCbjp7S4vaQ,4546
-httomolibgpu/misc/morph.py,sha256=sb5sm3DjY0NIghvzyZDAIVr2QvWDTeK-KUwShuXGlEE,7224
+httomolibgpu/misc/morph.py,sha256=QZTutZ28YrvTJ9wyBmgEtU9cW4bcQH6CnkETEMcaVdA,7223
 httomolibgpu/misc/rescale.py,sha256=prJa6IvdoB4O9FuonglfPsjkV_Y3xKajSFcsX8gO_Gs,4982
 httomolibgpu/prep/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 httomolibgpu/prep/alignment.py,sha256=GVxnyioipmqsHb4s3mPQ8tKGoPIQMPftDrQxUO-HBuE,5491
-httomolibgpu/prep/normalize.py,sha256=V3SnqigoZaL7QB3BE8I4gcrL6wyDWgFk9rpZkoD9vxs,4270
+httomolibgpu/prep/normalize.py,sha256=DV8CskBOPySJzydOaKOj2ytzPC7f73RS9rrqQ02acMU,4593
 httomolibgpu/prep/phase.py,sha256=vuKL3GkeJ0IG0ez8zG8t6aDoEWJNxnIdGJvaIF3kuyE,11823
-httomolibgpu/prep/stripe.py,sha256=xDWS02dKLyfYnKIeskB83aNZqZBiNXGvJhhXlgmBgRM,16071
+httomolibgpu/prep/stripe.py,sha256=_xHcIYQ-e5tN3mxASvYb9khX5dM1PB1dBXyLn9re9AQ,14541
 httomolibgpu/recon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-httomolibgpu/recon/algorithm.py,sha256=gIBpCTo28L7rrQCve1aILEiEPuu_f88lnX9oIwyt_Yo,11990
+httomolibgpu/recon/algorithm.py,sha256=g-IEcPsmyZ_OjSDTnlibx5j3duHh7t5LOLQyFeuEwpc,18576
 httomolibgpu/recon/rotation.py,sha256=zdi8I21hh8DGmij2pvncY35cioVz0ioauSsgaBPiKQs,26926
-httomolibgpu-2.3.2.dist-info/LICENSE,sha256=bXeLsgelPUUXw8HCIYiVC97Dpjhm2nB54m7TACdH8ng,48032
-httomolibgpu-2.3.2.dist-info/METADATA,sha256=_ELLLqTKpR6CY1iakEk847K64isHzZg4R5nyzSBsWks,3402
-httomolibgpu-2.3.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-httomolibgpu-2.3.2.dist-info/top_level.txt,sha256=nV0Ty_YvSPVd1O6MNWuIplD0w1nwk5hT76YgBZ-bzUw,13
-httomolibgpu-2.3.2.dist-info/RECORD,,
+httomolibgpu-2.5.dist-info/licenses/LICENSE,sha256=bXeLsgelPUUXw8HCIYiVC97Dpjhm2nB54m7TACdH8ng,48032
+httomolibgpu-2.5.dist-info/METADATA,sha256=KSbY0l0HXRv41ht58KdaL0dMBrq2tCXfjezbTvH5r2Q,3399
+httomolibgpu-2.5.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+httomolibgpu-2.5.dist-info/top_level.txt,sha256=nV0Ty_YvSPVd1O6MNWuIplD0w1nwk5hT76YgBZ-bzUw,13
+httomolibgpu-2.5.dist-info/RECORD,,

{httomolibgpu-2.3.2.dist-info → httomolibgpu-2.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any