httomolibgpu 2.5.1__tar.gz → 2.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 2.5.1
+Version: 2.6
 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

httomolibgpu-2.6/httomolibgpu/cuda_kernels/remove_nan_inf.cu

@@ -0,0 +1,19 @@
+template <typename Type>
+__global__ void remove_nan_inf(Type *data, int Z, int M, int N, int *result) {
+  const long i = blockDim.x * blockIdx.x + threadIdx.x;
+  const long j = blockDim.y * blockIdx.y + threadIdx.y;
+  const long k = blockDim.z * blockIdx.z + threadIdx.z;
+
+  if (i >= N || j >= M || k >= Z)
+    return;
+
+  long long index = static_cast<long long>(i) + N * static_cast<long long>(j) + N * M * static_cast<long long>(k);
+
+  float val = float(data[index]); /*needs a cast to float for isnan isinf functions to work*/
+  Type zero = 0;
+  if (isnan(val) || isinf(val)) {
+    result[0] = 1;
+    data[index] = zero;
+  }
+
+}

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/misc/corr.py

@@ -18,9 +18,7 @@
 # Created By  : Tomography Team at DLS <scientificsoftware@diamond.ac.uk>
 # Created Date: 21/October/2022
 # ---------------------------------------------------------------------------
-""" Module for data correction. For more detailed information see :ref:`data_correction_module`.
-
-"""
+"""Module for data correction. For more detailed information see :ref:`data_correction_module`."""
 
 import numpy as np
 from typing import Union
@@ -38,6 +36,7 @@ if cupy_run:
 else:
     load_cuda_module = Mock()
 
+from httomolibgpu.misc.supp_func import data_checker
 
 __all__ = [
     "median_filter",
@@ -74,7 +73,6 @@ def median_filter(
         If the input array is not three dimensional.
     """
     input_type = data.dtype
-
     if input_type not in ["float32", "uint16"]:
         raise ValueError("The input data should be either float32 or uint16 data type")
 
@@ -84,6 +82,10 @@ def median_filter(
     else:
         raise ValueError("The input array must be a 3D array")
 
+    data = data_checker(
+        data, verbosity=True, method_name="median_filter_or_remove_outlier"
+    )
+
     if kernel_size not in [3, 5, 7, 9, 11, 13]:
         raise ValueError("Please select a correct kernel size: 3, 5, 7, 9, 11, 13")
 

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/misc/denoise.py

@@ -18,8 +18,7 @@
 # Created By  : Tomography Team at DLS <scientificsoftware@diamond.ac.uk>
 # Created Date: 18/December/2024
 # ---------------------------------------------------------------------------
-""" Module for data denoising. For more detailed information see :ref:`data_denoising_module`.
-"""
+"""Module for data denoising. For more detailed information see :ref:`data_denoising_module`."""
 
 import numpy as np
 from typing import Union, Optional
@@ -29,9 +28,10 @@ from httomolibgpu import cupywrapper
 cp = cupywrapper.cp
 cupy_run = cupywrapper.cupy_run
 
-from numpy import float32
 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
 else:
@@ -82,6 +82,8 @@ def total_variation_ROF(
         If the input array is not float32 data type.
     """
 
+    data = data_checker(data, verbosity=True, method_name="total_variation_ROF")
+
     return ROF_TV(
         data, regularisation_parameter, iterations, time_marching_parameter, gpu_id
     )
@@ -127,6 +129,8 @@ def total_variation_PD(
         If the input array is not float32 data type.
     """
 
+    data_checker(data, verbosity=True, method_name="total_variation_PD")
+
     methodTV = 0
     if not isotropic:
         methodTV = 1

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/misc/morph.py

@@ -35,6 +35,8 @@ else:
 
 from typing import Literal
 
+from httomolibgpu.misc.supp_func import data_checker
+
 __all__ = [
     "sino_360_to_180",
     "data_resampler",
@@ -66,6 +68,8 @@ def sino_360_to_180(
     if data.ndim != 3:
         raise ValueError("only 3D data is supported")
 
+    data = data_checker(data, verbosity=True, method_name="sino_360_to_180")
+
     dx, dy, dz = data.shape
 
     overlap = int(np.round(overlap))
@@ -136,6 +140,8 @@ def data_resampler(
         data = cp.expand_dims(data, 1)
         axis = 1
 
+    data = data_checker(data, verbosity=True, method_name="data_resampler")
+
     N, M, Z = cp.shape(data)
 
     if axis == 0:

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/misc/rescale.py

@@ -18,9 +18,7 @@
 # Created By  : Tomography Team at DLS <scientificsoftware@diamond.ac.uk>
 # Created Date: 1 March 2024
 # ---------------------------------------------------------------------------
-""" Module for data rescaling. For more detailed information see :ref:`data_rescale_module`.
-
-"""
+"""Module for data rescaling. For more detailed information see :ref:`data_rescale_module`."""
 
 import numpy as np
 from httomolibgpu import cupywrapper
@@ -30,6 +28,8 @@ cupy_run = cupywrapper.cupy_run
 
 from typing import Literal, Optional, Tuple, Union
 
+from httomolibgpu.misc.supp_func import data_checker
+
 __all__ = [
     "rescale_to_int",
 ]
@@ -80,6 +80,8 @@ def rescale_to_int(
     else:
         output_dtype = np.uint32
 
+    data = data_checker(data, verbosity=True, method_name="rescale_to_int")
+
     if cupy_run:
         xp = cp.get_array_module(data)
     else:
@@ -109,7 +111,6 @@ def rescale_to_int(
     if xp.__name__ == "numpy":
         if input_max == pow(2, 32):
             input_max -= 1
-        data[np.logical_not(np.isfinite(data))] = 0
         res = np.copy(data.astype(float))
         res[data.astype(float) < input_min] = int(input_min)
         res[data.astype(float) > input_max] = int(input_max)

httomolibgpu-2.6/httomolibgpu/misc/supp_func.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ---------------------------------------------------------------------------
+# Copyright 2022 Diamond Light Source Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ---------------------------------------------------------------------------
+# Created By  : Tomography Team at DLS <scientificsoftware@diamond.ac.uk>
+# Created Date: 02/June/2025
+# ---------------------------------------------------------------------------
+"""This is a collection of supplementary functions (utils) to perform various data checks"""
+
+from httomolibgpu import cupywrapper
+from typing import Optional
+
+cp = cupywrapper.cp
+cupy_run = cupywrapper.cupy_run
+
+import numpy as np
+
+from unittest.mock import Mock
+
+if cupy_run:
+    from httomolibgpu.cuda_kernels import load_cuda_module
+else:
+    load_cuda_module = Mock()
+
+
+def _naninfs_check(
+    data: cp.ndarray,
+    verbosity: bool = True,
+    method_name: Optional[str] = None,
+) -> cp.ndarray:
+    """
+    This function finds NaN's, +-Inf's in the input data and then prints the warnings and correct the data if correction is enabled.
+
+    Parameters
+    ----------
+    data : cp.ndarray
+        Input CuPy or Numpy array either float32 or uint16 data type.
+    verbosity : bool
+        If enabled, then the printing of the warning happens when data contains infs or nans
+    method_name : str, optional.
+        Method's name for which input data is tested.
+
+    Returns
+    -------
+    ndarray
+        Uncorrected or corrected (nans and infs converted to zeros) input array.
+    """
+    present_nans_infs_b = False
+
+    if cupy_run:
+        xp = cp.get_array_module(data)
+    else:
+        import numpy as xp
+
+    if xp.__name__ == "cupy":
+        input_type = data.dtype
+        if len(data.shape) == 2:
+            dy, dx = data.shape
+            dz = 1
+        else:
+            dz, dy, dx = data.shape
+
+        present_nans_infs = cp.zeros(shape=(1)).astype(cp.uint8)
+
+        block_x = 128
+        # setting grid/block parameters
+        block_dims = (block_x, 1, 1)
+        grid_x = (dx + block_x - 1) // block_x
+        grid_y = dy
+        grid_z = dz
+        grid_dims = (grid_x, grid_y, grid_z)
+        params = (data, dz, dy, dx, present_nans_infs)
+
+        kernel_args = "remove_nan_inf<{0}>".format(
+            "float" if input_type == "float32" else "unsigned short"
+        )
+
+        module = load_cuda_module("remove_nan_inf", name_expressions=[kernel_args])
+        remove_nan_inf_kernel = module.get_function(kernel_args)
+        remove_nan_inf_kernel(grid_dims, block_dims, params)
+
+        if present_nans_infs[0].get() == 1:
+            present_nans_infs_b = True
+    else:
+        if not np.all(np.isfinite(data)):
+            present_nans_infs_b = True
+            np.nan_to_num(data, copy=False, nan=0.0, posinf=0.0, neginf=0.0)
+
+    if present_nans_infs_b:
+        if verbosity:
+            print(
+                f"Warning!!! Input data to method: {method_name} contains Inf's or/and NaN's. This will be corrected but it is recommended to check the validity of input to the method."
+            )
+
+    return data
+
+
+def _zeros_check(
+    data: cp.ndarray,
+    verbosity: bool = True,
+    percentage_threshold: float = 50,
+    method_name: Optional[str] = None,
+) -> bool:
+    """
+    This function finds all zeros present in the data. If the amount of zeros is larger than percentage_threshold it prints the warning.
+
+    Parameters
+    ----------
+    data : cp.ndarray
+        Input CuPy or Numpy array.
+    verbosity : bool
+        If enabled, then the printing of the warning happens when data contains infs or nans.
+    percentage_threshold: float:
+        If the number of zeros in input data is more than the percentage of all data points, then print the data warning
+    method_name : str, optional.
+        Method's name for which input data is tested.
+
+    Returns
+    -------
+    bool
+        True if the data contains too many zeros
+    """
+    if cupy_run:
+        xp = cp.get_array_module(data)
+    else:
+        import numpy as xp
+
+    nonzero_elements_total = 1
+    for tot_elements_mult in data.shape:
+        nonzero_elements_total *= tot_elements_mult
+
+    warning_zeros = False
+    zero_elements_total = nonzero_elements_total - int(xp.count_nonzero(data))
+
+    if (zero_elements_total / nonzero_elements_total) * 100 >= percentage_threshold:
+        warning_zeros = True
+        if verbosity:
+            print(
+                f"Warning!!! Input data to method: {method_name} contains more than {percentage_threshold} percent of zeros."
+            )
+
+    return warning_zeros
+
+
+def data_checker(
+    data: cp.ndarray,
+    verbosity: bool = True,
+    method_name: Optional[str] = None,
+) -> bool:
+    """
+    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; the number of zero elements.
+
+    Parameters
+    ----------
+    data : xp.ndarray
+        Input CuPy or Numpy array either float32 or uint16 data type.
+    verbosity : bool
+        If enabled, then the printing of the warning happens when data contains infs or nans.
+    method_name : str, optional.
+        Method's name for which input data is tested.
+
+    Returns
+    -------
+    cp.ndarray
+        Returns corrected or not data array.
+    """
+
+    data = _naninfs_check(data, verbosity=verbosity, method_name=method_name)
+
+    _zeros_check(
+        data,
+        verbosity=verbosity,
+        percentage_threshold=50,
+        method_name=method_name,
+    )
+
+    return data

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/prep/alignment.py

@@ -35,6 +35,8 @@ else:
 
 from typing import Dict, List, Tuple
 
+from httomolibgpu.misc.supp_func import data_checker
+
 __all__ = [
     "distortion_correction_proj_discorpy",
 ]
@@ -86,6 +88,10 @@ def distortion_correction_proj_discorpy(
     if len(data.shape) == 2:
         data = cp.expand_dims(data, axis=0)
 
+    data = data_checker(
+        data, verbosity=True, method_name="distortion_correction_proj_discorpy"
+    )
+
     # Get info from metadata txt file
     xcenter, ycenter, list_fact = _load_metadata_txt(metadata_path)
 

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/prep/normalize.py

@@ -36,6 +36,8 @@ else:
 from numpy import float32
 from typing import Tuple
 
+from httomolibgpu.misc.supp_func import data_checker
+
 __all__ = ["normalize"]
 
 
@@ -80,7 +82,7 @@ def normalize(
     cp.ndarray
         Normalised 3D tomographic data as a CuPy array.
     """
-    _check_valid_input(data, flats, darks)
+    _check_valid_input_normalise(data, flats, darks)
 
     dark0 = cp.empty(darks.shape[1:], dtype=float32)
     flat0 = cp.empty(flats.shape[1:], dtype=float32)
@@ -128,7 +130,7 @@ def normalize(
     return out
 
 
-def _check_valid_input(data, flats, darks) -> None:
+def _check_valid_input_normalise(data, flats, darks) -> None:
     """Helper function to check the validity of inputs to normalisation functions"""
     if data.ndim != 3:
         raise ValueError("Input data must be a 3D stack of projections")
@@ -143,3 +145,7 @@ def _check_valid_input(data, flats, darks) -> None:
         flats = flats[cp.newaxis, :, :]
     if darks.ndim == 2:
         darks = darks[cp.newaxis, :, :]
+
+    data_checker(data, verbosity=True, method_name="normalize_data")
+    data_checker(flats, verbosity=True, method_name="normalize_flats")
+    data_checker(darks, verbosity=True, method_name="normalize_darks")

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/prep/phase.py

@@ -41,6 +41,8 @@ from numpy import float32
 from typing import Tuple
 import math
 
+from httomolibgpu.misc.supp_func import data_checker
+
 __all__ = [
     "paganin_filter_savu",
     "paganin_filter_tomopy",
@@ -105,6 +107,8 @@ def paganin_filter_savu(
             " 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
@@ -297,6 +301,8 @@ def paganin_filter_tomopy(
             " please provide a stack of 2D projections."
         )
 
+    tomo = data_checker(tomo, verbosity=True, method_name="paganin_filter_tomopy")
+
     dz_orig, dy_orig, dx_orig = tomo.shape
 
     # Perform padding to the power of 2 as FFT is O(n*log(n)) complexity

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/prep/stripe.py

@@ -43,6 +43,8 @@ else:
 
 from typing import Union
 
+from httomolibgpu.misc.supp_func import data_checker
+
 __all__ = [
     "remove_stripe_based_sorting",
     "remove_stripe_ti",
@@ -80,6 +82,9 @@ def remove_stripe_based_sorting(
         Corrected 3D tomographic data as a CuPy or NumPy array.
 
     """
+
+    data = data_checker(data, verbosity=True, method_name="remove_stripe_based_sorting")
+
     if size is None:
         if data.shape[2] > 2000:
             size = 21
@@ -134,7 +139,13 @@ def remove_stripe_ti(
     ndarray
         3D array of de-striped projections.
     """
-    # TODO: detector dimensions must be even otherwise error
+    data = data_checker(data, verbosity=True, method_name="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")
+
     gamma = beta * ((1 - beta) / (1 + beta)) ** cp.abs(
         cp.fft.fftfreq(data.shape[-1]) * data.shape[-1]
     )
@@ -201,6 +212,8 @@ def remove_all_stripe(
         Corrected 3D tomographic data as a CuPy or NumPy array.
 
     """
+    data = data_checker(data, verbosity=True, method_name="remove_all_stripe")
+
     matindex = _create_matindex(data.shape[2], data.shape[0])
     for m in range(data.shape[1]):
         sino = data[:, m, :]
@@ -372,10 +385,11 @@ def raven_filter(
     ValueError
         If the input array is not three dimensional.
     """
-
     if data.dtype != cp.float32:
         raise ValueError("The input data should be float32 data type")
 
+    data = data_checker(data, verbosity=True, method_name="raven_filter")
+
     # Padding of the sinogram
     data = cp.pad(data, ((pad_y, pad_y), (0, 0), (pad_x, pad_x)), mode=pad_method)
 

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/recon/algorithm.py

@@ -40,6 +40,8 @@ else:
 from numpy import float32, complex64
 from typing import Optional, Type
 
+from httomolibgpu.misc.supp_func import data_checker
+
 
 __all__ = [
     "FBP2d_astra",
@@ -103,6 +105,8 @@ def FBP2d_astra(
     np.ndarray
         The FBP reconstructed volume as a numpy array.
     """
+    data = data_checker(data, verbosity=True, method_name="FBP2d_astra")
+
     data_shape = np.shape(data)
     if recon_size is None:
         recon_size = data_shape[2]
@@ -175,6 +179,8 @@ def FBP3d_tomobar(
     cp.ndarray
         FBP reconstructed volume as a CuPy array.
     """
+    data = data_checker(data, verbosity=True, method_name="FBP3d_tomobar")
+
     RecToolsCP = _instantiate_direct_recon_class(
         data, angles, center, recon_size, gpu_id
     )
@@ -194,6 +200,8 @@ def LPRec3d_tomobar(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
+    filter_type: str = "shepp",
+    filter_freq_cutoff: float = 1.0,
     recon_size: Optional[int] = None,
     recon_mask_radius: Optional[float] = 0.95,
     neglog: bool = False,
@@ -211,6 +219,10 @@ def LPRec3d_tomobar(
         An array of angles given in radians.
     center : float, optional
         The center of rotation (CoR).
+    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.
     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.
@@ -227,12 +239,17 @@ def LPRec3d_tomobar(
     cp.ndarray
         The Log-polar Fourier reconstructed volume as a CuPy array.
     """
+
+    data = data_checker(data, verbosity=True, method_name="LPRec3d_tomobar")
+
     RecToolsCP = _instantiate_direct_recon_class(data, angles, center, recon_size, 0)
 
     reconstruction = RecToolsCP.FOURIER_INV(
         _take_neg_log(data) if neglog else data,
         recon_mask_radius=recon_mask_radius,
         data_axes_labels_order=input_data_axis_labels,
+        filter_type=filter_type,
+        cutoff_freq=filter_freq_cutoff,
     )
     cp._default_memory_pool.free_all_blocks()
     return cp.require(cp.swapaxes(reconstruction, 0, 1), requirements="C")
@@ -281,6 +298,8 @@ def SIRT3d_tomobar(
     cp.ndarray
         The SIRT reconstructed volume as a CuPy array.
     """
+    data = data_checker(data, verbosity=True, method_name="SIRT3d_tomobar")
+
     RecToolsCP = _instantiate_iterative_recon_class(
         data,
         angles,
@@ -346,6 +365,8 @@ def CGLS3d_tomobar(
     cp.ndarray
         The CGLS reconstructed volume as a CuPy array.
     """
+    data = data_checker(data, verbosity=True, method_name="CGLS3d_tomobar")
+
     RecToolsCP = _instantiate_iterative_recon_class(
         data, angles, center, recon_size, gpu_id, datafidelity="LS"
     )

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu/recon/rotation.py

@@ -21,6 +21,7 @@
 """Modules for finding the axis of rotation for 180 and 360 degrees scans"""
 
 import numpy as np
+from numpy.polynomial import Polynomial
 from httomolibgpu import cupywrapper
 
 cp = cupywrapper.cp
@@ -48,6 +49,8 @@ else:
 import math
 from typing import List, Literal, Optional, Tuple, Union
 
+from httomolibgpu.misc.supp_func import data_checker
+
 __all__ = [
     "find_center_vo",
     "find_center_360",
@@ -107,6 +110,8 @@ def find_center_vo(
         data = cp.expand_dims(data, 1)
         ind = 0
 
+    data = data_checker(data, verbosity=True, method_name="find_center_vo")
+
     angles_tot, detY_size, detX_size = data.shape
 
     if ind is None:
@@ -455,6 +460,8 @@ def find_center_360(
     if data.ndim != 3:
         raise ValueError("A 3D array must be provided")
 
+    data = data_checker(data, verbosity=True, method_name="find_center_360")
+
     # this method works with a 360-degree sinogram.
     if ind is None:
         _sino = data[:, 0, :]
@@ -712,9 +719,23 @@ def _calculate_curvature(list_metric):
 
     # work mostly on CPU here - we have very small arrays here
     list1 = cp.asnumpy(list_metric[min_pos - radi : min_pos + radi + 1])
-    afact1 = np.polyfit(np.arange(0, 2 * radi + 1), list1, 2)[0]
+    if not all(map(np.isfinite, list1)):
+        raise ValueError(
+            "The list of metrics (list1) contains nan's or infs. Check your input data"
+        )
+
+    series1 = Polynomial.fit(np.arange(0, 2 * radi + 1), list1, deg=2)
+    afact1 = series1.convert().coef[-1]
+
     list2 = cp.asnumpy(list_metric[min_pos - 1 : min_pos + 2])
-    (afact2, bfact2, _) = np.polyfit(np.arange(min_pos - 1, min_pos + 2), list2, 2)
+    if not all(map(np.isfinite, list2)):
+        raise ValueError(
+            "The list of metrics (list2) contains nan's or infs. Check your input data"
+        )
+
+    series2 = Polynomial.fit(np.arange(min_pos - 1, min_pos + 2), list2, deg=2)
+    afact2 = series2.convert().coef[-1]
+    bfact2 = series2.convert().coef[-1 - 1]
 
     curvature = np.abs(afact1)
     if afact2 != 0.0:
@@ -759,6 +780,10 @@ def find_center_pc(
     np.float32
         Rotation axis location.
     """
+
+    proj1 = data_checker(proj1, verbosity=True, method_name="find_center_pc")
+    proj2 = data_checker(proj2, verbosity=True, method_name="find_center_pc")
+
     imgshift = 0.0 if rotc_guess is None else rotc_guess - (proj1.shape[1] - 1.0) / 2.0
 
     proj1 = shift(proj1, [0, -imgshift], mode="constant", cval=0)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 2.5.1
+Version: 2.6
 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

{httomolibgpu-2.5.1 → httomolibgpu-2.6}/httomolibgpu.egg-info/SOURCES.txt

@@ -16,11 +16,13 @@ httomolibgpu/cuda_kernels/generate_mask.cu
 httomolibgpu/cuda_kernels/median_kernel.cu
 httomolibgpu/cuda_kernels/paganin_filter_gen.cu
 httomolibgpu/cuda_kernels/raven_filter.cu
+httomolibgpu/cuda_kernels/remove_nan_inf.cu
 httomolibgpu/misc/__init__.py
 httomolibgpu/misc/corr.py
 httomolibgpu/misc/denoise.py
 httomolibgpu/misc/morph.py
 httomolibgpu/misc/rescale.py
+httomolibgpu/misc/supp_func.py
 httomolibgpu/prep/__init__.py
 httomolibgpu/prep/alignment.py
 httomolibgpu/prep/normalize.py