httomolibgpu 2.4.0__tar.gz → 2.5.1__tar.gz

{httomolibgpu-2.4.0/httomolibgpu.egg-info → httomolibgpu-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 2.4.0
+Version: 2.5.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,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.4.0 → httomolibgpu-2.5.1}/README.rst

@@ -14,19 +14,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:
 ==================================
@@ -34,14 +43,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.4.0 → httomolibgpu-2.5.1}/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-2.4.0 → httomolibgpu-2.5.1}/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-2.4.0 → httomolibgpu-2.5.1}/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-2.4.0 → httomolibgpu-2.5.1}/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-2.4.0 → httomolibgpu-2.5.1}/httomolibgpu/recon/algorithm.py

@@ -29,9 +29,11 @@ cupy_run = cupywrapper.cupy_run
 from unittest.mock import Mock
 
 if cupy_run:
+    from tomobar.methodsDIR import RecToolsDIR
     from tomobar.methodsDIR_CuPy import RecToolsDIRCuPy
     from tomobar.methodsIR_CuPy import RecToolsIRCuPy
 else:
+    RecToolsDIR = Mock()
     RecToolsDIRCuPy = Mock()
     RecToolsIRCuPy = Mock()
 
@@ -40,23 +42,103 @@ 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: float = 0.35,
     recon_size: Optional[int] = None,
-    recon_mask_radius: float = 0.95,
+    recon_mask_radius: Optional[float] = 0.95,
     neglog: bool = False,
     gpu_id: int = 0,
 ) -> cp.ndarray:
@@ -68,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
@@ -78,20 +160,20 @@ 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. 
+        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
@@ -108,7 +190,7 @@ def FBP(
 
 
 ## %%%%%%%%%%%%%%%%%%%%%%% LPRec  %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
-def LPRec(
+def LPRec3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
@@ -124,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
@@ -132,13 +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.         
+        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
     -------
@@ -157,7 +239,7 @@ def LPRec(
 
 
 ## %%%%%%%%%%%%%%%%%%%%%%% SIRT reconstruction %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
-def SIRT(
+def SIRT3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
@@ -189,8 +271,8 @@ def SIRT(
     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.              
+        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.
 
@@ -222,7 +304,7 @@ def SIRT(
 
 
 ## %%%%%%%%%%%%%%%%%%%%%%% CGLS reconstruction %%%%%%%%%%%%%%%%%%%%%%%%%%%%  ##
-def CGLS(
+def CGLS3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
@@ -254,8 +336,8 @@ def CGLS(
     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.              
+        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.
 
@@ -277,6 +359,7 @@ def CGLS(
     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,
@@ -314,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,
@@ -352,10 +472,20 @@ def _instantiate_iterative_recon_class(
     )
     return RecToolsCP
 
+
 def _take_neg_log(data: cp.ndarray) -> cp.ndarray:
     """Taking negative log"""
-    data[data<=0] = 1
+    data[data <= 0] = 1
     data = -cp.log(data)
     data[cp.isnan(data)] = 6.0
     data[cp.isinf(data)] = 0
-    return data
+    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.4.0 → httomolibgpu-2.5.1/httomolibgpu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 2.4.0
+Version: 2.5.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,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.4.0 → httomolibgpu-2.5.1}/httomolibgpu.egg-info/requires.txt

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

{httomolibgpu-2.4.0 → httomolibgpu-2.5.1}/pyproject.toml

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