nabu 2024.1.6__tar.gz → 2024.1.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.1.6
+Version: 2024.1.8
 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>
@@ -48,9 +48,29 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2,>1.9.0
+Requires-Dist: scipy
+Requires-Dist: h5py>=3.0
+Requires-Dist: silx>=0.15.0
+Requires-Dist: tomoscan>=2.0.4
+Requires-Dist: psutil
+Requires-Dist: pytest
+Requires-Dist: tifffile
 Provides-Extra: full
+Requires-Dist: scikit-image; extra == "full"
+Requires-Dist: PyWavelets; extra == "full"
+Requires-Dist: glymur; extra == "full"
+Requires-Dist: pycuda<2024.1.1; extra == "full"
+Requires-Dist: scikit-cuda; extra == "full"
+Requires-Dist: pycudwt; extra == "full"
+Requires-Dist: sluurp>=0.3; extra == "full"
+Requires-Dist: pyvkfft; extra == "full"
 Provides-Extra: doc
-License-File: LICENSE
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: cloud_sptheme; extra == "doc"
+Requires-Dist: myst-parser; extra == "doc"
+Requires-Dist: nbsphinx; extra == "doc"
 
 # Nabu
 

nabu-2024.1.8/doc/doc_config.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+from nabu.resources.nabu_config import nabu_config
+
+
+def generate(file_):
+    def write(content):
+        print(content, file=file_)
+    for section, values in nabu_config.items():
+        if section == "about":
+            continue
+        write("## %s\n" % section)
+        for key, val in values.items():
+            if val["type"] == "unsupported":
+                continue
+            write(val["help"] + "\n")
+            write(
+                "```ini\n%s = %s\n```"
+                % (key, val["default"])
+            )
+
+
+
+if __name__ == "__main__":
+
+    import sys, os
+    print(os.path.abspath(__file__))
+    exit(0)
+
+    fname = "/tmp/test.md"
+    with open(fname, "w") as f:
+        generate(f)

{nabu-2024.1.6 → nabu-2024.1.8}/nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.1.6"
+__version__ = "2024.1.8"
 __nabu_modules__ = [
     "app",
     "cuda",

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

@@ -548,7 +548,6 @@ class ChunkedPipeline:
 
         if options["method"] == "FBP":
             n_slices = self.n_slices
-            radios_shape_for_sino_builder = self.radios_cropped_shape
             self.reconstruction = self.FBPClass(
                 self.sinos_shape[1:],
                 angles=options["angles"],
@@ -567,7 +566,6 @@ class ChunkedPipeline:
             )
 
         if options["method"] == "cone":
-            radios_shape_for_sino_builder = self.radios_shape
             n_slices = self.n_slices + sum(self.margin[0])
             # For numerical stability, normalize all lengths with respect to detector pixel size
             pixel_size_m = self.dataset_info.pixel_size * 1e-6
@@ -577,17 +575,16 @@ 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"],
                 pixel_size=1,
+                scale_factor=1.0 / options["voxel_size_cm"][0],
             )
 
         self._allocate_recs(*self.process_config.rec_shape, n_slices=n_slices)
         n_a, _, n_x = self.radios_cropped_shape
         self._tmp_sino = self._allocate_array((n_a, n_x), "f", name="tmp_sino")
-        if options["method"] == "cone":
-            self.sinos = self._allocate_array(self.sino_builder.output_shape, "f", name="sinos")
 
     @use_options("histogram", "histogram")
     def _init_histogram(self):
@@ -734,14 +731,25 @@ class ChunkedPipeline:
         """
         This reconstructs the entire sinograms stack at once
         """
-        self.sino_builder.get_sinos(self.radios, output=self.sinos)
+
+        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 = self.process_config.radio_shape(binning=True)[0]
+        n_z_tot = self.process_config.radio_shape(binning=True)[0]
 
         self.reconstruction.reconstruct(  # pylint: disable=E1101
-            self.sinos,
+            sinos_contig,
             output=self.recs,
-            relative_z_position=((z_min + z_max) / self.process_config.binning_z / 2) - n_z / 2,
+            relative_z_position=((z_min + z_max) / self.process_config.binning_z / 2) - n_z_tot / 2,
         )
 
     @pipeline_step("histogram", "Computing histogram")

{nabu-2024.1.6 → nabu-2024.1.8}/nabu/pipeline/fullfield/dataset_validator.py

@@ -29,7 +29,7 @@ class FullFieldDatasetValidator(DatasetValidatorBase):
     def _check_slice_indices(self):
         nx, nz = self.dataset_info.radio_dims
         rec_params = self.rec_params
-        if rec_params["enable_halftomo"]:
+        if self.is_halftomo:
             ny, nx = self._get_nx_ny()
         what = (("start_x", "end_x", nx), ("start_y", "end_y", nx), ("start_z", "end_z", nz))
         for start_name, end_name, numels in what:
@@ -61,3 +61,7 @@ class FullFieldDatasetValidator(DatasetValidatorBase):
                 self.logger.warning(
                     "Cone-beam reconstruction: 'sample_detector_dist' not provided, will use the one in dataset metadata"
                 )
+            if self.is_halftomo:
+                err_msg = "Cone-beam reconstruction with half-acquisition is not supported yet"
+                self.logger.fatal(err_msg)
+                raise NotImplementedError(err_msg)

{nabu-2024.1.6 → nabu-2024.1.8}/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)
         #
@@ -600,7 +605,7 @@ class ProcessConfig(ProcessConfigBase):
             )
             if all([m is not None for m in mean_positions_xyz]):
                 rec_options["position"] = mean_positions_xyz
-            if rec_options["sample_detector_dist"] is None:
+            if rec_options["method"] == "cone" and rec_options["sample_detector_dist"] is None:
                 rec_options["sample_detector_dist"] = self.dataset_info.distance  # was checked to be not None earlier
 
             # New key

{nabu-2024.1.6 → nabu-2024.1.8}/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.6 → nabu-2024.1.8}/nabu/pipeline/helical/tests/test_accumulator.py

@@ -1,5 +1,5 @@
 from nabu.pipeline.helical import gridded_accumulator, span_strategy
-from nabu.testutils import get_data
+from nabu.testutils import get_data, __do_long_tests__
 
 import pytest
 import numpy as np
@@ -49,6 +49,7 @@ def bootstrap(request):
     cls.rtol_regridded = 1.0e-6
 
 
+@pytest.mark.skipif(not (__do_long_tests__), reason="need environment variable NABU_LONG_TESTS=1")
 @pytest.mark.usefixtures("bootstrap")
 class TestGriddedAccumulator:
     """

{nabu-2024.1.6 → nabu-2024.1.8}/nabu/pipeline/processconfig.py

@@ -181,7 +181,10 @@ class ProcessConfigBase:
         #
         if isinstance(tilt, str):  # auto-tilt
             self.tilt_estimator = DetectorTiltEstimator(
-                self.dataset_info, logger=self.logger, autotilt_options=self.nabu_config["preproc"]["autotilt_options"]
+                self.dataset_info,
+                do_flatfield=self.nabu_config["preproc"]["flatfield"],
+                logger=self.logger,
+                autotilt_options=self.nabu_config["preproc"]["autotilt_options"],
             )
             tilt = self.tilt_estimator.find_tilt(tilt_method=tilt)
         self.dataset_info.detector_tilt = tilt

{nabu-2024.1.6 → nabu-2024.1.8}/nabu/processing/tests/test_fftshift.py

@@ -31,6 +31,7 @@ def bootstrap(request):
         cls.cu_ctx.pop()
 
 
+@pytest.mark.skip(reason="OpenCL fftshift is a prototype")
 @pytest.mark.usefixtures("bootstrap")
 class TestFFTshift:
     def _do_test_fftshift(self, config, fftshift_cls):

{nabu-2024.1.6 → nabu-2024.1.8}/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.6 → nabu-2024.1.8}/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_corrections=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.6 → nabu-2024.1.8}/nabu/reconstruction/tests/test_deringer.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 from nabu.reconstruction.rings_cuda import CudaSinoMeanDeringer
-from nabu.testutils import compare_arrays, get_data, generate_tests_scenarios, __do_long_tests__
+from nabu.testutils import compare_arrays, get_data, generate_tests_scenarios, __do_long_tests__, __do_large_mem_tests__
 from nabu.reconstruction.rings import MunchDeringer, SinoMeanDeringer, VoDeringer, __has_algotom__
 from nabu.thirdparty.pore3d_deringer_munch import munchetal_filter
 from nabu.cuda.utils import __has_pycuda__, get_cuda_context
@@ -144,8 +144,8 @@ class TestMunchDeringer:
         # TODO check result. The generated test sinogram is "too synthetic" for this kind of deringer
 
     @pytest.mark.skipif(
-        not (__have_tomocupy_deringer__),
-        reason="Need cupy for this test",
+        not (__have_tomocupy_deringer__ and __do_large_mem_tests__),
+        reason="Need cupy for this test, and use NABU_LARGE_MEM_TESTS",
     )
     def test_cuda_vo_deringer(self):
         # Beware, this deringer seems to be buggy for "too-small" sinograms

{nabu-2024.1.6 → nabu-2024.1.8}/nabu/reconstruction/tests/test_halftomo.py

@@ -3,10 +3,11 @@ import pytest
 from nabu.testutils import get_data, generate_tests_scenarios, compare_shifted_images
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__, __has_cufft__
 from nabu.opencl.utils import get_opencl_context, __has_pyopencl__
+from nabu.processing.fft_opencl import has_vkfft as has_vkfft_cl
 from nabu.thirdparty.algotom_convert_sino import extend_sinogram
 
 __has_pycuda__ = __has_pycuda__ and __has_cufft__  # need both for using Cuda backprojector
-
+__has_pyopencl__ = __has_pyopencl__ and has_vkfft_cl()
 
 if __has_pycuda__:
     from nabu.reconstruction.fbp import CudaBackprojector

{nabu-2024.1.6 → nabu-2024.1.8}/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.6 → nabu-2024.1.8}/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.6 → nabu-2024.1.8/nabu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.1.6
+Version: 2024.1.8
 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>
@@ -48,9 +48,29 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2,>1.9.0
+Requires-Dist: scipy
+Requires-Dist: h5py>=3.0
+Requires-Dist: silx>=0.15.0
+Requires-Dist: tomoscan>=2.0.4
+Requires-Dist: psutil
+Requires-Dist: pytest
+Requires-Dist: tifffile
 Provides-Extra: full
+Requires-Dist: scikit-image; extra == "full"
+Requires-Dist: PyWavelets; extra == "full"
+Requires-Dist: glymur; extra == "full"
+Requires-Dist: pycuda<2024.1.1; extra == "full"
+Requires-Dist: scikit-cuda; extra == "full"
+Requires-Dist: pycudwt; extra == "full"
+Requires-Dist: sluurp>=0.3; extra == "full"
+Requires-Dist: pyvkfft; extra == "full"
 Provides-Extra: doc
-License-File: LICENSE
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: cloud_sptheme; extra == "doc"
+Requires-Dist: myst-parser; extra == "doc"
+Requires-Dist: nbsphinx; extra == "doc"
 
 # Nabu
 

{nabu-2024.1.6 → nabu-2024.1.8}/nabu.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 doc/conf.py
 doc/create_conf_doc.py
+doc/doc_config.py
 doc/get_mathjax.py
 nabu/__init__.py
 nabu/tests.py
@@ -40,7 +41,6 @@ nabu/app/shrink_dataset.py
 nabu/app/stitching.py
 nabu/app/utils.py
 nabu/app/validator.py
-nabu/app/tests/__init__.py
 nabu/app/tests/test_reduce_dark_flat.py
 nabu/cuda/__init__.py
 nabu/cuda/convolution.py
@@ -296,4 +296,35 @@ nabu/thirdparty/algotom_convert_sino.py
 nabu/thirdparty/pore3d_deringer_munch.py
 nabu/thirdparty/tomocupy_remove_stripe.py
 nabu/thirdparty/tomopy_phase.py
-nabu/thirdparty/tomwer_load_flats_darks.py
+nabu/thirdparty/tomwer_load_flats_darks.py
+sandbox/align_test.py
+sandbox/app.py
+sandbox/binning_cython.py
+sandbox/circ_sm.py
+sandbox/composite_image.py
+sandbox/convert_id15.py
+sandbox/do_test_ctf.py
+sandbox/esrf_envs.py
+sandbox/fbp_polar.py
+sandbox/fbp_tilt.py
+sandbox/interleaved.py
+sandbox/interp_sinos_halftomo.py
+sandbox/linear_interp.py
+sandbox/merge_recs.py
+sandbox/moduleutils.py
+sandbox/nbreconstruct.py
+sandbox/pag_margin.py
+sandbox/parse.py
+sandbox/plot.py
+sandbox/proj3D.py
+sandbox/rec_bm05.py
+sandbox/rec_thread.py
+sandbox/shift_bilinear2.py
+sandbox/sinotilt.py
+sandbox/sysutils.py
+sandbox/test_mp_queue.py
+sandbox/tilt.py
+sandbox/utils.py
+sandbox/vo.py
+sandbox/workers.py
+sandbox/xrdrec_pyFAI_data.py

{nabu-2024.1.6 → nabu-2024.1.8}/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.6 → nabu-2024.1.8}/nabu.egg-info/top_level.txt

@@ -1,4 +1,4 @@
+build
 dist
 doc
 nabu
-scripts

{nabu-2024.1.6 → nabu-2024.1.8}/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",

nabu-2024.1.8/sandbox/align_test.py

@@ -0,0 +1,61 @@
+import numpy as np
+from nabu.estimation.translation import DetectorTranslationAlongBeam
+from tomoscan.io import HDF5File
+
+
+def get_data(fname, h5_paths):
+    with HDF5File(fname, "r") as f:
+        align_data = f[h5_paths["align_data"]][()]
+        dark = f[h5_paths["dark"]][0]
+        pixel_size_um = f[h5_paths["pixel_size"]][()]
+        positions_mm = f[h5_paths["positions"]][()]
+
+    # Dark subtraction
+    align_data = align_data - dark.astype("f")
+
+    return align_data, pixel_size_um, positions_mm
+
+
+
+def get_alignment(align_data, pixel_size_um, positions_mm, plot=True):
+
+    tr_calc = DetectorTranslationAlongBeam()
+    if plot == True:
+        tr_calc.verbose=True
+
+    shifts_v, shifts_h = tr_calc.find_shift(align_data, positions_mm)
+
+    # pixel_size is in microns, motor position is in mm
+    tilt_v_deg = np.rad2deg(np.arctan(shifts_v * pixel_size_um / 1e3))
+    tilt_h_deg = np.rad2deg(np.arctan(shifts_h * pixel_size_um / 1e3))
+    print (f"\nVertical tilt  to be applied in deg (thy): {tilt_v_deg}")
+    print (f"Horizontal tilt to be applied in deg (thz): {tilt_h_deg}\n")
+
+    return align_data, shifts_v, shifts_h, positions_mm
+
+
+
+
+
+
+if __name__ == "__main__":
+    fname = "/data/id19/inhouse/id192201/id19/sample/sample_0001/sample_0001.h5"
+    h5_paths = {
+        "align_data": "11.1/measurement/pcolinux",
+        "dark": "12.1/measurement/pcolinux",
+        "pixel_size": "11.1/instrument/pcolinux/x_pixel_size",
+        "positions": "11.1/measurement/hrxc"
+    }
+    align_data, pixel_size_um, positions_mm = get_data(fname, h5_paths)
+    # align_data, shifts_v, shifts_h, positions_mm = get_alignment(align_data, pixel_size_um, positions_mm)
+
+    D = DetectorTranslationAlongBeam()
+    D. verbose = True
+    sv, sh = D.find_shift(align_data, positions_mm)
+    D.verbose = False
+    sv, sh = D.find_shift(align_data, positions_mm)
+    D.verbose = True
+    sv, sh = D.find_shift(align_data, positions_mm)
+
+
+