various changes to 360 centering and morphing 360 to 180 methods

Author: dkazanc

httomolibgpu/misc/morph.py

@@ -44,7 +44,7 @@
 
 
 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.
@@ -55,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
@@ -74,26 +74,28 @@ def sino_360_to_180(
 
     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]
         out[:, :, dz - overlap : dz] = (
             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]

httomolibgpu/recon/rotation.py

@@ -416,27 +416,26 @@ 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.
     ind : int, optional
         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
@@ -451,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.
@@ -475,8 +474,9 @@ 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
+    if side == "left":
+        # cor = overlap / 2.0 - 1.0
+        cor = ncol // 2  # NOTE: major correction to check!
     else:
         cor = ncol - overlap / 2.0 - 1.0
 
@@ -498,10 +498,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
@@ -514,8 +513,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.
@@ -525,25 +524,25 @@ 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,
         )
         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,
@@ -556,7 +555,7 @@ def _find_overlap(
             mat1,
             mat2,
             win_width,
-            side=1,
+            side=1,  # right side
             denoise=denoise,
             norm=norm,
             use_overlap=use_overlap,
@@ -565,7 +564,7 @@ def _find_overlap(
             mat1,
             mat2,
             win_width,
-            side=0,
+            side=0,  # left side
             denoise=denoise,
             norm=norm,
             use_overlap=use_overlap,
@@ -577,11 +576,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
 

tests/test_recon/test_rotation.py

@@ -126,7 +126,7 @@ def test_find_center_360_NaN_infs_raises(data, flats, darks):
 @pytest.mark.parametrize("norm", [False, True], ids=["no_normalise", "normalise"])
 @pytest.mark.parametrize("overlap", [False, True], ids=["no_overlap", "overlap"])
 @pytest.mark.parametrize("denoise", [False, True], ids=["no_denoise", "denoise"])
-@pytest.mark.parametrize("side", [1, 0])
+@pytest.mark.parametrize("side", ["right", "left"])
 @cp.testing.numpy_cupy_allclose(rtol=1e-5, atol=1e-6)
 def test_find_center_360_unity(ensure_clean_memory, xp, norm, overlap, denoise, side):
     # because it's random, we explicitly seed and use numpy only, to match the data

zenodo-tests/test_misc/test_morph.py

@@ -20,7 +20,7 @@ def test_sino_360_to_180_i13_dataset1(i13_dataset1):
     force_clean_gpu_memory()
 
     stiched_data_180degrees = sino_360_to_180(
-        data_normalised, overlap=473.822265625, rotation="right"
+        data_normalised, overlap=473.822265625, side="right"
     )
     stiched_data_180degrees = stiched_data_180degrees.get()
 
@@ -41,7 +41,7 @@ def test_sino_360_to_180_i13_dataset3(i13_dataset3):
     force_clean_gpu_memory()
 
     stiched_data_180degrees = sino_360_to_180(
-        data_normalised, overlap=438.173828, rotation="left"
+        data_normalised, overlap=438.173828, side="left"
     )
     stiched_data_180degrees = stiched_data_180degrees.get()
 

zenodo-tests/test_recon/test_algorithm.py

@@ -1,4 +1,3 @@
-
 import cupy as cp
 import numpy as np
 import pytest
@@ -114,7 +113,7 @@ def test_reconstruct_LPRec_tomobar_i13_dataset1(i13_dataset1):
     force_clean_gpu_memory()
 
     stiched_data_180degrees = sino_360_to_180(
-        data_normalised[:, 2:3, :], overlap=473.822265625, rotation="right"
+        data_normalised[:, 2:3, :], overlap=473.822265625, side="right"
     )
     del data_normalised
     force_clean_gpu_memory()
@@ -208,7 +207,7 @@ def test_reconstruct_LPRec3d_tomobar_i13_dataset2(i13_dataset2):
 
     assert isclose(np.sum(recon_data), 4095.6257, abs_tol=10**-3)
     assert pytest.approx(np.max(recon_data), rel=1e-3) == 0.0105672
-    assert pytest.approx(np.min(recon_data), rel=1e-3) == -0.00839    
+    assert pytest.approx(np.min(recon_data), rel=1e-3) == -0.00839
     assert recon_data.dtype == np.float32
     assert recon_data.shape == (2560, 10, 2560)
 
@@ -262,7 +261,7 @@ def test_reconstruct_FBP3d_tomobar_i13_dataset3(i13_dataset3):
     force_clean_gpu_memory()
 
     stiched_data_180degrees = sino_360_to_180(
-        data_normalised, overlap=438.173828, rotation="left"
+        data_normalised, overlap=438.173828, side="left"
     )
     force_clean_gpu_memory()
 
@@ -278,5 +277,6 @@ def test_reconstruct_FBP3d_tomobar_i13_dataset3(i13_dataset3):
 
     assert recon_data.flags.c_contiguous
     recon_data = recon_data.get()
+
     assert recon_data.dtype == np.float32
     assert recon_data.shape == (4682, 3, 4682)

zenodo-tests/test_recon/test_rotation.py

@@ -140,6 +140,7 @@ def test_center_360_i13_dataset1(i13_dataset1, ensure_clean_memory):
     cor, overlap, side, overlap_position = find_center_360(data_normalised)
 
     assert int(cor) == 2322
+    assert side == "right"
     assert int(overlap) == 473  # actual 473.822265625
     assert cor.dtype == np.float64
 
@@ -183,13 +184,14 @@ def test_center_360_i13_dataset3(i13_dataset3, ensure_clean_memory):
         data_normalised,
         ind=1,
         win_width=50,
-        side=0,
+        side="left",
         denoise=True,
         norm=True,
         use_overlap=True,
     )
 
     assert int(cor) == 218  # actual 218.08 (not correct CoR actually, should be 2341)
+    assert side == "left"
     assert int(overlap) == 438  # actual 438.173828
     assert cor.dtype == np.float64