httomolibgpu 5.4__tar.gz → 5.5.1__tar.gz

{httomolibgpu-5.4/httomolibgpu.egg-info → httomolibgpu-5.5.1}/PKG-INFO

@@ -1,20 +1,20 @@
 Metadata-Version: 2.4
 Name: httomolibgpu
-Version: 5.4
+Version: 5.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
 Project-URL: Repository, https://github.com/DiamondLightSource/httomolibgpu
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Environment :: GPU :: NVIDIA CUDA
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: cupy==12.3.0
+Requires-Dist: cupy==14.0.*
 Requires-Dist: nvtx
-Requires-Dist: numpy
+Requires-Dist: numpy==2.4.*
 Requires-Dist: scipy
 Requires-Dist: pillow
 Requires-Dist: scikit-image
@@ -46,7 +46,7 @@ Some of the methods also have been optimised to ensure higher computational effi
 The purpose of HTTomolibGPU
 ===========================
 
-Although **HTTomolibGPU** can be used as a stand-alone library, it has been specifically developed to work together with the 
+Although **HTTomolibGPU** can be used as a stand-alone library, it has been specifically developed to work together with the
 `HTTomo <https://diamondlightsource.github.io/httomo/>`_ package as
 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.
@@ -71,7 +71,7 @@ Conda environment
 
    $ conda create --name httomolibgpu # create a fresh conda environment
    $ conda activate httomolibgpu # activate the environment
-   $ conda install conda-forge::cupy==12.3.0
+   $ conda install conda-forge::cupy==14.0.*
    $ pip install httomolibgpu
 
 Setup the development environment:
@@ -80,6 +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 -c conda-forge cupy==12.3.0 # install dependencies
+   $ conda env create --name httomolibgpu -c conda-forge cupy==14.0.* # install dependencies
    $ conda activate httomolibgpu # activate the environment
    $ pip install -e ./httomolibgpu[dev] # editable/development mode

{httomolibgpu-5.4 → httomolibgpu-5.5.1}/README.rst

@@ -9,7 +9,7 @@ Some of the methods also have been optimised to ensure higher computational effi
 The purpose of HTTomolibGPU
 ===========================
 
-Although **HTTomolibGPU** can be used as a stand-alone library, it has been specifically developed to work together with the 
+Although **HTTomolibGPU** can be used as a stand-alone library, it has been specifically developed to work together with the
 `HTTomo <https://diamondlightsource.github.io/httomo/>`_ package as
 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.
@@ -34,7 +34,7 @@ Conda environment
 
    $ conda create --name httomolibgpu # create a fresh conda environment
    $ conda activate httomolibgpu # activate the environment
-   $ conda install conda-forge::cupy==12.3.0
+   $ conda install conda-forge::cupy==14.0.*
    $ pip install httomolibgpu
 
 Setup the development environment:
@@ -43,6 +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 -c conda-forge cupy==12.3.0 # install dependencies
+   $ conda env create --name httomolibgpu -c conda-forge cupy==14.0.* # install dependencies
    $ conda activate httomolibgpu # activate the environment
    $ pip install -e ./httomolibgpu[dev] # editable/development mode

{httomolibgpu-5.4 → httomolibgpu-5.5.1}/httomolibgpu/cuda_kernels/__init__.py

@@ -25,5 +25,5 @@ def load_cuda_module(
         code += f.read()
 
     return cp.RawModule(
-        options=("-std=c++11", *options), code=code, name_expressions=name_expressions
+        options=("-std=c++17", *options), code=code, name_expressions=name_expressions
     )

{httomolibgpu-5.4 → httomolibgpu-5.5.1}/httomolibgpu/cuda_kernels/calc_metrics.cu

@@ -321,7 +321,7 @@ __device__ void _calc_metrics_overlap(const float *mat1, int mat1_nx,
  * the compiler (rather than at runtime), which reduces the register count.
  */
 template <bool norm, bool use_overlap>
-__global__ void calc_metrics_kernel(const float *mat1, int mat1_nx,
+__device__ __forceinline__ void calc_metrics_kernel_impl(const float *mat1, int mat1_nx,
                                     const float *mat2, int mat2_nx,
                                     int win_width, int rows, int side,
                                     float *list_metric)
@@ -331,4 +331,28 @@ __global__ void calc_metrics_kernel(const float *mat1, int mat1_nx,
     } else {
         _calc_metrics_no_overlap<norm>(mat1, mat1_nx, mat2, mat2_nx, win_width, rows, side, list_metric);
     }
-}
+}
+
+extern "C" __global__ void calc_metrics_kernel(const float *mat1, int mat1_nx, const float *mat2, int mat2_nx,
+                                               int win_width, int rows, int side, float *list_metric)
+{
+    calc_metrics_kernel_impl<false, false>(mat1, mat1_nx, mat2, mat2_nx, win_width, rows, side, list_metric);
+}
+
+extern "C" __global__ void calc_metrics_kernel_norm(const float *mat1, int mat1_nx, const float *mat2, int mat2_nx,
+                                                    int win_width, int rows, int side, float *list_metric)
+{
+    calc_metrics_kernel_impl<true, false>(mat1, mat1_nx, mat2, mat2_nx, win_width, rows, side, list_metric);
+}
+
+extern "C" __global__ void calc_metrics_kernel_use_overlap(const float *mat1, int mat1_nx, const float *mat2, int mat2_nx,
+                                                           int win_width, int rows, int side, float *list_metric)
+{
+    calc_metrics_kernel_impl<false, true>(mat1, mat1_nx, mat2, mat2_nx, win_width, rows, side, list_metric);
+}
+
+extern "C" __global__ void calc_metrics_kernel_norm_use_overlap(const float *mat1, int mat1_nx, const float *mat2, int mat2_nx,
+                                                                int win_width, int rows, int side, float *list_metric)
+{
+    calc_metrics_kernel_impl<true, true>(mat1, mat1_nx, mat2, mat2_nx, win_width, rows, side, list_metric);
+}

httomolibgpu-5.5.1/httomolibgpu/cuda_kernels/median_kernel.cu

@@ -0,0 +1,114 @@
+template <typename Type, int diameter>
+__device__ __forceinline__ void median_general_kernel3d_impl(const Type *in, Type *out, float dif,
+                                                             int Z, int M, int N) {
+  constexpr int radius = diameter / 2;
+  constexpr int d3 = diameter * diameter * diameter;
+  constexpr int midpoint = d3 / 2;
+
+  Type ValVec[d3];
+  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);
+
+  int counter = 0;
+  for (int i_m = -radius; i_m <= radius; i_m++) {
+    long long i1 = i + i_m;   // using long long to avoid integer overflows
+    if ((i1 < 0) || (i1 >= N))
+      i1 = i;
+    for (int j_m = -radius; j_m <= radius; j_m++) {
+      long long j1 = j + j_m;
+      if ((j1 < 0) || (j1 >= M))
+        j1 = j;
+      for (int k_m = -radius; k_m <= radius; k_m++) {
+        long long k1 = k + k_m;
+        if ((k1 < 0) || (k1 >= Z))
+          k1 = k;
+        ValVec[counter] = in[i1 + N * j1 + N * M * k1];
+        counter++;
+      }
+    }
+  }  
+
+  /* do bubble sort here */
+  for (int x = 0; x < d3 - 1; x++) {
+    for (int y = 0; y < d3 - x - 1; y++) {
+      if (ValVec[y] > ValVec[y + 1]) {
+        Type temp = ValVec[y];
+        ValVec[y] = ValVec[y + 1];
+        ValVec[y + 1] = temp;
+      }
+    }
+  }
+
+  if (dif > 0.0f) {
+    /* perform dezingering */
+    out[index] =
+        fabsf(in[index] - ValVec[midpoint]) >= dif ? ValVec[midpoint] : in[index];
+  }
+  else out[index] = ValVec[midpoint]; /* median filtering */
+}
+
+extern "C" __global__ void median_general_kernel3d_float_3(const float *in, float *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<float, 3>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_float_5(const float *in, float *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<float, 5>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_float_7(const float *in, float *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<float, 7>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_float_9(const float *in, float *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<float, 9>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_float_11(const float *in, float *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<float, 11>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_float_13(const float *in, float *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<float, 13>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_unsigned_short_3(const unsigned short *in, unsigned short *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<unsigned short, 3>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_unsigned_short_5(const unsigned short *in, unsigned short *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<unsigned short, 5>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_unsigned_short_7(const unsigned short *in, unsigned short *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<unsigned short, 7>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_unsigned_short_9(const unsigned short *in, unsigned short *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<unsigned short, 9>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_unsigned_short_11(const unsigned short *in, unsigned short *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<unsigned short, 11>(in, out, dif, Z, M, N);
+}
+
+extern "C" __global__ void median_general_kernel3d_unsigned_short_13(const unsigned short *in, unsigned short *out, float dif, int Z, int M, int N)
+{
+  median_general_kernel3d_impl<unsigned short, 13>(in, out, dif, Z, M, N);
+}

{httomolibgpu-5.4 → httomolibgpu-5.5.1}/httomolibgpu/cuda_kernels/raven_filter.cu

@@ -1,8 +1,8 @@
 #include <cupy/complex.cuh>
 
 template <typename Type>
-__global__ void 
-raven_filter(
+__device__ __forceinline__ void 
+raven_filter_impl(
   complex<Type> *input,
   complex<Type> *output,
   int width, int images, int height, 
@@ -47,3 +47,19 @@ raven_filter(
 
   output[outIndex] = value;
 }
+
+extern "C" __global__ void raven_filter_float(complex<float> *input,
+                                              complex<float> *output,
+                                              int width, int images, int height, 
+                                              int u0, int n, int v0)
+{
+  raven_filter_impl<float>(input, output, width, images, height, u0, n, v0);
+}
+
+extern "C" __global__ void raven_filter_double(complex<double> *input,
+                                               complex<double> *output,
+                                               int width, int images, int height, 
+                                               int u0, int n, int v0)
+{
+  raven_filter_impl<double>(input, output, width, images, height, u0, n, v0);
+}

{httomolibgpu-5.4 → httomolibgpu-5.5.1}/httomolibgpu/cuda_kernels/remove_nan_inf.cu

@@ -1,5 +1,5 @@
 template <typename Type>
-__global__ void remove_nan_inf(Type *data, int Z, int M, int N, int *result) {
+__device__ __forceinline__ void remove_nan_inf_impl(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;
@@ -16,4 +16,14 @@ __global__ void remove_nan_inf(Type *data, int Z, int M, int N, int *result) {
     data[index] = zero;
   }
 
-}
+}
+
+extern "C" __global__ void remove_nan_inf_float(float *data, int Z, int M, int N, int *result)
+{
+  remove_nan_inf_impl<float>(data, Z, M, N, result);
+}
+
+extern "C" __global__ void remove_nan_inf_unsigned_short(unsigned short *data, int Z, int M, int N, int *result)
+{
+  remove_nan_inf_impl<unsigned short>(data, Z, M, N, result);
+}

{httomolibgpu-5.4 → httomolibgpu-5.5.1}/httomolibgpu/cuda_kernels/remove_stripe_fw.cu

@@ -1,5 +1,4 @@
-template<int WSize>
-__global__ void grouped_convolution_x(
+extern "C" __global__ void grouped_convolution_x(
     int dim_x,
     int dim_y,
     int dim_z,
@@ -10,7 +9,8 @@ __global__ void grouped_convolution_x(
     float* out,
     int out_stride_z,
     int out_stride_group,
-    const float* w
+    const float* w,
+    int wk
 )
 {
     const int g_thd_x = blockDim.x * blockIdx.x + threadIdx.x;
@@ -25,9 +25,9 @@ __global__ void grouped_convolution_x(
     for (int i = 0; i < out_groups; ++i)
     {
         float acc = 0.F;
-        for (int j = 0; j < WSize; ++j)
+        for (int j = 0; j < wk; ++j)
         {
-            const int w_idx = i * WSize + j;
+            const int w_idx = i * wk + j;
             const int in_idx = (g_thd_x * in_stride_x + j) + g_thd_y * in_stride_y + g_thd_z * in_stride_z;
             acc += w[w_idx] * in[in_idx];
         }
@@ -36,8 +36,7 @@ __global__ void grouped_convolution_x(
     }
 }
 
-template<int WSize>
-__global__ void grouped_convolution_y(
+extern "C" __global__ void grouped_convolution_y(
     int dim_x,
     int dim_y,
     int dim_z,
@@ -49,7 +48,8 @@ __global__ void grouped_convolution_y(
     float* out,
     int out_stride_z,
     int out_stride_group,
-    const float* w
+    const float* w,
+    int hk
 )
 {
     const int g_thd_x = blockDim.x * blockIdx.x + threadIdx.x;
@@ -68,9 +68,9 @@ __global__ void grouped_convolution_y(
         for (int i = 0; i < out_groups; ++i)
         {
             float acc = 0.F;
-            for (int j = 0; j < WSize; ++j)
+            for (int j = 0; j < hk; ++j)
             {
-                const int w_idx = (out_groups * group + i) * WSize + j;
+                const int w_idx = (out_groups * group + i) * hk + j;
                 const int in_idx = g_thd_x * in_stride_x + (item_stride_y * g_thd_y + j) * in_stride_y + group * in_stride_group + g_thd_z * in_stride_z;
                 acc += w[w_idx] * in[in_idx];
             }
@@ -80,8 +80,7 @@ __global__ void grouped_convolution_y(
     }
 }
 
-template<int WSize>
-__global__ void transposed_convolution_x(
+extern "C" __global__ void transposed_convolution_x(
     int dim_x,
     int dim_y,
     int dim_z,
@@ -90,6 +89,7 @@ __global__ void transposed_convolution_x(
     int in_stride_y,
     int in_stride_z,
     const float* w,
+    int wk,
     float* out
 )
 {
@@ -103,7 +103,7 @@ __global__ void transposed_convolution_x(
 
     constexpr int item_out_stride = 2;
     float acc = 0.F;
-    for (int i = 0; i < WSize; ++i)
+    for (int i = 0; i < wk; ++i)
     {
         const int in_x = (g_thd_x - i) / item_out_stride;
         const int in_x_mod = (g_thd_x - i) % item_out_stride;
@@ -117,8 +117,7 @@ __global__ void transposed_convolution_x(
     out[out_idx] = acc;
 }
 
-template<int WSize>
-__global__ void transposed_convolution_y(
+extern "C" __global__ void transposed_convolution_y(
     int dim_x,
     int dim_y,
     int dim_z,
@@ -127,6 +126,7 @@ __global__ void transposed_convolution_y(
     int in_stride_y,
     int in_stride_z,
     const float* w,
+    int hk,
     float* out
 )
 {
@@ -140,7 +140,7 @@ __global__ void transposed_convolution_y(
 
     constexpr int item_out_stride = 2;
     float acc = 0.F;
-    for (int i = 0; i < WSize; ++i)
+    for (int i = 0; i < hk; ++i)
     {
         const int in_y = (g_thd_y - i) / item_out_stride;
         const int in_y_mod = (g_thd_y - i) % item_out_stride;

{httomolibgpu-5.4 → httomolibgpu-5.5.1}/httomolibgpu/misc/corr.py

@@ -20,21 +20,25 @@
 # ---------------------------------------------------------------------------
 """Module for data correction. For more detailed information see :ref:`data_correction_module`."""
 
-import numpy as np
-from typing import Union
-
 from httomolibgpu import cupywrapper
 
 cp = cupywrapper.cp
 cupy_run = cupywrapper.cupy_run
 
-from numpy import float32
 from unittest.mock import Mock
 
 if cupy_run:
     from httomolibgpu.cuda_kernels import load_cuda_module
 else:
     load_cuda_module = Mock()
+from typing import Union
+
+from httomolibgpu.misc.utils import (
+    __check_variable_type,
+    __check_if_data_3D_array,
+    __check_if_data_correct_type,
+    __check_if_positive_nonzero,
+)
 
 __all__ = [
     "median_filter",
@@ -45,7 +49,7 @@ __all__ = [
 def median_filter(
     data: cp.ndarray,
     kernel_size: int = 3,
-    dif: float = 0.0,
+    dif: Union[float, int] = 0.0,
 ) -> cp.ndarray:
     """
     Applies 3D median filter to a 3D CuPy array. For more detailed information, see :ref:`method_median_filter`.
@@ -54,9 +58,9 @@ def median_filter(
     ----------
     data : cp.ndarray
         Input CuPy 3D array either float32 or uint16 data type.
-    kernel_size : int, optional
-        The size of the filter's kernel (a diameter).
-    dif : float, optional
+    kernel_size : int
+        The size of the filter's kernel (a "diameter").
+    dif : float, int
         Expected difference value between outlier value and the
         median value of the array, leave equal to 0 for classical median.
 
@@ -70,25 +74,25 @@ def median_filter(
     ValueError
         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")
-
-    if data.ndim == 3:
-        if 0 in data.shape:
-            raise ValueError("The length of one of dimensions is equal to zero")
-    else:
-        raise ValueError("The input array must be a 3D array")
-
-    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")
+    ### Data and parameters checks ###
+    methods_name = "median_filter/remove_outlier"
+    __check_if_data_3D_array(data, methods_name)
+    __check_if_data_correct_type(
+        data, accepted_type=["float32", "uint16"], methods_name=methods_name
+    )
+    __check_variable_type(
+        kernel_size, [int], "kernel_size", [3, 5, 7, 9, 11, 13], methods_name
+    )
+    __check_variable_type(dif, [int, float], "dif", [], methods_name)
+    ###################################
 
     dz, dy, dx = data.shape
+    input_type = data.dtype
     output = cp.copy(data, order="C")
 
     # 3d median or dezinger
-    kernel_args = "median_general_kernel3d<{0}, {1}>".format(
-        "float" if input_type == "float32" else "unsigned short", kernel_size
+    kernel_name = "median_general_kernel3d_{0}_{1}".format(
+        "float" if input_type == "float32" else "unsigned_short", kernel_size
     )
     block_x = 128
     # setting grid/block parameters
@@ -99,8 +103,8 @@ def median_filter(
     grid_dims = (grid_x, grid_y, grid_z)
     params = (data, output, cp.float32(dif), dz, dy, dx)
 
-    median_module = load_cuda_module("median_kernel", name_expressions=[kernel_args])
-    median_filt = median_module.get_function(kernel_args)
+    median_module = load_cuda_module("median_kernel")
+    median_filt = median_module.get_function(kernel_name)
 
     median_filt(grid_dims, block_dims, params)
 
@@ -108,7 +112,7 @@ def median_filter(
 
 
 def remove_outlier(
-    data: cp.ndarray, kernel_size: int = 3, dif: float = 1000
+    data: cp.ndarray, kernel_size: int = 3, dif: Union[float, int] = 1000
 ) -> cp.ndarray:
     """Selectively applies 3D median filter to a 3D CuPy array to remove outliers. Also called a dezinger.
     For more detailed information, see :ref:`method_outlier_removal`.
@@ -117,9 +121,9 @@ def remove_outlier(
     ----------
     data : cp.ndarray
         Input CuPy 3D array either float32 or uint16 data type.
-    kernel_size : int, optional
-        The size of the filter's kernel (a diameter).
-    dif : float, optional
+    kernel_size : int
+        The size of the filter's kernel (a "diameter").
+    dif : float, int
         Expected difference value between the outlier value (central voxel) and the
         median value of the neighbourhood. Lower values lead to median filtering.
 
@@ -133,8 +137,9 @@ def remove_outlier(
     ValueError
         Threshold value (dif) must be positive and nonzero.
     """
-
-    if dif <= 0.0:
-        raise ValueError("Threshold value (dif) must be positive and nonzero.")
-
+    ### Data and parameters checks ###
+    __check_if_positive_nonzero(
+        dif, "dif", positive=True, nonzero=True, methods_name="remove_outlier"
+    )
+    ###################################
     return median_filter(data, kernel_size, dif)

{httomolibgpu-5.4 → httomolibgpu-5.5.1}/httomolibgpu/misc/denoise.py

@@ -20,8 +20,6 @@
 # ---------------------------------------------------------------------------
 """Module for data denoising. For more detailed information see :ref:`data_denoising_module`."""
 
-import numpy as np
-
 from httomolibgpu import cupywrapper
 
 cp = cupywrapper.cp
@@ -35,6 +33,13 @@ else:
     ROF_TV = Mock()
     PD_TV = Mock()
 
+from typing import Union
+
+from httomolibgpu.misc.utils import (
+    __check_variable_type,
+    __check_if_data_3D_array,
+    __check_if_data_correct_type,
+)
 
 __all__ = [
     "total_variation_ROF",
@@ -44,7 +49,7 @@ __all__ = [
 
 def total_variation_ROF(
     data: cp.ndarray,
-    regularisation_parameter: float = 1e-05,
+    regularisation_parameter: Union[float, int] = 1e-05,
     iterations: int = 3000,
     time_marching_parameter: float = 0.001,
     gpu_id: int = 0,
@@ -55,7 +60,6 @@ def total_variation_ROF(
     This is a gradient-based algorithm for a smoothed TV term which requires a small time marching parameter and a significant number of iterations.
     See more in :ref:`method_total_variation_ROF`.
 
-
     Parameters
     ----------
     data : cp.ndarray
@@ -81,6 +85,26 @@ def total_variation_ROF(
     ValueError
         If the input array is not float32 data type.
     """
+    ### Data and parameters checks ###
+    methods_name = "total_variation_ROF"
+    __check_if_data_3D_array(data, methods_name)
+    __check_if_data_correct_type(
+        data, accepted_type=["float32"], methods_name=methods_name
+    )
+    __check_variable_type(
+        regularisation_parameter,
+        [float, int],
+        "regularisation_parameter",
+        [],
+        methods_name,
+    )
+    __check_variable_type(iterations, [int], "iterations", [], methods_name)
+    __check_variable_type(
+        time_marching_parameter, [float], "time_marching_parameter", [], methods_name
+    )
+    __check_variable_type(gpu_id, [int], "gpu_id", [], methods_name)
+    __check_variable_type(half_precision, [bool], "half_precision", [], methods_name)
+    ###################################
 
     return ROF_TV_cupy(
         data,
@@ -94,11 +118,11 @@ def total_variation_ROF(
 
 def total_variation_PD(
     data: cp.ndarray,
-    regularisation_parameter: float = 1e-05,
+    regularisation_parameter: Union[float, int] = 1e-05,
     iterations: int = 1000,
     isotropic: bool = True,
     nonnegativity: bool = False,
-    lipschitz_const: float = 8.0,
+    lipschitz_const: Union[float, int] = 8.0,
     gpu_id: int = 0,
     half_precision: bool = False,
 ) -> cp.ndarray:
@@ -109,7 +133,7 @@ def total_variation_PD(
     ----------
     data : cp.ndarray
         Input CuPy 3D array of float32 data type.
-    regularisation_parameter : float
+    regularisation_parameter : float, int
         Regularisation parameter to control the level of smoothing. Defaults to 1e-05.
     iterations : int
         The number of iterations. Defaults to 1000.
@@ -117,7 +141,7 @@ def total_variation_PD(
         Choose between isotropic or anisotropic TV norm. Defaults to isotropic.
     nonnegativity  : bool
         Enable non-negativity in iterations. Defaults to False.
-    lipschitz_const : float
+    lipschitz_const : float,int
         Lipschitz constant to control convergence. Defaults to 8.
     gpu_id : int
         GPU device index to perform processing on. Defaults to 0.
@@ -135,6 +159,27 @@ def total_variation_PD(
         If the input array is not float32 data type.
     """
 
+    ### Data and parameters checks ###
+    methods_name = "total_variation_PD"
+    __check_if_data_3D_array(data, methods_name)
+    __check_if_data_correct_type(
+        data, accepted_type=["float32"], methods_name=methods_name
+    )
+    __check_variable_type(
+        regularisation_parameter,
+        [float, int],
+        "regularisation_parameter",
+        [],
+        methods_name,
+    )
+    __check_variable_type(iterations, [int], "iterations", [], methods_name)
+    __check_variable_type(isotropic, [bool], "isotropic", [], methods_name)
+    __check_variable_type(nonnegativity, [bool], "nonnegativity", [], methods_name)
+    __check_variable_type(lipschitz_const, [float, int], "lipschitz_const", [], methods_name)
+    __check_variable_type(gpu_id, [int], "gpu_id", [], methods_name)
+    __check_variable_type(half_precision, [bool], "half_precision", [], methods_name)
+    ###################################
+
     methodTV = 0
     if not isotropic:
         methodTV = 1