httomolibgpu 2.5.1__py3-none-any.whl → 2.7__py3-none-any.whl

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/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/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/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",
@@ -42,7 +44,7 @@ __all__ = [
 
 
 def sino_360_to_180(
-    data: cp.ndarray, overlap: int = 0, rotation: Literal["left", "right"] = "left"
+    data: cp.ndarray, overlap: float = 0, side: Literal["left", "right"] = "left"
 ) -> cp.ndarray:
     """
     Converts 0-360 degrees sinogram to a 0-180 sinogram.
@@ -53,9 +55,9 @@ def sino_360_to_180(
     ----------
     data : cp.ndarray
         Input 3D data.
-    overlap : scalar, optional
-        Overlapping number of pixels.
-    rotation : string, optional
+    overlap : float
+        Overlapping number of pixels. Floats will be converted to integers.
+    side : string
         'left' if rotation center is close to the left of the
         field-of-view, 'right' otherwise.
     Returns
@@ -66,22 +68,26 @@ 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))
     if overlap >= dz:
-        raise ValueError("overlap must be less than data.shape[2]")
+        raise ValueError("Overlap must be less than data.shape[2]")
     if overlap < 0:
-        raise ValueError("only positive overlaps are allowed.")
+        raise ValueError("Only positive overlaps are allowed.")
 
-    if rotation not in ["left", "right"]:
-        raise ValueError('rotation parameter must be either "left" or "right"')
+    if side not in ["left", "right"]:
+        raise ValueError(
+            f'The value {side} is invalid, only "left" or "right" strings are accepted'
+        )
 
     n = dx // 2
 
     out = cp.empty((n, dy, 2 * dz - overlap), dtype=data.dtype)
 
-    if rotation == "left":
+    if side == "left":
         weights = cp.linspace(0, 1.0, overlap, dtype=cp.float32)
         out[:, :, -dz + overlap :] = data[:n, :, overlap:]
         out[:, :, : dz - overlap] = data[n : 2 * n, :, overlap:][:, :, ::-1]
@@ -89,7 +95,7 @@ def sino_360_to_180(
             weights * data[:n, :, :overlap]
             + (weights * data[n : 2 * n, :, :overlap])[:, :, ::-1]
         )
-    if rotation == "right":
+    if side == "right":
         weights = cp.linspace(1.0, 0, overlap, dtype=cp.float32)
         out[:, :, : dz - overlap] = data[:n, :, :-overlap]
         out[:, :, -dz + overlap :] = data[n : 2 * n, :, :-overlap][:, :, ::-1]
@@ -136,6 +142,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/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/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/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/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/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/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/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/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:
@@ -411,16 +416,16 @@ def find_center_360(
     data: cp.ndarray,
     ind: Optional[int] = None,
     win_width: int = 10,
-    side: Optional[Literal[0, 1]] = None,
+    side: Optional[Literal["left", "right"]] = None,
     denoise: bool = True,
     norm: bool = False,
     use_overlap: bool = False,
-) -> Tuple[float, float, Optional[Literal[0, 1]], float]:
+) -> Tuple[np.float32, np.float32, Optional[Literal["left", "right"]], np.float32]:
     """
     Find the center-of-rotation (COR) in a 360-degree scan and also an offset
     to perform data transformation from 360 to 180 degrees scan. See :cite:`vo2021data`.
 
-    Parameters
+    Parameters Tuple[np.float32, np.float32, Literal["left", "right"], np.float32]:
     ----------
     data : cp.ndarray
         3D tomographic data as a Cupy array.
@@ -428,10 +433,9 @@ def find_center_360(
         Index of the slice to be used for estimate the CoR and the overlap.
     win_width : int, optional
         Window width used for finding the overlap area.
-    side : {None, 0, 1}, optional
-        Overlap size. Only there options: None, 0, or 1. "None" corresponds
-        to fully automated determination. "0" corresponds to the left side.
-        "1" corresponds to the right side.
+    side : {None, left, right}, optional
+        Chose between "left", "right" or "None" which corresponds to fully
+        automated determination of the side.
     denoise : bool, optional
         Apply the Gaussian filter if True.
     norm : bool, optional
@@ -446,8 +450,8 @@ def find_center_360(
         Center-of-rotation.
     overlap : float
         Width of the overlap area between two halves of the sinogram.
-    side : int
-        Overlap side between two halves of the sinogram.
+    side : str
+        Overlap side (left or right) between two halves of the sinogram.
     overlap_position : float
         Position of the window in the first image giving the best
         correlation metric.
@@ -455,6 +459,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, :]
@@ -468,10 +474,7 @@ def find_center_360(
     (overlap, side, overlap_position) = _find_overlap(
         sino_top, sino_bot, win_width, side, denoise, norm, use_overlap
     )
-    if side == 0:
-        cor = overlap / 2.0 - 1.0
-    else:
-        cor = ncol - overlap / 2.0 - 1.0
+    cor = ncol - overlap / 2
 
     return cor, overlap, side, overlap_position
 
@@ -491,10 +494,9 @@ def _find_overlap(
         2D array. Projection image or sinogram image.
     win_width : int
         Width of the searching window.
-    side : {None, 0, 1}, optional
-        Only there options: None, 0, or 1. "None" corresponding to fully
-        automated determination. "0" corresponding to the left side. "1"
-        corresponding to the right side.
+    side : {None, left, right}, optional
+        Chose between "left", "right" or "None" which corresponds to fully
+        automated determination of the side.
     denoise : bool, optional
         Apply the Gaussian filter if True.
     norm : bool, optional
@@ -507,8 +509,8 @@ def _find_overlap(
     -------
     overlap : float
         Width of the overlap area between two images.
-    side : int
-        Overlap side between two images.
+    side : str
+        Overlap side (left or right) between two images.
     overlap_position : float
         Position of the window in the first image giving the best
         correlation metric.
@@ -518,12 +520,12 @@ def _find_overlap(
     ncol2 = mat2.shape[1]
     win_width = int(np.clip(win_width, 6, min(ncol1, ncol2) // 2))
 
-    if side == 1:
+    if side == "right":
         (list_metric, offset) = _search_overlap(
             mat1,
             mat2,
             win_width,
-            side=side,
+            side=1,  # right side
             denoise=denoise,
             norm=norm,
             use_overlap=use_overlap,
@@ -531,12 +533,12 @@ def _find_overlap(
         overlap_position = _calculate_curvature(list_metric)[1]
         overlap_position += offset
         overlap = ncol1 - overlap_position + win_width // 2
-    elif side == 0:
+    elif side == "left":
         (list_metric, offset) = _search_overlap(
             mat1,
             mat2,
             win_width,
-            side=side,
+            side=0,  # left side
             denoise=denoise,
             norm=norm,
             use_overlap=use_overlap,
@@ -549,7 +551,7 @@ def _find_overlap(
             mat1,
             mat2,
             win_width,
-            side=1,
+            side=1,  # right side
             denoise=denoise,
             norm=norm,
             use_overlap=use_overlap,
@@ -558,7 +560,7 @@ def _find_overlap(
             mat1,
             mat2,
             win_width,
-            side=0,
+            side=0,  # left side
             denoise=denoise,
             norm=norm,
             use_overlap=use_overlap,
@@ -570,11 +572,11 @@ def _find_overlap(
         overlap_position2 += offset2
 
         if curvature1 > curvature2:
-            side = 1
+            side = "right"
             overlap_position = overlap_position1
             overlap = ncol1 - overlap_position + win_width // 2
         else:
-            side = 0
+            side = "left"
             overlap_position = overlap_position2
             overlap = overlap_position + win_width // 2
 
@@ -712,9 +714,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 +775,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.dist-info → httomolibgpu-2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 2.5.1
+Version: 2.7
 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.7.dist-info/RECORD

@@ -0,0 +1,29 @@
+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
+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/morph.py,sha256=AlLk_kGFHF6vNrdICMpsXmTUDnCc7ey97-_DqwZb3Wc,7475
+httomolibgpu/misc/rescale.py,sha256=ODO-WI3jmfyVIcfMsD_Pb39hUt4YiHqIWncpemuFhks,5058
+httomolibgpu/misc/supp_func.py,sha256=gGAxwi0KYLwnBRnfsXitDZ16QMaycPexJ4vzzKx6Plk,6101
+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/recon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httomolibgpu/recon/algorithm.py,sha256=O1URBdhXKw5He4AQDLdC4XhdcnlGY355qBpStBeZVZs,19461
+httomolibgpu/recon/rotation.py,sha256=o7niNpGY30H8z7syk_3fCn1DfDNejtGnrU8Iy1CaPKQ,27798
+httomolibgpu-2.7.dist-info/licenses/LICENSE,sha256=bXeLsgelPUUXw8HCIYiVC97Dpjhm2nB54m7TACdH8ng,48032
+httomolibgpu-2.7.dist-info/METADATA,sha256=Jz-N3slXF-qao2ooEgtHhqkGKWoolMGsp0cUIQ1o-Ew,3399
+httomolibgpu-2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+httomolibgpu-2.7.dist-info/top_level.txt,sha256=nV0Ty_YvSPVd1O6MNWuIplD0w1nwk5hT76YgBZ-bzUw,13
+httomolibgpu-2.7.dist-info/RECORD,,

{httomolibgpu-2.5.1.dist-info → httomolibgpu-2.7.dist-info}/WHEEL

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

httomolibgpu-2.5.1.dist-info/RECORD

@@ -1,27 +0,0 @@
-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
-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/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=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=DV8CskBOPySJzydOaKOj2ytzPC7f73RS9rrqQ02acMU,4593
-httomolibgpu/prep/phase.py,sha256=vuKL3GkeJ0IG0ez8zG8t6aDoEWJNxnIdGJvaIF3kuyE,11823
-httomolibgpu/prep/stripe.py,sha256=_xHcIYQ-e5tN3mxASvYb9khX5dM1PB1dBXyLn9re9AQ,14541
-httomolibgpu/recon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-httomolibgpu/recon/algorithm.py,sha256=l_gedUiKYAKuekKMyTabqD9lEim2S-mzj1tDuvxhEI4,18604
-httomolibgpu/recon/rotation.py,sha256=zdi8I21hh8DGmij2pvncY35cioVz0ioauSsgaBPiKQs,26926
-httomolibgpu-2.5.1.dist-info/licenses/LICENSE,sha256=bXeLsgelPUUXw8HCIYiVC97Dpjhm2nB54m7TACdH8ng,48032
-httomolibgpu-2.5.1.dist-info/METADATA,sha256=q3ERNOEgfl1J1a62MWuQm4EruIQey7h_JwBqR5PFUEg,3401
-httomolibgpu-2.5.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-httomolibgpu-2.5.1.dist-info/top_level.txt,sha256=nV0Ty_YvSPVd1O6MNWuIplD0w1nwk5hT76YgBZ-bzUw,13
-httomolibgpu-2.5.1.dist-info/RECORD,,