basic tests fixed

Author: dkazanc

tests/test_prep/stripe_cpu_reference.py

@@ -74,7 +74,7 @@ def test_dark_flat_field_performance(ensure_clean_memory):
 
     # run code and time it
     # do a cold run for warmup
-    dark_flat_field(
+    dark_flat_field_correction(
         cp.copy(data),
         flats,
         darks,
@@ -85,7 +85,7 @@ def test_dark_flat_field_performance(ensure_clean_memory):
     start = time.perf_counter_ns()
     nvtx.RangePush("Core")
     for _ in range(10):
-        normalize(
+        dark_flat_field_correction(
             cp.copy(data),
             flats,
             darks,

tests/test_prep/test_normalize.py

@@ -12,7 +12,6 @@
     raven_filter,
 )
 from numpy.testing import assert_allclose
-from .stripe_cpu_reference import raven_filter_numpy
 
 
 def test_remove_stripe_ti_on_data(data, flats, darks):
@@ -62,45 +61,17 @@ def test_stripe_removal_sorting_cupy(data, flats, darks):
 
 
 def test_stripe_raven_cupy(data, flats, darks):
-    # --- testing the CuPy port of TomoPy's implementation ---#
-
-    data = normalize(data, flats, darks, cutoff=10, minus_log=True)
-
-    data_after_raven_gpu = raven_filter(cp.copy(data)).get()
-    data_after_raven_cpu = raven_filter_numpy(cp.copy(data).get())
-
-    assert_allclose(data_after_raven_cpu, data_after_raven_gpu, rtol=0, atol=4e-01)
+    data_norm = dark_flat_field_correction(cp.copy(data), flats, darks, cutoff=10)
+    data_norm = minus_log(data_norm)
 
+    data_after_raven_gpu = cp.asnumpy(raven_filter(data_norm))
+    
     data = None  #: free up GPU memory
+    assert_allclose(np.mean(data_after_raven_gpu), 0.2892464, rtol=1e-06)
+
     # make sure the output is float32
     assert data_after_raven_gpu.dtype == np.float32
-    assert data_after_raven_gpu.shape == data_after_raven_cpu.shape
-
-
-@pytest.mark.parametrize("uvalue", [20, 50, 100])
-@pytest.mark.parametrize("nvalue", [2, 4, 6])
-@pytest.mark.parametrize("vvalue", [2, 4])
-@pytest.mark.parametrize("pad_x", [0, 10, 20])
-@pytest.mark.parametrize("pad_y", [0, 10, 20])
-@cp.testing.numpy_cupy_allclose(rtol=0, atol=3e-01)
-def test_stripe_raven_parameters_cupy(
-    ensure_clean_memory, xp, uvalue, nvalue, vvalue, pad_x, pad_y
-):
-    # because it's random, we explicitly seed and use numpy only, to match the data
-    np.random.seed(12345)
-    data = np.random.random_sample(size=(256, 5, 512)).astype(np.float32) * 2.0 + 0.001
-    data = xp.asarray(data)
-
-    if xp.__name__ == "numpy":
-        results = raven_filter_numpy(
-            data, uvalue=uvalue, nvalue=nvalue, vvalue=vvalue, pad_x=pad_x, pad_y=pad_y
-        ).astype(np.float32)
-    else:
-        results = raven_filter(
-            data, uvalue=uvalue, nvalue=nvalue, vvalue=vvalue, pad_x=pad_x, pad_y=pad_y
-        ).get()
-
-    return xp.asarray(results)
+    assert data_after_raven_gpu.shape == (180, 128, 160)
 
 
 @pytest.mark.perf
@@ -180,9 +151,11 @@ def test_raven_filter_performance(ensure_clean_memory):
 
 def test_remove_all_stripe_on_data(data, flats, darks):
     # --- testing the CuPy implementation from TomoCupy ---#
-    data = normalize(data, flats, darks, cutoff=10, minus_log=True)
+    data_norm = dark_flat_field_correction(cp.copy(data), flats, darks, cutoff=10)
+    data_norm = minus_log(data_norm)
+
 
-    data_after_stripe_removal = remove_all_stripe(cp.copy(data)).get()
+    data_after_stripe_removal = cp.asnumpy(remove_all_stripe(data_norm))
 
     assert_allclose(np.mean(data_after_stripe_removal), 0.266914, rtol=1e-05)
     assert_allclose(

tests/test_prep/test_stripe.py

@@ -92,11 +92,11 @@ def test_reconstruct_FBP3d_tomobar_2(data, flats, darks, ensure_clean_memory):
     )
 
     recon_data = recon_data.get()
-    assert_allclose(np.mean(recon_data), -0.00015, rtol=1e-07, atol=1e-6)
+    assert_allclose(np.mean(recon_data), 0.000265, rtol=1e-07, atol=1e-6)
     assert_allclose(
-        np.mean(recon_data, axis=(0, 2)).sum(), -0.019142, rtol=1e-06, atol=1e-5
+        np.mean(recon_data, axis=(0, 2)).sum(), 0.03396, rtol=1e-06, atol=1e-5
     )
-    assert_allclose(np.std(recon_data), 0.003561, rtol=1e-07, atol=1e-6)
+    assert_allclose(np.std(recon_data), 0.006599, rtol=1e-07, atol=1e-6)
     assert recon_data.dtype == np.float32
 
 
@@ -114,9 +114,9 @@ def test_reconstruct_FBP3d_tomobar_3_detpad_true(data, flats, darks, ensure_clea
     )
 
     recon_data = recon_data.get()
-    assert_allclose(np.mean(recon_data), -0.00041842036, atol=1e-6)
+    assert_allclose(np.mean(recon_data), 0.000692, atol=1e-6)
     assert_allclose(
-        np.mean(recon_data, axis=(0, 2)).sum(), -0.05355779, rtol=1e-06, atol=1e-5
+        np.mean(recon_data, axis=(0, 2)).sum(), 0.088599, rtol=1e-06, atol=1e-5
     )
     assert recon_data.dtype == np.float32
     assert recon_data.shape == (210, 128, 210)

tests/test_recon/test_algorithm.py

@@ -1,13 +1,11 @@
-import math
-import random
 import time
 from unittest import mock
 import cupy as cp
 from cupy.cuda import nvtx
 from cupyx.scipy.ndimage import shift
 import numpy as np
 import pytest
-from httomolibgpu.prep.normalize import normalize
+from httomolibgpu.prep.normalize import dark_flat_field_correction, minus_log
 from httomolibgpu.recon.rotation import (
     _calculate_chunks,
     find_center_360,
@@ -18,11 +16,11 @@
 
 
 def test_find_center_vo(data, flats, darks):
-    data = normalize(data, flats, darks)
+    data_normalize = dark_flat_field_correction(cp.copy(data), flats, darks)
 
     # --- testing the center of rotation on tomo_standard ---#
     cor = find_center_vo(
-        data.copy(),
+        data_normalize,
         average_radius=0,
     )
 
@@ -147,20 +145,10 @@ def test_find_center_360_performance(ensure_clean_memory):
     assert "performance in ms" == duration_ms
 
 
-def test_find_center_pc(data, flats, darks, ensure_clean_memory):
-    data = normalize(data, flats, darks)[:, :, 3]
-    shifted_data = shift(cp.fliplr(data), (0, 18.75), mode="reflect")
-
-    # --- testing the center of rotation on tomo_standard ---#
-    cor = find_center_pc(data, shifted_data)
-
-    assert_allclose(cor, 73.0, rtol=1e-7)
-
-
-def test_find_center_pc2(data, flats, darks, ensure_clean_memory):
-    data = normalize(data, flats, darks)
-    proj1 = data[0, :, :]
-    proj2 = data[179, :, :]
+def test_find_center_pc(data, flats, darks, ensure_clean_memory):    
+    data_normalize = dark_flat_field_correction(cp.copy(data), flats, darks)
+    proj1 = data_normalize[0, :, :]
+    proj2 = data_normalize[179, :, :]
 
     # --- testing the center of rotation on tomo_standard ---#
     cor = find_center_pc(proj1, proj2)