nabu 2024.1.7__tar.gz → 2024.1.8.post1__tar.gz

{nabu-2024.1.7/nabu.egg-info → nabu-2024.1.8.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.1.7
+Version: 2024.1.8.post1
 Summary: Nabu - Tomography software
 Author-email: Pierre Paleo <pierre.paleo@esrf.fr>, Henri Payno <henri.payno@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 Maintainer-email: Pierre Paleo <pierre.paleo@esrf.fr>

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.1.7"
+__version__ = "2024.1.8.post1"
 __nabu_modules__ = [
     "app",
     "cuda",

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu/pipeline/fullfield/chunked.py

@@ -575,10 +575,11 @@ class ChunkedPipeline:
                 (self.radios_shape[1],) + self.sino_shape,
                 source_sample_dist,
                 sample_detector_dist,
-                angles=options["angles"],
-                # TODO one center for each angle to handle "x translations"
+                angles=-options["angles"],
                 rot_center=options["rotation_axis_position"],
+                axis_correction=(-options["axis_correction"] if options["axis_correction"] is not None else None),
                 pixel_size=1,
+                scale_factor=1.0 / options["voxel_size_cm"][0],
             )
 
         self._allocate_recs(*self.process_config.rec_shape, n_slices=n_slices)
@@ -732,12 +733,16 @@ class ChunkedPipeline:
         """
 
         n_angles, n_z, n_x = self.radios.shape
+
+        # FIXME
         # can't do a discontiguous single copy...
         sinos_contig = self._allocate_array((n_z, n_angles, n_x), np.float32, "sinos_cone")
         for i in range(n_z):
             sinos_contig[i] = self.radios[:, i, :]
-        #
+        # ---
 
+        # In principle radios are not cropped at this stage,
+        # so self.sub_region[2][0] can be used instead of self.get_slice_start_index() instead of self.sub_region[2][0]
         z_min, z_max = self.sub_region_xz[2:]
         n_z_tot = self.process_config.radio_shape(binning=True)[0]
 

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu/pipeline/fullfield/processconfig.py

@@ -517,10 +517,15 @@ class ProcessConfig(ProcessConfigBase):
         #
         # Translation movements
         #
+
         translations = dataset_info.translations
         if translations is not None:
-            tasks.append("radios_movements")
-            options["radios_movements"] = {"translation_movements": dataset_info.translations}
+            if np.max(np.abs(translations[:, 1])) < 1e-5:
+                self.logger.warning("No vertical translation greater than 1e-5 - disabling vertical shifts")
+                # horizontal movements are handled in backprojector
+            else:
+                tasks.append("radios_movements")
+                options["radios_movements"] = {"translation_movements": dataset_info.translations}
         #
         # Sinogram normalization (before half-tomo)
         #

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu/pipeline/fullfield/reconstruction.py

@@ -359,6 +359,16 @@ class FullFieldReconstructor:
 
         return (max_overlap, 0)
 
+    def _compute_rotation_margin(self):
+        if "rotate_projections" in self.process_config.processing_steps:
+            # Partial radios rotation yields too much error in single-slice mode
+            # Forcing a big margin circumvents the problem
+            # This is likely to trigger the 'grouped mode', but perhaps grouped mode should always be used when rotating radios
+            nz, nx = self.process_config.radio_shape(binning=True)
+            return nz // 3, nx // 3
+        else:
+            return 0, 0
+
     def _ensure_good_chunk_size_and_margin(self):
         """
         Check that "chunk_size" and "margin" (if any) are a multiple of binning factor.

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu/reconstruction/cone.py

@@ -23,7 +23,9 @@ class ConebeamReconstructor:
         volume_shape=None,
         rot_center=None,
         relative_z_position=None,
+        axis_correction=None,
         pixel_size=None,
+        scale_factor=None,
         cuda_options=None,
     ):
         """
@@ -88,6 +90,7 @@ class ConebeamReconstructor:
         Optics Express. 24. 25129-25147. 10.1364/OE.24.025129.
         """
         self._init_cuda(cuda_options)
+        self.scale_factor = scale_factor
         self._init_geometry(
             sinos_shape,
             source_origin_dist,
@@ -97,6 +100,7 @@ class ConebeamReconstructor:
             volume_shape,
             rot_center,
             relative_z_position,
+            axis_correction,
         )
         self._alg_id = None
         self._vol_id = None
@@ -133,6 +137,7 @@ class ConebeamReconstructor:
         volume_shape,
         rot_center,
         relative_z_position,
+        axis_correction,
     ):
         self._set_sino_shape(sinos_shape)
         if angles is None:
@@ -153,6 +158,7 @@ class ConebeamReconstructor:
         if rot_center is not None:
             self._cor_shift = (self.prj_width - 1) / 2.0 - rot_center
         self._set_pixel_size(pixel_size)
+        self._axis_corrections = axis_correction
         self._create_astra_proj_geometry(relative_z_position)
 
     def _create_astra_proj_geometry(self, relative_z_position):
@@ -170,13 +176,26 @@ class ConebeamReconstructor:
             self.origin_detector_dist,
         )
         self.relative_z_position = relative_z_position or 0.0
+        # This will turn the geometry of type "cone" into a geometry of type "cone_vec"
         self.proj_geom = astra.geom_postalignment(self.proj_geom, (self._cor_shift, 0))
+        # (src, detector_center, u, v) = (srcX, srcY, srcZ, dX, dY, dZ, uX, uY, uZ, vX, vY, vZ)
+        vecs = self.proj_geom["Vectors"]
+
+        # To adapt the center of rotation:
+        # dX = cor_shift * cos(theta) - origin_detector_dist * sin(theta)
+        # dY = origin_detector_dist * cos(theta) + cor_shift * sin(theta)
+        if self._axis_corrections is not None:
+            # should we check that dX and dY match the above formulas ?
+            cor_shifts = self._cor_shift + self._axis_corrections
+            vecs[:, 3] = cor_shifts * np.cos(self.angles) - self.origin_detector_dist * np.sin(self.angles)
+            vecs[:, 4] = self.origin_detector_dist * np.cos(self.angles) + cor_shifts * np.sin(self.angles)
+
+        # To adapt the z position:
         # Component 2 of vecs is the z coordinate of the source, component 5 is the z component of the detector position
         # We need to re-create the same inclination of the cone beam, thus we need to keep the inclination of the two z positions.
         # The detector is centered on the rotation axis, thus moving it up or down, just moves it out of the reconstruction volume.
         # We can bring back the detector in the correct volume position, by applying a rigid translation of both the detector and the source.
         # The translation is exactly the amount that brought the detector up or down, but in the opposite direction.
-        vecs = self.proj_geom["Vectors"]
         vecs[:, 2] = -self.relative_z_position
 
     def _set_output(self, volume):
@@ -229,6 +248,8 @@ class ConebeamReconstructor:
         result = self.cuda.get_array("output")
         if output is None:
             result = result.get()
+        if self.scale_factor is not None:
+            result *= np.float32(self.scale_factor)  # in-place for pycuda
         self.cuda.recover_arrays_references(["sinos", "output"])
         return result
 

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu/reconstruction/tests/test_cone.py

@@ -1,7 +1,7 @@
 import pytest
 import numpy as np
-from scipy.ndimage import gaussian_filter
-from nabu.utils import subdivide_into_overlapping_segment
+from scipy.ndimage import gaussian_filter, shift
+from nabu.utils import subdivide_into_overlapping_segment, clip_circle
 
 try:
     import astra
@@ -238,6 +238,65 @@ class TestCone:
         assert np.max(err_max_profile) < 2e-3
         assert np.max(err_median_profile) < 5e-6
 
+    def test_reconstruction_horizontal_translations(self):
+        n_z = n_y = n_x = 256
+        n_a = 500
+        src_orig_dist = 1000
+        orig_det_dist = 50
+
+        volume, cone_data = generate_hollow_cube_cone_sinograms(
+            vol_shape=(n_z, n_y, n_x),
+            n_angles=n_a,
+            src_orig_dist=src_orig_dist,
+            orig_det_dist=orig_det_dist,
+            apply_filter=False,
+        )
+
+        # Apply horizontal translations on projections. This could have been done directly with astra
+        shift_min, shift_max = -2, 5
+        shifts_float = (shift_max - shift_min) * np.random.rand(n_a) - shift_min
+        shifts_int = np.random.randint(shift_min, high=shift_max + 1, size=n_a)
+
+        reconstructor_args = [
+            cone_data.shape,
+            src_orig_dist,
+            orig_det_dist,
+        ]
+        reconstructor_kwargs = {
+            "volume_shape": volume.shape,
+            "cuda_options": {"ctx": self.ctx},
+        }
+        cone_reconstructor = ConebeamReconstructor(*reconstructor_args, **reconstructor_kwargs)
+        rec = cone_reconstructor.reconstruct(cone_data)
+
+        # Translations done with floating-point shift values give a blurring of the image that cannot be recovered.
+        # Error tolerance has to be higher for these shifts.
+        for shift_type, shifts, err_tol in [
+            ("integer shifts", shifts_int, 5e-3),
+            ("float shifts", shifts_float, 1.4e-1),
+        ]:
+            cone_data_shifted = np.zeros_like(cone_data)
+            [shift(cone_data[:, i, :], (0, shifts[i]), output=cone_data_shifted[:, i, :]) for i in range(n_a)]
+
+            # Reconstruct with horizontal shifts
+            cone_reconstructor_with_correction = ConebeamReconstructor(
+                *reconstructor_args,
+                axis_correction=shifts,
+                **reconstructor_kwargs,
+            )
+
+            rec_with_correction = cone_reconstructor_with_correction.reconstruct(cone_data_shifted)
+
+            metric = lambda img: np.max(np.abs(clip_circle(img, radius=int(0.85 * img.shape[1] // 2))))
+            error_profile = np.array([metric(rec[i] - rec_with_correction[i]) for i in range(n_z)])
+            assert error_profile.max() < err_tol, "Max error with %s is too high" % shift_type
+
+            # import matplotlib.pyplot as plt
+            # plt.figure()
+            # plt.plot(np.arange(n_z), error_profile)
+            # plt.legend([shift_type])
+            # plt.show()
+
 
 def generate_hollow_cube_cone_sinograms(
     vol_shape, n_angles, src_orig_dist, orig_det_dist, prj_width=None, apply_filter=True

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu/stitching/overlap.py

@@ -301,7 +301,7 @@ def check_overlaps(frames: Union[tuple, numpy.ndarray], positions: tuple, axis:
         if raise_error:
             raise ValueError(error_msg)
         else:
-            _logger.error(raise_error)
+            _logger.error(error_msg)
 
     # convert each frame to appropriate bounding box according to the axis
     def convert_to_bb(frame: numpy.ndarray, position: tuple, axis: int):

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu/stitching/tests/test_z_stitching.py

@@ -695,11 +695,6 @@ def test_DistributePostProcessZStitcher(tmp_path, configuration_dist, flip_ud):
     if complete:
         concatenate_volumes(output_volume=final_vol, volumes=tuple(reconstructed_sub_volumes), axis=1)
         final_vol.load_data(store=True)
-        with h5py.File("debug.hdf5", mode="w") as h5f:
-            h5f["raw_volume"] = raw_volume
-            h5f["final_vol"] = final_vol.data
-            h5f["volume1"] = volume_1.data
-            h5f["volume2"] = volume_2.data
         numpy.testing.assert_almost_equal(
             raw_volume,
             final_vol.data,
@@ -925,14 +920,6 @@ def test_vol_z_stitching_with_alignment_axis_2(tmp_path, alignment_axis_2):
 
     assert output_volume.data.shape == (120, 4, 120)
 
-    import h5py
-
-    with h5py.File("input.h5", mode="w") as h5f:
-        h5f["data"] = raw_volume
-
-    with h5py.File("output.h5", mode="w") as h5f:
-        h5f["data"] = output_volume.data
-
     if alignment_axis_2 == "center":
         numpy.testing.assert_array_almost_equal(raw_volume[:, :, 10:-10], output_volume.data[:, :, 10:-10])
     elif alignment_axis_2 == "left":

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu/stitching/z_stitching.py

@@ -1975,7 +1975,7 @@ def stitch_vertically_raw_frames(
       |    |  Frame 2   |                         --------------
       |    |            |
       |    --------------
-      \/
+      |
 
     returns stitched_projection, raw_img_1, raw_img_2, computed_overlap
     proj_0 and pro_1 are already expected to be in a row. Having stitching_height_in_px in common. At top of proj_0

{nabu-2024.1.7 → nabu-2024.1.8.post1/nabu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.1.7
+Version: 2024.1.8.post1
 Summary: Nabu - Tomography software
 Author-email: Pierre Paleo <pierre.paleo@esrf.fr>, Henri Payno <henri.payno@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 Maintainer-email: Pierre Paleo <pierre.paleo@esrf.fr>

{nabu-2024.1.7 → nabu-2024.1.8.post1}/nabu.egg-info/requires.txt

@@ -1,4 +1,4 @@
-numpy>1.9.0
+numpy<2,>1.9.0
 scipy
 h5py>=3.0
 silx>=0.15.0
@@ -17,7 +17,7 @@ nbsphinx
 scikit-image
 PyWavelets
 glymur
-pycuda
+pycuda<2024.1.1
 scikit-cuda
 pycudwt
 sluurp>=0.3

{nabu-2024.1.7 → nabu-2024.1.8.post1}/pyproject.toml

@@ -49,7 +49,7 @@ classifiers = [
 
 ]
 dependencies = [
-    "numpy > 1.9.0",
+    "numpy > 1.9.0, < 2",
     "scipy",
     "h5py>=3.0",
     "silx >= 0.15.0",
@@ -73,7 +73,7 @@ full = [
     "scikit-image",
     "PyWavelets",
     "glymur",
-    "pycuda",
+    "pycuda<2024.1.1",
     "scikit-cuda",
     "pycudwt",
     "sluurp >=0.3",