httomolibgpu 2.2__tar.gz → 2.3__tar.gz

{httomolibgpu-2.2/httomolibgpu.egg-info → httomolibgpu-2.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: httomolibgpu
-Version: 2.2
+Version: 2.3
 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
@@ -12,12 +12,14 @@ Classifier: Environment :: GPU :: NVIDIA CUDA
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: cupy
+Requires-Dist: cupy==12.3.0
+Requires-Dist: nvtx
 Requires-Dist: numpy
 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"
@@ -43,10 +45,10 @@ Some of the methods also have been optimised to ensure higher computational effi
 The purpose of HTTomolibGPU
 ===========================
 
-**HTTomolibGPU** can be used as a stand-alone library, see Examples section in `Documentation <https://diamondlightsource.github.io/httomolibgpu/>`_.
-However, it has been specifically developed to work together with the `HTTomo <https://diamondlightsource.github.io/httomo/>`_ package as
+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.
+MPI protocols or as well serially.
 
 Install HTTomolibGPU as a PyPi package
 =========================================================

{httomolibgpu-2.2 → httomolibgpu-2.3}/README.rst

@@ -9,10 +9,10 @@ Some of the methods also have been optimised to ensure higher computational effi
 The purpose of HTTomolibGPU
 ===========================
 
-**HTTomolibGPU** can be used as a stand-alone library, see Examples section in `Documentation <https://diamondlightsource.github.io/httomolibgpu/>`_.
-However, it has been specifically developed to work together with the `HTTomo <https://diamondlightsource.github.io/httomo/>`_ package as
+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.
+MPI protocols or as well serially.
 
 Install HTTomolibGPU as a PyPi package
 =========================================================

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu/__init__.py

@@ -1,4 +1,5 @@
 from httomolibgpu.misc.corr import median_filter, remove_outlier
+from httomolibgpu.misc.denoise import total_variation_ROF, total_variation_PD
 from httomolibgpu.misc.morph import sino_360_to_180, data_resampler
 from httomolibgpu.misc.rescale import rescale_to_int
 from httomolibgpu.prep.alignment import distortion_correction_proj_discorpy

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu/cuda_kernels/center_360_shifts.cu

@@ -1,7 +1,7 @@
 #include <cupy/complex.cuh>
 
 extern "C" __global__ void
-shift_whole_shifts(const float *sino2, const float *sino3,
+shift_whole_shifts(const float *flip_sino, const float *comp_sino,
                    const float *__restrict__ list_shift, float *mat, int nx,
                    int nymat) {
   int xid = threadIdx.x + blockIdx.x * blockDim.x;
@@ -17,14 +17,14 @@ shift_whole_shifts(const float *sino2, const float *sino3,
   float frac_part = modf(shift_col, &int_part);
   if (abs(frac_part) > 1e-5f) {
     // we have a floating point shift, so we only roll in
-    // sino3, but we leave the rest for later using scipy
+    // comp_sino, but we leave the rest for later using scipy
     int shift_int =
         shift_col >= 0.0 ? int(ceil(shift_col)) : int(floor(shift_col));
     if (shift_int >= 0 && xid < shift_int) {
-      mat[zid * nymat * nx + yid * nx + xid] = sino3[yid * nx + xid];
+      mat[zid * nymat * nx + yid * nx + xid] = comp_sino[yid * nx + xid];
     }
     if (shift_int < 0 && xid >= nx + shift_int) {
-      mat[zid * nymat * nx + yid * nx + xid] = sino3[yid * nx + xid];
+      mat[zid * nymat * nx + yid * nx + xid] = comp_sino[yid * nx + xid];
     }
   } else {
     // we have an integer shift, so we can roll in directly
@@ -33,16 +33,16 @@ shift_whole_shifts(const float *sino2, const float *sino3,
     if (shift_int >= 0) {
       if (xid >= shift_int) {
         mat[zid * nymat * nx + yid * nx + xid] =
-            sino2[yid * nx + xid - shift_int];
+            flip_sino[yid * nx + xid - shift_int];
       } else {
-        mat[zid * nymat * nx + yid * nx + xid] = sino3[yid * nx + xid];
+        mat[zid * nymat * nx + yid * nx + xid] = comp_sino[yid * nx + xid];
       }
     } else {
       if (xid < nx + shift_int) {
         mat[zid * nymat * nx + yid * nx + xid] =
-            sino2[yid * nx + xid - shift_int];
+            flip_sino[yid * nx + xid - shift_int];
       } else {
-        mat[zid * nymat * nx + yid * nx + xid] = sino3[yid * nx + xid];
+        mat[zid * nymat * nx + yid * nx + xid] = comp_sino[yid * nx + xid];
       }
     }
   }

httomolibgpu-2.3/httomolibgpu/cuda_kernels/generate_mask.cu

@@ -0,0 +1,103 @@
+extern "C" __global__ void generate_mask(const int ncol, const int nrow,
+                                         const int cen_col, const int cen_row,
+                                         const float du, const float dv,
+                                         const float radius, const float drop,
+                                         unsigned short *mask) {
+  int i = blockDim.x * blockIdx.x + threadIdx.x;
+  int j = blockIdx.y;
+
+  if (i >= ncol/2+1)
+    return;
+
+  // we only need to look at the right half as we're using a real2complex FFT
+  int outi = i;
+  i += ncol/2-1;
+
+  int pos = __float2int_ru(((j - cen_row) * dv / radius) / du);
+  int pos1 = -pos + cen_col;
+  int pos2 = pos + cen_col;
+
+  if (pos1 > pos2) {
+    int temp = pos1;
+    pos1 = pos2;
+    pos2 = temp;
+    if (pos1 >= ncol) {
+      pos1 = ncol - 1;
+    }
+    if (pos2 < 0) {
+      pos2 = 0;
+    }
+  } else {
+    if (pos1 < 0) {
+      pos1 = 0;
+    }
+    if (pos2 >= ncol) {
+      pos2 = ncol - 1;
+    }
+  }
+
+  short outval = (pos1 <= i && i <= pos2) ? 1 : 0;
+
+  // mask[cen_row - drop: cen_row + drop + 1, :] = 0
+  if (j >= cen_row - drop && j <= cen_row + drop) {
+    outval = 0;
+  }
+  // mask[:, cen_col - 1: cen_col + 2] = 0
+  if (i >= cen_col - 1 && i <= cen_col + 1) {
+    outval = 0;
+  }
+
+  mask[j * (ncol/2+1) + outi] = outval;
+}
+
+extern "C" __global__ void generate_mask_full(const int ncol, const int nrow,
+                                              const int cen_col, const int cen_row,
+                                              const float du, const float dv,
+                                              const float radius, const float drop,
+                                              float *mask) {
+  int i = blockDim.x * blockIdx.x + threadIdx.x;
+  int j = blockIdx.y;
+
+  if (i >= ncol)
+    return;
+
+  // we only need to look at the right half as we're using a real2complex FFT
+  int outi = i;
+  //i += ncol-1;
+
+  int pos = __float2int_ru(((j - cen_row) * dv / radius) / du);
+  int pos1 = -pos + cen_col;
+  int pos2 = pos + cen_col;
+
+  if (pos1 > pos2) {
+    int temp = pos1;
+    pos1 = pos2;
+    pos2 = temp;
+    if (pos1 >= ncol) {
+      pos1 = ncol - 1;
+    }
+    if (pos2 < 0) {
+      pos2 = 0;
+    }
+  } else {
+    if (pos1 < 0) {
+      pos1 = 0;
+    }
+    if (pos2 >= ncol) {
+      pos2 = ncol - 1;
+    }
+  }
+
+  float outval = (pos1 <= i && i <= pos2) ? 1.0 : 0.0;
+
+  // mask[cen_row - drop: cen_row + drop + 1, :] = 0
+  if (j >= cen_row - drop && j <= cen_row + drop) {
+    outval = 0;
+  }
+  // mask[:, cen_col - 1: cen_col + 2] = 0
+  if (i >= cen_col - 1 && i <= cen_col + 1) {
+    outval = 0;
+  }
+
+  mask[j * ncol + outi] = outval;
+}

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu/cupywrapper.py

@@ -1,3 +1,4 @@
+cupy_run = False
 try:
     import cupy as cp
     import nvtx
@@ -6,7 +7,7 @@ try:
         cp.cuda.Device(0).compute_capability
         cupy_run = True
     except cp.cuda.runtime.CUDARuntimeError:
-        print("CuPy library is a major dependency for HTTomolibgpu, please install")
+        print("CuPy library is installed but GPU is not accessible")
         import numpy as cp
 except ImportError as e:
     print(
@@ -15,6 +16,4 @@ except ImportError as e:
     from unittest.mock import Mock
     import numpy as cp
 
-    cupy_run = False
-
     nvtx = Mock()

httomolibgpu-2.3/httomolibgpu/misc/denoise.py

@@ -0,0 +1,141 @@
+#!/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: 18/December/2024
+# ---------------------------------------------------------------------------
+""" Module for data denoising. For more detailed information see :ref:`data_denoising_module`.
+"""
+
+import numpy as np
+from typing import Union, Optional
+
+from httomolibgpu import cupywrapper
+
+cp = cupywrapper.cp
+cupy_run = cupywrapper.cupy_run
+
+from numpy import float32
+from unittest.mock import Mock
+
+from ccpi.filters.regularisersCuPy import ROF_TV, PD_TV
+
+__all__ = [
+    "total_variation_ROF",
+    "total_variation_PD",
+]
+
+
+def total_variation_ROF(
+    data: cp.ndarray,
+    regularisation_parameter: Optional[float] = 1e-05,
+    iterations: Optional[int] = 3000,
+    time_marching_parameter: Optional[float] = 0.001,
+    gpu_id: Optional[int] = 0,
+) -> cp.ndarray:
+    """
+    Total Variation using Rudin-Osher-Fatemi (ROF) :cite:`rudin1992nonlinear` explicit iteration scheme to perform edge-preserving image denoising.
+    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
+        Input CuPy 3D array of float32 data type.
+    regularisation_parameter : float, optional
+        Regularisation parameter to control the level of smoothing. Defaults to 1e-05.
+    iterations : int, optional
+        The number of iterations. Defaults to 3000.
+    time_marching_parameter : float, optional
+        Time marching parameter, needs to be small to ensure convergence. Defaults to 0.001.
+    gpu_id : int, optional
+        GPU device index to perform processing on. Defaults to 0.
+
+    Returns
+    -------
+    ndarray
+        TV-ROF filtered 3D CuPy array in float32 data type.
+
+    Raises
+    ------
+    ValueError
+        If the input array is not float32 data type.
+    """
+
+    return ROF_TV(
+        data, regularisation_parameter, iterations, time_marching_parameter, gpu_id
+    )
+
+
+def total_variation_PD(
+    data: cp.ndarray,
+    regularisation_parameter: Optional[float] = 1e-05,
+    iterations: Optional[int] = 1000,
+    isotropic: Optional[bool] = True,
+    nonnegativity: Optional[bool] = False,
+    lipschitz_const: Optional[float] = 8.0,
+    gpu_id: Optional[int] = 0,
+) -> cp.ndarray:
+    """
+    Primal Dual algorithm for non-smooth convex Total Variation functional :cite:`chan1999nonlinear`. See more in :ref:`method_total_variation_PD`.
+
+    Parameters
+    ----------
+    data : cp.ndarray
+        Input CuPy 3D array of float32 data type.
+    regularisation_parameter : float
+        Regularisation parameter to control the level of smoothing. Defaults to 1e-05.
+    iterations : int
+        The number of iterations. Defaults to 1000.
+    isotropic : bool
+        Choose between isotropic or anisotropic TV norm. Defaults to isotropic.
+    nonnegativity  : bool
+        Enable non-negativity in iterations. Defaults to False.
+    lipschitz_const : float
+        Lipschitz constant to control convergence. Defaults to 8.
+    gpu_id : int
+        GPU device index to perform processing on. Defaults to 0.
+
+    Returns
+    -------
+    ndarray
+        TV-PD filtered 3D CuPy array in float32 data type.
+
+    Raises
+    ------
+    ValueError
+        If the input array is not float32 data type.
+    """
+
+    methodTV = 0
+    if not isotropic:
+        methodTV = 1
+
+    nonneg = 0
+    if nonnegativity:
+        nonneg = 1
+
+    return PD_TV(
+        data,
+        regularisation_parameter,
+        iterations,
+        methodTV,
+        nonneg,
+        lipschitz_const,
+        gpu_id,
+    )

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu/misc/morph.py

@@ -104,25 +104,37 @@ def sino_360_to_180(
 def data_resampler(
     data: cp.ndarray, newshape: list, axis: int = 1, interpolation: str = "linear"
 ) -> cp.ndarray:
-    """Down/Up-resampler of the input data implemented through interpn function.
-       Please note that the method will leave the specified axis
-       dimension unchanged, e.g. (128,128,128) -> (128,256,256) for axis = 0 and
-       newshape = [256,256].
-
-    Args:
-        data (cp.ndarray): 3d cupy array.
-        newshape (list): 2d list that defines the 2D slice shape of new shape data.
-        axis (int, optional): Axis along which the scaling is applied. Defaults to 1.
-        interpolation (str, optional): Selection of interpolation method. Defaults to 'linear'.
-
-    Raises:
+    """
+    Down/Up-resampler of the input data implemented through interpn function.
+    Please note that the method will leave the specified axis
+    dimension unchanged, e.g. (128,128,128) -> (128,256,256) for axis = 0 and
+    newshape = [256,256].
+
+    Parameters
+    ----------
+    data : cp.ndarray 
+        3d cupy array.
+    newshape : list
+        2d list that defines the 2D slice shape of new shape data.
+    axis : int, optional
+        Axis along which the scaling is applied. Defaults to 1.
+    interpolation : str, optional
+        Selection of interpolation method. Defaults to 'linear'.
+
+    Raises
+    ----------
         ValueError: When data is not 3D
 
-    Returns:
+    Returns
+    -------
         cp.ndarray: Up/Down-scaled 3D cupy array
     """
-    if data.ndim != 3:
-        raise ValueError("only 3D data is supported")
+    expanded = False
+    # if 2d data is given it is extended into a 3D array along the vertical dimension
+    if data.ndim == 2:
+        expanded = True
+        data = cp.expand_dims(data, 1)
+        axis = 1
 
     N, M, Z = cp.shape(data)
 
@@ -214,4 +226,6 @@ def data_resampler(
                 res, [newshape[0], newshape[1]], order="C"
             )
 
+    if expanded:
+        scaled_data = cp.squeeze(scaled_data, axis=axis)
     return scaled_data

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu/prep/phase.py

@@ -128,7 +128,6 @@ def paganin_filter_savu(
     # Note: this takes considerable time on GPU...
     data = cp.pad(data, ((0, 0), (pad_y, pad_y), (pad_x, pad_x)), mode=pad_method)
 
-    # Define array to hold result, which will not have the padding applied to it
     precond_kernel_float = cp.ElementwiseKernel(
         "T data",
         "T out",

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu/prep/stripe.py

@@ -394,13 +394,13 @@ def raven_filter(
         Numpy pad method to use.
 
     uvalue : int, optional
-        The shape of filter.
+        Cut-off frequency. To control the strength of filter, e.g., strong=10, moderate=20, weak=50.
 
     nvalue : int, optional
         The shape of filter.
 
     vvalue : int, optional
-        The number of rows to be applied the filter
+        Number of image-rows around the zero-frequency to be applied the filter.
 
     Returns
     -------
@@ -447,6 +447,7 @@ def raven_filter(
     raven_filt = raven_module.get_function(kernel_args)
 
     raven_filt(grid_dims, block_dims, params)
+    del fft_data_shifted
 
     # raven_filt already doing ifftshifting
     data = ifft2(fft_data, axes=(0, 2), overwrite_x=True)

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu/recon/algorithm.py

@@ -54,15 +54,15 @@ def FBP(
     data: cp.ndarray,
     angles: np.ndarray,
     center: Optional[float] = None,
-    filter_freq_cutoff: Optional[float] = 1.1,
+    filter_freq_cutoff: Optional[float] = 0.35,
     recon_size: Optional[int] = None,
-    recon_mask_radius: Optional[float] = None,
+    recon_mask_radius: Optional[float] = 0.95,
     gpu_id: int = 0,
 ) -> cp.ndarray:
     """
     Perform Filtered Backprojection (FBP) reconstruction using ASTRA toolbox :cite:`van2016fast` and
     ToMoBAR :cite:`kazantsev2020tomographic` wrappers.
-    This is a 3D recon from a CuPy array directly and a custom built filter.
+    This is a 3D recon from the CuPy array directly and using a custom built SINC filter for filtration in Fourier space.
 
     Parameters
     ----------
@@ -72,16 +72,16 @@ def FBP(
         An array of angles given in radians.
     center : float, optional
         The center of rotation (CoR).
-    filter_freq_cutoff : float, optional
-        Cutoff frequency parameter for the sinc filter, the lowest values produce more crispy but noisy reconstruction.
+    filter_freq_cutoff : float
+        Cutoff frequency parameter for the SINC filter, the lower values produce better contrast but noisy reconstruction.
     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, optional
+    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 diameter will be set to zero.
-        None by default, to see the effect of the mask try setting the value in the range [0.7-1.0].
-    gpu_id : int, optional
+        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].
+    gpu_id : int
         A GPU device index to perform operation on.
 
     Returns
@@ -109,7 +109,7 @@ def LPRec(
     angles: np.ndarray,
     center: Optional[float] = None,
     recon_size: Optional[int] = None,
-    recon_mask_radius: Optional[float] = None,
+    recon_mask_radius: Optional[float] = 0.95,
 ) -> cp.ndarray:
     """
     Fourier direct inversion in 3D on unequally spaced (also called as Log-Polar) grids using
@@ -127,10 +127,10 @@ 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, optional
+    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 diameter will be set to zero.
-        None by default, to see the effect of the mask try setting the value in the range [0.7-1.0].
+        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].
 
     Returns
     -------

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu/recon/rotation.py

@@ -33,13 +33,16 @@ if cupy_run:
     from cupyx.scipy.ndimage import shift, gaussian_filter
     from skimage.registration import phase_cross_correlation
     from cupyx.scipy.fftpack import get_fft_plan
-    from cupyx.scipy.fft import rfft2
+    from cupyx.scipy.fft import fft2, fftshift
 else:
     load_cuda_module = Mock()
     shift = Mock()
     gaussian_filter = Mock()
     phase_cross_correlation = Mock()
     get_fft_plan = Mock()
+    fft2 = Mock()
+    fftshift = Mock()
+    fft = Mock()
     rfft2 = Mock()
 
 import math
@@ -55,92 +58,131 @@ __all__ = [
 def find_center_vo(
     data: cp.ndarray,
     ind: Optional[int] = None,
-    smin: int = -50,
-    smax: int = 50,
+    average_radius: int = 0,
+    cor_initialisation_value: Optional[float] = None,
+    smin: int = -100,
+    smax: int = 100,
     srad: float = 6.0,
     step: float = 0.25,
     ratio: float = 0.5,
     drop: int = 20,
-) -> float:
+) -> np.float32:
     """
-    Find rotation axis location (aka CoR) using Nghia Vo's method. See the paper
+    Find the rotation axis location (aka the centre of rotation) using Nghia Vo's method. See the paper
     :cite:`vo2014reliable`.
 
     Parameters
     ----------
     data : cp.ndarray
-        3D tomographic data or a 2D sinogram as a CuPy array.
+        3D [angles, detY, detX] tomographic data or a 2D [angles, detX] sinogram as a CuPy array.
     ind : int, optional
-        Index of the slice to be used to estimate the CoR.
-    smin : int, optional
+        Index of the slice to be used to estimate the CoR. If None is given, then the central sinogram will be extracted from the data array with a possible averaging, see .
+    average_radius : int
+        Averaging multiple sinograms around the ind-indexed sinogram to improve the signal-to-noise ratio. It is recommended to keep this parameter smaller than 10.
+    cor_initialisation_value : float, optional
+        The initial approximation for the centre of rotation. If the value is None, use the horizontal centre of the projection/sinogram image.
+    smin : int
         Coarse search radius. Reference to the horizontal center of
         the sinogram.
-    smax : int, optional
+    smax : int
         Coarse search radius. Reference to the horizontal center of
         the sinogram.
-    srad : float, optional
+    srad : float
         Fine search radius.
-    step : float, optional
+    step : float
         Step of fine searching.
-    ratio : float, optional
+    ratio : float
         The ratio between the FOV of the camera and the size of object.
         It's used to generate the mask.
-    drop : int, optional
+    drop : int
         Drop lines around vertical center of the mask.
 
     Returns
     -------
-    float
-        Rotation axis location.
+    float32
+        Rotation axis location with a subpixel precision.
     """
+    # if 2d sinogram is given it is extended into a 3D array along the vertical dimension
     if data.ndim == 2:
         data = cp.expand_dims(data, 1)
         ind = 0
 
-    height = data.shape[1]
+    angles_tot, detY_size, detX_size = data.shape
 
     if ind is None:
-        ind = height // 2
-        if height > 10:
-            _sino = cp.mean(data[:, ind - 5 : ind + 5, :], axis=1)
+        ind = detY_size // 2  # middle slice index
+        # averaging the data here to improve SNR
+        if 2 * average_radius >= detY_size:
+            # reduce the averaging radius
+            average_radius = ind
+        if ind > 0:
+            _sino = cp.mean(
+                data[:, ind - average_radius : ind + average_radius, :], axis=1
+            )
         else:
             _sino = data[:, ind, :]
     else:
         _sino = data[:, ind, :]
 
+    if cor_initialisation_value is None:
+        cor_initialisation_value = (detX_size - 1.0) / 2.0
+
+    # downsampling ratios
+    dsp_angle = 1
+    dsp_detX = 1
+    if detX_size > 2000:
+        dsp_detX = 4
+    if angles_tot > 2000:
+        dsp_angle = 2
+
+    start_cor = np.int16(np.floor(1.0 * (cor_initialisation_value + smin) / dsp_detX))
+    stop_cor = np.int16(np.ceil(1.0 * (cor_initialisation_value + smax) / dsp_detX))
+    fine_srange = max(srad, dsp_detX)
+    off_set = 0.5 * dsp_detX if dsp_detX > 1 else 0.0
+
+    # initiate denoising
     _sino_cs = gaussian_filter(_sino, (3, 1), mode="reflect")
     _sino_fs = gaussian_filter(_sino, (2, 2), mode="reflect")
 
-    if _sino.shape[0] * _sino.shape[1] > 4e6:
-        # data is large, so downsample it before performing search for
-        # centre of rotation
-        _sino_coarse = _downsample(_sino_cs, 2, 1)
-        init_cen = _search_coarse(_sino_coarse, smin / 4.0, smax / 4.0, ratio, drop)
-        fine_cen = _search_fine(_sino_fs, srad, step, init_cen * 4.0, ratio, drop)
-    else:
-        init_cen = _search_coarse(_sino_cs, smin, smax, ratio, drop)
-        fine_cen = _search_fine(_sino_fs, srad, step, init_cen, ratio, drop)
+    # Downsampling by averaging along a chosen dimension
+    if dsp_angle > 1 or dsp_detX > 1:
+        _sino_cs = _downsample(_sino_cs, dsp_angle, dsp_detX)
+
+    init_cen = _search_coarse(_sino_cs, start_cor, stop_cor, ratio, drop)
 
-    return cp.asnumpy(fine_cen)
+    fine_cen = _search_fine(
+        _sino_fs, fine_srange, step, float(init_cen) * dsp_detX + off_set, ratio, drop
+    )
+    cen_np = np.float32(cp.asnumpy(fine_cen))
+    if cen_np == 0.0:
+        return np.float32(cor_initialisation_value)
+    else:
+        return cen_np
 
 
 def _search_coarse(sino, smin, smax, ratio, drop):
     (nrow, ncol) = sino.shape
     flip_sino = cp.ascontiguousarray(cp.fliplr(sino))
     comp_sino = cp.ascontiguousarray(cp.flipud(sino))
-    mask = _create_mask(2 * nrow, ncol, 0.5 * ratio * ncol, drop)
 
+    mask = _create_mask(2 * nrow, ncol, 0.5 * ratio * ncol, drop)
     cen_fliplr = (ncol - 1.0) / 2.0
-    smin_clip_val = max(min(smin + cen_fliplr, ncol - 1), 0)
-    smin = smin_clip_val - cen_fliplr
-    smax_clip_val = max(min(smax + cen_fliplr, ncol - 1), 0)
-    smax = smax_clip_val - cen_fliplr
-    start_cor = ncol // 2 + smin
-    stop_cor = ncol // 2 + smax
-    list_cor = cp.arange(start_cor, stop_cor + 0.5, 0.5, dtype=cp.float32)
+    start_cor, stop_cor = np.sort((smin, smax))
+    start_cor = np.int16(np.clip(start_cor, 0, ncol - 1))
+    stop_cor = np.int16(np.clip(stop_cor, 0, ncol - 1))
+    list_cor = cp.arange(start_cor, stop_cor + 1.0, dtype=cp.float32)
     list_shift = 2.0 * (list_cor - cen_fliplr)
     list_metric = cp.empty(list_shift.shape, dtype=cp.float32)
-    _calculate_metric(list_shift, sino, flip_sino, comp_sino, mask, list_metric)
+
+    sino_sino = cp.vstack((sino, flip_sino))
+    for i, shift in enumerate(list_shift):
+        _sino = sino_sino[nrow:]
+        _sino[...] = cp.roll(flip_sino, int(shift), axis=1)
+        if shift >= 0:
+            _sino[:, :shift] = comp_sino[:, :shift]
+        else:
+            _sino[:, shift:] = comp_sino[:, shift:]
+        list_metric[i] = cp.mean(cp.abs(fftshift(fft2(sino_sino))) * mask)
 
     minpos = cp.argmin(list_metric)
     if minpos == 0:
@@ -161,10 +203,10 @@ def _search_fine(sino, srad, step, init_cen, ratio, drop):
     mask = _create_mask(2 * nrow, ncol, 0.5 * ratio * ncol, drop)
 
     cen_fliplr = (ncol - 1.0) / 2.0
-    srad = max(min(abs(float(srad)), ncol / 4.0), 1.0)
-    step = max(min(abs(step), srad), 0.1)
-    init_cen = max(min(init_cen, ncol - srad - 1), srad)
-    list_cor = init_cen + cp.arange(-srad, srad + step, step, dtype=np.float32)
+    srad = np.clip(np.abs(srad), 1, ncol // 10 - 1)
+    step = np.clip(np.abs(step), 0.1, 1.1)
+    init_cen = np.clip(init_cen, srad, ncol - srad - 1)
+    list_cor = init_cen + cp.arange(-srad, srad + step, step, dtype=cp.float32)
     list_shift = 2.0 * (list_cor - cen_fliplr)
     list_metric = cp.empty(list_shift.shape, dtype="float32")
 
@@ -183,10 +225,10 @@ def _create_mask(nrow, ncol, radius, drop):
     block_x = 128
     block_y = 1
     block_dims = (block_x, block_y)
-    grid_x = (ncol // 2 + 1 + block_x - 1) // block_x
+    grid_x = (ncol + block_x - 1) // block_x
     grid_y = nrow
     grid_dims = (grid_x, grid_y)
-    mask = cp.empty((nrow, ncol // 2 + 1), dtype="uint16")
+    mask = cp.empty((nrow, ncol), dtype="float32")
     params = (
         ncol,
         nrow,
@@ -199,7 +241,7 @@ def _create_mask(nrow, ncol, radius, drop):
         mask,
     )
     module = load_cuda_module("generate_mask")
-    kernel = module.get_function("generate_mask")
+    kernel = module.get_function("generate_mask_full")
     kernel(grid_dims, block_dims, params)
     return mask
 
@@ -229,10 +271,10 @@ def _calculate_chunks(
 
     available_memory -= shift_size
     freq_domain_size = (
-        shift_size  # it needs only half (RFFT), but complex64, so it's the same
+        shift_size * 2  # it needs full (FFT), with complex64, so it's double
     )
     fft_plan_size = freq_domain_size
-    size_per_shift = 2 * (fft_plan_size + freq_domain_size + shift_size)
+    size_per_shift = 2.5 * (fft_plan_size + freq_domain_size + shift_size)
     nshift_max = available_memory // size_per_shift
     assert nshift_max > 0, "Not enough memory to process"
     num_chunks = int(np.ceil(nshifts / nshift_max))
@@ -243,28 +285,28 @@ def _calculate_chunks(
     return stop_idx
 
 
-def _calculate_metric(list_shift, sino1, sino2, sino3, mask, out):
+def _calculate_metric(list_shift, sino, flip_sino, comp_sino, mask, out):
     # this tries to simplify - if shift_col is integer, no need to spline interpolate
     assert list_shift.dtype == cp.float32, "shifts must be single precision floats"
-    assert sino1.dtype == cp.float32, "sino1 must be float32"
-    assert sino2.dtype == cp.float32, "sino1 must be float32"
-    assert sino3.dtype == cp.float32, "sino1 must be float32"
-    assert out.dtype == cp.float32, "sino1 must be float32"
-    assert sino2.flags["C_CONTIGUOUS"], "sino2 must be C-contiguous"
-    assert sino3.flags["C_CONTIGUOUS"], "sino3 must be C-contiguous"
+    assert sino.dtype == cp.float32, "sino must be float32"
+    assert flip_sino.dtype == cp.float32, "flip_sino must be float32"
+    assert comp_sino.dtype == cp.float32, "comp_sino must be float32"
+    assert out.dtype == cp.float32, "out must be float32"
+    assert flip_sino.flags["C_CONTIGUOUS"], "flip_sino must be C-contiguous"
+    assert comp_sino.flags["C_CONTIGUOUS"], "comp_sino must be C-contiguous"
     assert list_shift.flags["C_CONTIGUOUS"], "list_shift must be C-contiguous"
     nshifts = list_shift.shape[0]
-    na1 = sino1.shape[0]
-    na2 = sino2.shape[0]
+    na1 = sino.shape[0]
+    na2 = flip_sino.shape[0]
 
     module = load_cuda_module("center_360_shifts")
     shift_whole_shifts = module.get_function("shift_whole_shifts")
     # note: we don't have to calculate the mean here, as we're only looking for minimum metric.
     # The sum is enough.
     masked_sum_abs_kernel = cp.ReductionKernel(
-        in_params="complex64 x, uint16 mask",  # input, complex + mask
+        in_params="complex64 x, float32 mask",  # input, complex + mask
         out_params="float32 out",  # output, real
-        map_expr="mask ? abs(x) : 0.0f",
+        map_expr="abs(x) * mask",
         reduce_expr="a + b",
         post_map_expr="out = a",
         identity="0.0f",
@@ -275,13 +317,14 @@ def _calculate_metric(list_shift, sino1, sino2, sino3, mask, out):
     # determine how many shifts we can fit in the available memory
     # and iterate in chunks
     chunks = _calculate_chunks(
-        nshifts, (na1 + na2) * sino2.shape[1] * cp.float32().nbytes
+        nshifts, (na1 + na2) * flip_sino.shape[1] * cp.float32().nbytes
     )
 
-    mat = cp.empty((chunks[0], na1 + na2, sino2.shape[1]), dtype=cp.float32)
-    mat[:, :na1, :] = sino1
+    mat = cp.empty((chunks[0], na1 + na2, flip_sino.shape[1]), dtype=cp.float32)
+    mat[:, :na1, :] = sino
+
     # explicitly create FFT plan here, so it's not cached and clearly re-used
-    plan = get_fft_plan(mat, mat.shape[-2:], axes=(1, 2), value_type="R2C")
+    plan = get_fft_plan(mat, mat.shape[-2:], axes=(1, 2), value_type="C2C")
 
     for i, stop_idx in enumerate(chunks):
         if i > 0:
@@ -293,18 +336,18 @@ def _calculate_metric(list_shift, sino1, sino2, sino3, mask, out):
         size = stop_idx - start_idx
 
         # first, handle the integer shifts without spline in a raw kernel,
-        # and shift in the sino3 one accordingly
+        # and shift in the comp_sino one accordingly
         bx = 128
-        gx = (sino3.shape[1] + bx - 1) // bx
+        gx = (comp_sino.shape[1] + bx - 1) // bx
         shift_whole_shifts(
             grid=(gx, na2, size),  ####
             block=(bx, 1, 1),
             args=(
-                sino2,
-                sino3,
+                flip_sino,
+                comp_sino,
                 list_shift[start_idx:stop_idx],
                 mat[:, na1:, :],
-                sino3.shape[1],
+                comp_sino.shape[1],
                 na1 + na2,
             ),
         )
@@ -314,7 +357,7 @@ def _calculate_metric(list_shift, sino1, sino2, sino3, mask, out):
         for i in range(list_shift_host.shape[0]):
             shift_col = float(list_shift_host[i])
             if not shift_col.is_integer():
-                shifted = shift(sino2, (0, shift_col), order=3, prefilter=True)
+                shifted = shift(flip_sino, (0, shift_col), order=3, prefilter=True)
                 shift_int = round_up(shift_col)
                 if shift_int >= 0:
                     mat[i, na1:, shift_int:] = shifted[:, shift_int:]
@@ -324,38 +367,41 @@ def _calculate_metric(list_shift, sino1, sino2, sino3, mask, out):
         # stack and transform
         # (we do the full sized mat FFT, even though the last chunk may be smaller, to
         # make sure we can re-use the same FFT plan as before)
-        mat_freq = rfft2(mat, axes=(1, 2), norm=None, plan=plan)
+        mat_freq = fftshift(fft2(mat, axes=(1, 2), norm=None, plan=plan), axes=(1, 2))
+
         masked_sum_abs_kernel(
             mat_freq[:size, :, :], mask, out=out[start_idx:stop_idx], axis=(1, 2)
         )
 
 
-def _downsample(sino, level, axis):
-    assert sino.dtype == cp.float32, "single precision floating point input required"
-    assert sino.flags["C_CONTIGUOUS"], "list_shift must be C-contiguous"
+def _downsample(image, dsp_fact0, dsp_fact1):
+    """Downsample an image by averaging.
 
-    dx, dz = sino.shape
-    # Determine the new size, dim, of the downsampled dimension
-    dim = int(sino.shape[axis] / math.pow(2, level))
-    shape = [dx, dz]
-    shape[axis] = dim
-    downsampled_data = cp.empty(shape, dtype="float32")
+    Parameters
+    ----------
+        image : 2D array.
+        dsp_fact0 : downsampling factor along axis 0.
+        dsp_fact1 : downsampling factor along axis 1.
 
-    block_x = 8
-    block_y = 8
-    block_dims = (block_x, block_y)
-    grid_x = (sino.shape[1] + block_x - 1) // block_x
-    grid_y = (sino.shape[0] + block_y - 1) // block_y
-    grid_dims = (grid_x, grid_y)
-    # 8x8 thread-block, which means 16 "lots" of columns to downsample per
-    # thread-block; 4 bytes per float, so allocate 16*6 = 64 bytes of shared
-    # memeory per thread-block
-    shared_mem_bytes = 64
-    params = (sino, dx, dz, level, downsampled_data)
-    module = load_cuda_module("downsample_sino")
-    kernel = module.get_function("downsample_sino")
-    kernel(grid_dims, block_dims, params, shared_mem=shared_mem_bytes)
-    return downsampled_data
+    Returns
+    ---------
+        image_dsp : Downsampled image.
+    """
+    (height, width) = image.shape
+    dsp_fact0 = cp.clip(cp.int16(dsp_fact0), 1, height // 2)
+    dsp_fact1 = cp.clip(cp.int16(dsp_fact1), 1, width // 2)
+    height_dsp = height // dsp_fact0
+    width_dsp = width // dsp_fact1
+    if dsp_fact0 == 1 and dsp_fact1 == 1:
+        image_dsp = image
+    else:
+        image_dsp = image[0 : dsp_fact0 * height_dsp, 0 : dsp_fact1 * width_dsp]
+        image_dsp = (
+            image_dsp.reshape(height_dsp, dsp_fact0, width_dsp, dsp_fact1)
+            .mean(-1)
+            .mean(1)
+        )
+    return image_dsp
 
 
 ##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -688,22 +734,30 @@ def find_center_pc(
     proj2: cp.ndarray,
     tol: float = 0.5,
     rotc_guess: Union[float, Optional[str]] = None,
-) -> float:
-    """Find rotation axis location by finding the offset between the first
+) -> np.float32:
+    """
+    Find rotation axis location by finding the offset between the first
     projection and a mirrored projection 180 degrees apart using
     phase correlation in Fourier space.
     The `phase_cross_correlation` function uses cross-correlation in Fourier
     space, optionally employing an upsampled matrix-multiplication DFT to
     achieve arbitrary subpixel precision. See :cite:`guizar2008efficient`.
 
-    Args:
-        proj1 (cp.ndarray): Projection from the 0th degree angle.
-        proj2 (cp.ndarray): Projection from the 180th degree angle.
-        tol (float, optional): Subpixel accuracy. Defaults to 0.5.
-        rotc_guess (float, optional): Initial guess value for the rotation center. Defaults to None.
+    Parameters
+    ----------
+    proj1 : cp.ndarray
+        Projection from the 0th degree angle.
+    proj2 : cp.ndarray
+        Projection from the 180th degree angle.
+    tol : float, optional
+        Subpixel accuracy. Defaults to 0.5.
+    rotc_guess : float, optional
+        Initial guess value for the rotation center. Defaults to None.
 
-    Returns:
-        float: Rotation axis location.
+    Returns
+    ----------
+    np.float32
+        Rotation axis location.
     """
     imgshift = 0.0 if rotc_guess is None else rotc_guess - (proj1.shape[1] - 1.0) / 2.0
 
@@ -722,7 +776,7 @@ def find_center_pc(
     # registered translation with the second image
     center = (proj1.shape[1] + shiftr[0][1] - 1.0) / 2.0
 
-    return center + imgshift
+    return np.float32(center + imgshift)
 
 
 ##%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

{httomolibgpu-2.2 → httomolibgpu-2.3/httomolibgpu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: httomolibgpu
-Version: 2.2
+Version: 2.3
 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
@@ -12,12 +12,14 @@ Classifier: Environment :: GPU :: NVIDIA CUDA
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: cupy
+Requires-Dist: cupy==12.3.0
+Requires-Dist: nvtx
 Requires-Dist: numpy
 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"
@@ -43,10 +45,10 @@ Some of the methods also have been optimised to ensure higher computational effi
 The purpose of HTTomolibGPU
 ===========================
 
-**HTTomolibGPU** can be used as a stand-alone library, see Examples section in `Documentation <https://diamondlightsource.github.io/httomolibgpu/>`_.
-However, it has been specifically developed to work together with the `HTTomo <https://diamondlightsource.github.io/httomo/>`_ package as
+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.
+MPI protocols or as well serially.
 
 Install HTTomolibGPU as a PyPi package
 =========================================================

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu.egg-info/SOURCES.txt

@@ -12,13 +12,13 @@ httomolibgpu.egg-info/top_level.txt
 httomolibgpu/cuda_kernels/__init__.py
 httomolibgpu/cuda_kernels/calc_metrics.cu
 httomolibgpu/cuda_kernels/center_360_shifts.cu
-httomolibgpu/cuda_kernels/downsample_sino.cu
 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/misc/__init__.py
 httomolibgpu/misc/corr.py
+httomolibgpu/misc/denoise.py
 httomolibgpu/misc/morph.py
 httomolibgpu/misc/rescale.py
 httomolibgpu/prep/__init__.py

{httomolibgpu-2.2 → httomolibgpu-2.3}/httomolibgpu.egg-info/requires.txt

@@ -1,9 +1,11 @@
-cupy
+cupy==12.3.0
+nvtx
 numpy
 scipy
 pillow
 scikit-image
 tomobar
+ccpi-regularisation-cupy
 
 [dev]
 pytest

{httomolibgpu-2.2 → httomolibgpu-2.3}/pyproject.toml

@@ -37,12 +37,14 @@ classifiers = [
 requires-python = ">=3.10"
 dynamic = ["version"]
 dependencies = [
-    "cupy",
+    "cupy==12.3.0",
+    "nvtx",
     "numpy",
     "scipy",
     "pillow",
     "scikit-image",
-    "tomobar"
+    "tomobar",
+    "ccpi-regularisation-cupy"
 ]
 
 [project.optional-dependencies]

httomolibgpu-2.2/httomolibgpu/cuda_kernels/downsample_sino.cu

@@ -1,36 +0,0 @@
-extern "C" __global__ void downsample_sino(float *sino, int dx, int dz,
-                                           int level, float *out) {
-  // use shared memory to store the values used to "merge" columns of the
-  // sinogram in the downsampling process
-  extern __shared__ float downsampled_vals[];
-  unsigned int binsize, i, j, k, orig_ind, out_ind, output_bin_no;
-  i = blockDim.x * blockIdx.x + threadIdx.x;
-  j = 0;
-  k = blockDim.y * blockIdx.y + threadIdx.y;
-  orig_ind = (k * dz) + i;
-  binsize = 1 << level;
-  unsigned int dz_downsampled =
-      __float2uint_rd(fdividef(__uint2float_rd(dz), __uint2float_rd(binsize)));
-  unsigned int i_downsampled =
-      __float2uint_rd(fdividef(__uint2float_rd(i), __uint2float_rd(binsize)));
-  if (orig_ind < dx * dz) {
-    output_bin_no =
-        __float2uint_rd(fdividef(__uint2float_rd(i), __uint2float_rd(binsize)));
-    out_ind = (k * dz_downsampled) + i_downsampled;
-    downsampled_vals[threadIdx.y * 8 + threadIdx.x] =
-        sino[orig_ind] / __uint2float_rd(binsize);
-    // synchronise threads within thread-block so that it's guaranteed
-    // that all the required values have been copied into shared memeory
-    // to then sum and save in the downsampled output
-    __syncthreads();
-    // arbitrarily use the "beginning thread" in each "lot" of pixels
-    // for downsampling to then save the desired value in the
-    // downsampled output array
-    if (i % 4 == 0) {
-      out[out_ind] = downsampled_vals[threadIdx.y * 8 + threadIdx.x] +
-                     downsampled_vals[threadIdx.y * 8 + threadIdx.x + 1] +
-                     downsampled_vals[threadIdx.y * 8 + threadIdx.x + 2] +
-                     downsampled_vals[threadIdx.y * 8 + threadIdx.x + 3];
-    }
-  }
-}

httomolibgpu-2.2/httomolibgpu/cuda_kernels/generate_mask.cu

@@ -1,51 +0,0 @@
-extern "C" __global__ void generate_mask(const int ncol, const int nrow,
-                                         const int cen_col, const int cen_row,
-                                         const float du, const float dv,
-                                         const float radius, const float drop,
-                                         unsigned short *mask) {
-  int i = blockDim.x * blockIdx.x + threadIdx.x;
-  int j = blockIdx.y;
-
-  if (i >= ncol/2+1)
-    return;
-
-  // we only need to look at the right half as we're using a real2complex FFT
-  int outi = i;
-  i += ncol/2-1;
-
-  int pos = __float2int_ru(((j - cen_row) * dv / radius) / du);
-  int pos1 = -pos + cen_col;
-  int pos2 = pos + cen_col;
-
-  if (pos1 > pos2) {
-    int temp = pos1;
-    pos1 = pos2;
-    pos2 = temp;
-    if (pos1 >= ncol) {
-      pos1 = ncol - 1;
-    }
-    if (pos2 < 0) {
-      pos2 = 0;
-    }
-  } else {
-    if (pos1 < 0) {
-      pos1 = 0;
-    }
-    if (pos2 >= ncol) {
-      pos2 = ncol - 1;
-    }
-  }
-
-  short outval = (pos1 <= i && i <= pos2) ? 1 : 0;
-
-  // mask[cen_row - drop: cen_row + drop + 1, :] = 0
-  if (j >= cen_row - drop && j <= cen_row + drop) {
-    outval = 0;
-  }
-  // mask[:, cen_col - 1: cen_col + 2] = 0
-  if (i >= cen_col - 1 && i <= cen_col + 1) {
-    outval = 0;
-  }
-
-  mask[j * (ncol/2+1) + outi] = outval;
-}