nabu 2023.2.1__py3-none-any.whl → 2024.1.0rc3__py3-none-any.whl

nabu/estimation/cor_sino.py

@@ -34,18 +34,17 @@ class SinoCor:
         - accurate. Try to refine COR to 1/10 pixel
     """
 
-    def __init__(self, sinogram, logger=None):
+    def __init__(self, img_1, img_2, logger=None):
         """ """
         self.logger = LoggerOrPrint(logger)
-        self.sx = sinogram.shape[1]
-        self.sy = sinogram.shape[0]
+        self.sx = img_1.shape[1]
 
-        # algorithm cannot accept odd number of projs
-        nproj2 = int((self.sy - (self.sy % 2)) / 2)
+        # algorithm cannot accept odd number of projs. This is handled in the SinoCORFinder class.
+        nproj2 = img_1.shape[0]
 
         # extract upper and lower part of sinogram, flipping H the upper part
-        self.data1 = sinogram[0:nproj2, :]
-        self.data2 = np.fliplr(sinogram[nproj2:, :].copy())
+        self.data1 = img_1
+        self.data2 = img_2
 
         self.rcor_abs = round(self.sx / 2.0)
         self.cor_acc = round(self.sx / 2.0)
@@ -177,8 +176,7 @@ class SinoCorInterface:
         self._logger = logger
 
     def find_shift(self, img_1, img_2, side="right", window_width=None, neighborhood=7, shift_value=0.1, **kwargs):
-        sinogram = np.vstack([img_1, img_2])
-        cor_finder = SinoCor(sinogram, logger=self._logger)
+        cor_finder = SinoCor(img_1, img_2, logger=self._logger)
         cor_finder.estimate_cor_coarse(side=side, window_width=window_width)
         cor = cor_finder.estimate_cor_fine(neighborhood=neighborhood, shift_value=shift_value)
         # offset will be added later - keep compatibility with result from AlignmentBase.find_shift()

nabu/estimation/tests/test_cor.py

@@ -5,11 +5,14 @@ import scipy.ndimage
 import h5py
 from nabu.testutils import utilstest, __do_long_tests__
 from nabu.testutils import get_data as nabu_get_data
+
 from nabu.estimation.cor import (
     CenterOfRotation,
     CenterOfRotationAdaptiveSearch,
     CenterOfRotationGrowingWindow,
     CenterOfRotationSlidingWindow,
+    CenterOfRotationFourierAngles,
+    CenterOfRotationOctaveAccurate,
 )
 from nabu.estimation.cor_sino import SinoCor
 
@@ -30,6 +33,27 @@ def bootstrap_cor_win(request):
     cls.data_ha_sino, cls.cor_ha_sn_pix = get_cor_win_sino_data_h5("halftomo_1_sino.npz")
 
 
+@pytest.fixture(scope="class")
+def bootstrap_cor_accurate(request):
+    cls = request.cls
+    cls.abs_tol = 0.2
+    cls.image_pair_stylo, cls.cor_pos_abs_stylo = get_cor_win_proj_data_h5("stylo_accurate.npz")
+    cls.image_pair_blc12781, cls.cor_pos_abs_blc12781 = get_cor_win_proj_data_h5("blc12781_accurate.npz")
+
+
+@pytest.fixture(scope="class")
+def bootstrap_cor_fourier(request):
+    cls = request.cls
+    cls.abs_tol = 0.2
+    dataset_relpath = os.path.join("sino_bamboo_hercules_for_test.npz")
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+    a = np.load(dataset_downloaded_path)
+    cls.sinos = a["sinos"]
+    cls.angles = a["angles"]
+    cls.true_cor = a["true_cor"]
+    cls.estimated_cor_from_motor = a["estimated_cor_from_motor"]
+
+
 def get_cor_data_h5(*dataset_path):
     """
     Get a dataset file from silx.org/pub/nabu/data
@@ -241,6 +265,7 @@ class TestCor:
         assert "Images need to be of the same shape" in str(ex.value), message
 
 
+@pytest.mark.skipif(not (__do_long_tests__), reason="Need NABU_LONG_TESTS=1 for this test")
 @pytest.mark.usefixtures("bootstrap_cor", "bootstrap_cor_win")
 class TestCorWindowSlide:
     def test_proj_center_axis_lft(self):
@@ -309,6 +334,7 @@ class TestCorWindowSlide:
         assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 5), message
 
 
+@pytest.mark.skipif(not (__do_long_tests__), reason="need NABU_LONG_TESTS for this test")
 @pytest.mark.usefixtures("bootstrap_cor", "bootstrap_cor_win")
 class TestCorWindowGrow:
     def test_proj_center_axis_cen(self):
@@ -379,12 +405,68 @@ class TestCoarseToFineSinoCor:
         Test nabu.estimation.cor_sino.SinoCor
         """
         sino_halftomo = np.vstack([self.data_ha_sino[0], self.data_ha_sino[1]])
-        sino_cor = SinoCor(sino_halftomo)
+        sino_cor = SinoCor(self.data_ha_sino[0], np.fliplr(self.data_ha_sino[1]))
         cor_coarse = sino_cor.estimate_cor_coarse()
-        assert np.isscalar(cor_coarse), f"cor_position expected to be a scale, {type(cor_position)} returned"
+        assert np.isscalar(cor_coarse), f"cor_position expected to be a scalar, {type(cor_coarse)} returned"
         cor_fine = sino_cor.estimate_cor_fine()
-        assert np.isscalar(cor_fine), f"cor_position expected to be a scale, {type(cor_position)} returned"
+        assert np.isscalar(cor_fine), f"cor_position expected to be a scale, {type(cor_fine)} returned"
 
         cor_ref = self.cor_ha_sn_pix + sino_halftomo.shape[-1] / 2.0
         message = "Computed CoR %f " % cor_fine + " and expected CoR %f do not coincide" % cor_ref
         assert abs(cor_fine - cor_ref) < self.abs_tol * 2, message
+
+
+@pytest.mark.usefixtures("bootstrap_cor_accurate")
+class TestCorOctaveAccurate:
+    def test_cor_accurate_positive_shift(self):
+        detector_width = self.image_pair_stylo[0].shape[1]
+        CoR_calc = CenterOfRotationOctaveAccurate()
+        cor_position = CoR_calc.find_shift(self.image_pair_stylo[0], np.fliplr(self.image_pair_stylo[1]), "center")
+        cor_position = cor_position + detector_width / 2
+        assert np.isscalar(cor_position), f"cor_position expected to be a scalar, {type(cor_position)} returned"
+        message = f"Computed CoR {cor_position} and expected CoR {self.cor_pos_abs_stylo} do not coincide."
+        assert np.isclose(self.cor_pos_abs_stylo, cor_position, atol=self.abs_tol), message
+
+    def test_cor_accurate_negative_shift(self):
+        detector_width = self.image_pair_blc12781[0].shape[1]
+        CoR_calc = CenterOfRotationOctaveAccurate()
+        cor_position = CoR_calc.find_shift(
+            self.image_pair_blc12781[0], np.fliplr(self.image_pair_blc12781[1]), "center"
+        )
+        cor_position = cor_position + detector_width / 2
+        assert np.isscalar(cor_position), f"cor_position expected to be a scalar, {type(cor_position)} returned"
+        message = f"Computed CoR {cor_position} and expected CoR {self.cor_pos_abs_blc12781} do not coincide."
+        assert np.isclose(self.cor_pos_abs_blc12781, cor_position, atol=self.abs_tol), message
+
+
+@pytest.mark.usefixtures("bootstrap_cor_fourier", "bootstrap_cor_win")
+class TestCorFourierAngle:
+    def test_sino_right_axis_with_near_pos(self):
+        sino1 = self.data_ha_sino[0, :, :]
+        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
+        start_angle = np.pi / 4
+        angles = np.linspace(start_angle, start_angle + 2 * np.pi, 2 * sino1.shape[0])
+
+        cor_options = {"side": 740, "refine": True}
+
+        CoR_calc = CenterOfRotationFourierAngles(cor_options=cor_options)
+        cor_position = CoR_calc.find_shift(sino1, sino2, angles, side="right")
+        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
+
+        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
+        assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 3), message
+
+    def test_sino_right_axis_with_ignore(self):
+        sino1 = self.data_ha_sino[0, :, :]
+        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
+        start_angle = np.pi / 4
+        angles = np.linspace(start_angle, start_angle + 2 * np.pi, 2 * sino1.shape[0])
+
+        cor_options = {"side": "ignore", "refine": True}
+
+        CoR_calc = CenterOfRotationFourierAngles(cor_options=cor_options)
+        cor_position = CoR_calc.find_shift(sino1, sino2, angles, side="right")
+        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
+
+        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
+        assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 3), message

nabu/io/reader.py

@@ -9,9 +9,9 @@ from ..misc.binning import binning as image_binning
 from ..utils import subsample_dict, get_3D_subregion, get_num_threads
 
 try:
-    from silx.third_party.EdfFile import EdfFile
+    from fabio.edfimage import EdfImage
 except ImportError:
-    EdfFile = None
+    EdfImage = None
 
 
 class Reader:
@@ -122,21 +122,21 @@ class EDFReader(Reader):
         A class for reading series of EDF Files.
         Multi-frames EDF are not supported.
         """
-        if EdfFile is None:
-            raise ImportError("Need EdfFile to use this reader")
+        if EdfImage is None:
+            raise ImportError("Need fabio to use this reader")
         super().__init__(sub_region=sub_region)
+        self._reader = EdfImage()
+        self._first_fname = None
 
     def read(self, fname):
-        E = EdfFile(fname, "r")
-        if self.sub_region is not None:
-            data = E.GetData(
-                0,
-                Pos=(self.start_x, self.start_y),
-                Size=(self.end_x - self.start_x, self.end_y - self.start_y),
-            )
+        if self._first_fname is None:
+            self._first_fname = fname
+            self._reader.read(fname)
+        if self.sub_region is None:
+            data = self._reader.data
         else:
-            data = E.GetData(0)
-        E.File.close()
+            data = self._reader.fast_read_roi(fname, (slice(self.start_y, self.end_y), slice(self.start_x, self.end_x)))
+        self._reader.close()
         return data
 
     def get_data(self, data_url):
@@ -279,9 +279,10 @@ class ChunkReader:
             Whether to bin the data. If multi-dimensional binning is done,
             the parameter must be in the form (binning_x, binning_y).
             Each image will be binned by these factors.
-        dataset_subsampling: int, optional
-            Whether to subsample the dataset. If an integer `n` is provided,
-            then one image out of `n` will be read.
+        dataset_subsampling: int or tuple, optional
+            Subsampling factor when reading the images.
+            If an integer `n` is provided, then one image out of `n` will be read.
+            If a tuple of integers (step, begin) is given, the data is read as data[begin::step]
         num_threads: int, optional
             Number of threads to use for binning the data.
             Default is to use all available threads.
@@ -328,6 +329,10 @@ class ChunkReader:
     def _set_files(self, files):
         if len(files) == 0:
             raise ValueError("Expected at least one data file")
+        self._files_begin_idx = 0
+        if isinstance(self.dataset_subsampling, (tuple, list)):
+            self._files_begin_idx = self.dataset_subsampling[1]
+            self.dataset_subsampling = self.dataset_subsampling[0]
         self.n_files = len(files)
         self.files = files
         self._sorted_files_indices = sorted(files.keys())
@@ -469,10 +474,13 @@ class ChunkReader:
             self._fileindex_to_idx[fileidx] = i
 
     def _load_multi(self):
-        urls_compacted = get_compacted_dataslices(self.files, subsampling=self.dataset_subsampling)
+        urls_compacted = get_compacted_dataslices(
+            self.files, subsampling=self.dataset_subsampling, begin=self._files_begin_idx
+        )
         loaded = {}
         start_idx = 0
-        for idx in self._sorted_files_indices:
+        sorted_files_indices = sorted(urls_compacted.keys())
+        for idx in sorted_files_indices:
             url = urls_compacted[idx]
             url_str = str(url)
             is_loaded = loaded.get(url_str, False)

nabu/io/tests/test_cast_volume.py

@@ -14,7 +14,7 @@ from tomoscan.esrf.volume import (
 )
 from nabu.io.writer import __have_jp2k__
 from tomoscan.esrf.scan.edfscan import EDFTomoScan
-from tomoscan.esrf.scan.hdf5scan import HDF5TomoScan
+from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 import pytest
 import h5py
 import os
@@ -137,7 +137,7 @@ def test_find_histogram_single_frame_volume(tmp_path):
 
     assert find_histogram(
         volume=volume,
-        scan=HDF5TomoScan(scan=str(tmp_path), entry="entry"),
+        scan=NXtomoScan(scan=str(tmp_path), entry="entry"),
     ) == DataUrl(
         file_path=histogram_file,
         data_path="entry",
@@ -174,7 +174,7 @@ def test_find_histogram_multi_tiff_volume(tmp_path):
 
     assert find_histogram(
         volume=volume,
-        scan=HDF5TomoScan(scan=str(tmp_path), entry="entry"),
+        scan=NXtomoScan(scan=str(tmp_path), entry="entry"),
     ) == DataUrl(
         file_path=histogram_file,
         data_path="entry",

nabu/io/tests/test_detector_distortion.py

@@ -1,9 +1,9 @@
+import pytest
 import numpy as np
 import scipy.ndimage
-from nabu.io.detector_distortion import DetectorDistortionBase
 from scipy import sparse
-from nabu.misc.rotation import Rotation, __have__skimage__
-import pytest
+from nabu.io.detector_distortion import DetectorDistortionBase
+from nabu.processing.rotation import Rotation, __have__skimage__
 
 if __have__skimage__:
     import skimage

nabu/io/tiffwriter_zmm.py

@@ -83,10 +83,10 @@ class TIFFWriter(StandardTIFFWriter):  # pylint: disable=E0102
                     part_mm = int(value_mm)
                     rest_um = (value_mm - part_mm) * 1000
                     part_um = int(rest_um)
-                    rest_nm = (rest_um - part_um) * 1000
+                    rest_nm = (rest_um - part_um) * 10
                     part_nm = int(rest_nm)
 
-                    curr_rel_filename = prefix + "_{}{:06d}p{:03d}{:03d}".format(sign, part_mm, part_um, part_nm) + ext
+                    curr_rel_filename = prefix + "_{}{:04d}p{:03d}{:1d}".format(sign, part_mm, part_um, part_nm) + ext
 
                 fname = path.join(dirname, curr_rel_filename)
 

nabu/io/utils.py

@@ -1,6 +1,5 @@
 import os
 from typing import Optional
-import warnings
 import contextlib
 import h5py
 import numpy as np
@@ -11,7 +10,7 @@ from tomoscan.io import HDF5File
 
 
 # This function might be moved elsewhere
-def get_compacted_dataslices(urls, subsampling=None):
+def get_compacted_dataslices(urls, subsampling=None, begin=0):
     """
     Regroup urls to get the data more efficiently.
     Build a structure mapping files indices to information on
@@ -54,7 +53,9 @@ def get_compacted_dataslices(urls, subsampling=None):
         return urls
 
     sorted_files_indices = sorted(urls.keys())
-    idx0 = sorted_files_indices[0]
+    # if begin > 0:
+    # sorted_files_indices = sorted_files_indices[begin:]
+    idx0 = sorted_files_indices[begin]
     first_url = urls[idx0]
 
     merged_indices = [[idx0]]
@@ -62,7 +63,11 @@ def get_compacted_dataslices(urls, subsampling=None):
     data_location = [[first_url.file_path(), first_url.data_path(), _convert_to_slice(first_url.data_slice())]]
     pos = 0
     curr_fp, curr_dp, curr_slice = data_location[pos]
-    for idx in sorted_files_indices[1:]:
+    skip_next = 0
+    for idx in sorted_files_indices[begin + 1 :]:
+        if skip_next > 1:
+            skip_next -= 1
+            continue
         url = urls[idx]
         next_slice = _convert_to_slice(url.data_slice())
         if (
@@ -74,7 +79,12 @@ def get_compacted_dataslices(urls, subsampling=None):
             merged_slices = merge_slices(curr_slice, next_slice, step=subsampling)
             data_location[pos][-1] = merged_slices
             curr_slice = merged_slices
+            skip_next = 0
         else:  # "jump"
+            if begin > 0 and skip_next == 0:
+                # Skip the "begin" next urls (first of a new block)
+                skip_next = begin
+                continue
             pos += 1
             merged_indices.append([idx])
             data_location.append([url.file_path(), url.data_path(), _convert_to_slice(url.data_slice())])

nabu/io/writer.py

@@ -795,15 +795,15 @@ class HSTVolWriter(Writer):
         super().__init__(fname)
         self.append = append
         self._vol_writer = RawVolume(fname, overwrite=True, append=append)
+        self._hst_metadata = kwargs.get("hst_metadata", {})
 
-    @staticmethod
-    def generate_metadata(data, **kwargs):
+    def generate_metadata(self, data, **kwargs):
         n_z, n_y, n_x = data.shape
         metadata = {
             "NUM_X": n_x,
             "NUM_Y": n_y,
             "NUM_Z": n_z,
-            "voxelSize": kwargs.get("voxelSize", 40.0),
+            "voxelSize": 40.0,
             "BYTEORDER": "LOWBYTEFIRST",
             "ValMin": kwargs.get("ValMin", 0.0),
             "ValMax": kwargs.get("ValMin", 1.0),
@@ -812,6 +812,8 @@ class HSTVolWriter(Writer):
             "S1": 0.0,
             "S2": 0.0,
         }
+        for key, default_val in metadata.items():
+            metadata[key] = kwargs.get(key, None) or self._hst_metadata.get(key, None) or default_val
         return metadata
 
     @staticmethod

nabu/misc/fftshift.py

@@ -0,0 +1,6 @@
+from ..processing.fftshift import *
+from ..utils import deprecation_warning
+
+deprecation_warning(
+    "nabu.misc.fftshift has been moved to nabu.processing.fftshift", do_print=True, func_name="fftshift"
+)