tomoscan 2.3.0.dev0__tar.gz → 2.3.0.dev1__tar.gz

{tomoscan-2.3.0.dev0 → tomoscan-2.3.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tomoscan
-Version: 2.3.0.dev0
+Version: 2.3.0.dev1
 Summary: Utility to access tomography data at ESRF
 Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>
 License: MIT

{tomoscan-2.3.0.dev0 → tomoscan-2.3.0.dev1}/tomoscan/esrf/scan/framereducer/hdf5framereducer.py

@@ -154,6 +154,11 @@ class HDF5FrameReducer(FrameReducerBase):
         res = {}
         # res: key is serie index (first serie frame index), value is the numpy.array of the reduced frame
         infos = ReducedFramesInfos()
+        from tomoscan.esrf.scan.nxtomoscan import NXtomoScan  # avoid cyclic import
+
+        if isinstance(self.scan, NXtomoScan):
+            infos.lr_flip = self.scan.detector_is_lr_flip
+            infos.ud_flip = self.scan.detector_is_ud_flip
 
         for series_ in raw_series:
             series_index = min(series_)

{tomoscan-2.3.0.dev0 → tomoscan-2.3.0.dev1}/tomoscan/esrf/scan/framereducer/tests/test_hdf5framereducer.py

@@ -4,10 +4,17 @@ from __future__ import annotations
 
 import h5py
 import numpy
+import pytest
 
 from nxtomo.application.nxtomo import ImageKey
 from tomoscan.esrf.scan.mock import MockNXtomo as _MockNXtomo
 from tomoscan.scanbase import ReducedFramesInfos
+from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
+from nxtomo.utils.transformation import (
+    DetXFlipTransformation,
+    DetYFlipTransformation,
+)
+from nxtomo.nxobject.nxtransformations import NXtransformations
 
 
 class MockNXtomo(_MockNXtomo):
@@ -86,7 +93,10 @@ class MockNXtomo(_MockNXtomo):
             )
 
 
-def test_reduce_hdf5(tmp_path):
+@pytest.mark.parametrize(
+    "lr_flip, ud_flip", ((False, False), (True, False), (False, True))
+)
+def test_reduce_hdf5(tmp_path, lr_flip, ud_flip):
     """insure calculation of dark and flats are valid for a default use case"""
     dim = 20
     folder_1 = tmp_path / "test1"
@@ -158,6 +168,8 @@ def test_reduce_hdf5(tmp_path):
         machine_current=machine_current,
     ).scan
 
+    patch_detector_flip(scan=scan, lr_flip=lr_flip, ud_flip=ud_flip)
+
     assert scan.machine_current is not None
     assert scan.exposure_time is not None
 
@@ -276,7 +288,11 @@ def test_reduce_hdf5(tmp_path):
     numpy.testing.assert_almost_equal(
         flats_infos.count_time[1], numpy.mean(flats_s2_count_time)
     )
-    # no test on first and last but this is the same as for darks
+    # note: no test are done on the first and last but this is the same as for darks
+
+    # test detector flips
+    assert flats_infos.lr_flip == lr_flip
+    assert flats_infos.ud_flip == ud_flip
 
 
 def test_reduce_hdf5_fails(tmp_path):
@@ -291,3 +307,16 @@ def test_reduce_hdf5_fails(tmp_path):
     ).scan
     assert scan.compute_reduced_flats(reduced_method="first", return_info=False) == {}
     assert scan.compute_reduced_darks(reduced_method="last", return_info=False) == {}
+
+
+def patch_detector_flip(scan: NXtomoScan, lr_flip: bool, ud_flip: bool):
+    "function that patches an NXtomo' detector flips"
+
+    mc_stas_transformation = NXtransformations()
+    mc_stas_transformation.add_transformation(DetYFlipTransformation(flip=lr_flip))
+    mc_stas_transformation.add_transformation(DetXFlipTransformation(flip=ud_flip))
+    mc_stas_transformation.save(
+        file_path=scan.master_file,
+        data_path="/entry/instrument/detector/transformations",
+        overwrite=True,
+    )

{tomoscan-2.3.0.dev0 → tomoscan-2.3.0.dev1}/tomoscan/framereducer/ReduceFrameSaver.py

@@ -199,7 +199,9 @@ class ReduceFrameSaver:
                     metadata_values,
                 ) in self.frames_metadata.to_dict().items():
                     # warning: for now we only handle list (of count_time and machine_current)
-                    if len(metadata_values) == 0:
+                    if (not numpy.isscalar(metadata_values)) and len(
+                        metadata_values
+                    ) == 0:
                         continue
                     else:
                         # save metadata

{tomoscan-2.3.0.dev0 → tomoscan-2.3.0.dev1}/tomoscan/framereducer/reducedframesinfos.py

@@ -13,9 +13,17 @@ class ReducedFramesInfos:
 
     COUNT_TIME_KEY = "count_time"
 
+    LR_FLIP = "lr_flip"
+    """Save the information if the original raw frame was left-right flipped. Warning: tomoscan will only propagate this information but won't flip reduced frames saved"""
+
+    UD_FLIP = "ud_flip"
+    """Save the information if the original raw frame was up-down flipped. Warning: tomoscan will only propagate this information but won't flip reduced frames saved"""
+
     def __init__(self) -> None:
         self._count_time = []
         self._machine_current = []
+        self._lr_flip = None
+        self._ud_flip = None
 
     def __eq__(self, __o: object) -> bool:
         if isinstance(__o, dict):
@@ -32,6 +40,8 @@ class ReducedFramesInfos:
     def clear(self):
         self._count_time.clear()
         self._machine_current.clear()
+        self._lr_flip = None
+        self._ud_flip = None
 
     @property
     def count_time(self) -> list:
@@ -79,17 +89,53 @@ class ReducedFramesInfos:
         else:
             self._machine_current = list(machine_current)
 
+    @property
+    def lr_flip(self) -> bool | None:
+        return self._lr_flip
+
+    @lr_flip.setter
+    def lr_flip(self, flip: bool | None):
+        if not isinstance(flip, (bool, type(None))):
+            raise TypeError(
+                f"flip is expected to be None or a bool. got {type(flip)}, {flip}, {flip.dtype}"
+            )
+        self._lr_flip = flip
+
+    @property
+    def ud_flip(self) -> bool | None:
+        return self._ud_flip
+
+    @ud_flip.setter
+    def ud_flip(self, flip: bool | None):
+        if not isinstance(flip, (bool, type(None))):
+            raise TypeError(
+                f"flip is expected to be None or a bool. got {type(flip)}, {flip}, {flip.dtype}"
+            )
+        self._ud_flip = flip
+
     def to_dict(self) -> dict:
         res = {}
         if len(self.machine_current) > 0:
             res[self.MACHINE_ELECT_CURRENT_KEY] = self.machine_current
         if len(self.count_time) > 0:
             res[self.COUNT_TIME_KEY] = self.count_time
+        if self.lr_flip is not None:
+            res[self.LR_FLIP] = self.lr_flip
+        if self.ud_flip is not None:
+            res[self.UD_FLIP] = self.ud_flip
         return res
 
     def load_from_dict(self, my_dict: dict):
         self.machine_current = my_dict.get(self.MACHINE_ELECT_CURRENT_KEY, None)
         self.count_time = my_dict.get(self.COUNT_TIME_KEY, None)
+
+        def cast_numpy_bool(value):
+            if isinstance(value, numpy.ndarray):
+                return bool(value)
+            return value
+
+        self.lr_flip = cast_numpy_bool(my_dict.get(self.LR_FLIP, None))
+        self.ud_flip = cast_numpy_bool(my_dict.get(self.UD_FLIP, None))
         return self
 
     @staticmethod
@@ -98,6 +144,8 @@ class ReducedFramesInfos:
             raise TypeError
         my_dict.pop(ReducedFramesInfos.MACHINE_ELECT_CURRENT_KEY, None)
         my_dict.pop(ReducedFramesInfos.COUNT_TIME_KEY, None)
+        my_dict.pop(ReducedFramesInfos.LR_FLIP, None)
+        my_dict.pop(ReducedFramesInfos.UD_FLIP, None)
         return my_dict
 
     @staticmethod
@@ -119,5 +167,7 @@ class ReducedFramesInfos:
             [
                 f"machine_current {self.machine_current}",
                 f"count_time {self.count_time}",
+                f"lr_flip {self.lr_flip}",
+                f"ud_flip {self.ud_flip}",
             ]
         )

{tomoscan-2.3.0.dev0 → tomoscan-2.3.0.dev1}/tomoscan/version.py

@@ -56,7 +56,7 @@ MAJOR = 2
 MINOR = 3
 MICRO = 0
 RELEV = "dev"  # <16
-SERIAL = 0
+SERIAL = 1
 
 date = __date__
 

{tomoscan-2.3.0.dev0 → tomoscan-2.3.0.dev1}/tomoscan.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tomoscan
-Version: 2.3.0.dev0
+Version: 2.3.0.dev1
 Summary: Utility to access tomography data at ESRF
 Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>
 License: MIT

{tomoscan-2.3.0.dev0 → tomoscan-2.3.0.dev1}/tomoscan.egg-info/SOURCES.txt

@@ -71,9 +71,6 @@ tomoscan/esrf/volume/rawvolume.py
 tomoscan/esrf/volume/singleframebase.py
 tomoscan/esrf/volume/tiffvolume.py
 tomoscan/esrf/volume/utils.py
-tomoscan/esrf/volume/helpers/__init__.py
-tomoscan/esrf/volume/helpers/single_frame_saver.py
-tomoscan/esrf/volume/helpers/test/test_single_frame_saver.py
 tomoscan/esrf/volume/tests/test_edfvolume.py
 tomoscan/esrf/volume/tests/test_hdf5volume.py
 tomoscan/esrf/volume/tests/test_jp2kvolume.py

tomoscan-2.3.0.dev0/tomoscan/esrf/volume/helpers/single_frame_saver.py

@@ -1,73 +0,0 @@
-"""module with helper ot save single frame"""
-
-from __future__ import annotations
-
-from tomoscan.esrf.volume.singleframebase import VolumeSingleFrameBase
-
-
-class SingleFrameSaverHelper:
-    """
-    Allow to save to a single file per frame structure along any axis. The volume is expected to be 3D.
-
-    .. note:: This is not part of the VolumeSingleFrameBase API because we want to make it clear that way of saving is very particular
-              and might comes with some botlnecks
-    """
-
-    def __init__(
-        self,
-        volume: VolumeSingleFrameBase,
-        data_shape: tuple,
-        dtype,
-        cache_size: int | None = None,
-    ) -> None:
-        """
-        :param volume: volume to save data for
-        :param shape: final data shape
-        :param dtype: data type (as a numpy data type)
-        :param cache_size: cache of the size (in bytes). Once this size is reached then the data will be dump to disk...
-        """
-        if not isinstance(volume, VolumeSingleFrameBase):
-            raise TypeError(
-                f"volume is expected to be an instance of VolumeSingleFrameBase. Get {type(volume)}"
-            )
-        if not isinstance(data_shape, tuple):
-            raise TypeError(
-                f"shape is expected to be an instance of tuple. Get {type(data_shape)}"
-            )
-
-        self._volume = volume
-        self._shape = data_shape
-        self._dtype = dtype
-        self._frame_index_to_file = None
-        self._initialized = False
-
-    def init_saver(self):
-        self._frame_index_to_file = {}
-        for i, frame_dumper in enumerate(
-            self._volume.data_file_saver_generator(
-                n_frames=self._shape[0],
-                data_url=self._volume.data_url,
-                overwrite=self._volume.overwrite,
-            ),
-        ):
-            self._frame_index_to_file[i] = frame_dumper
-        self._initialized = True
-
-        for i in range(len(self._frame_index_to_file) - 1):
-            assert self._frame_index_to_file[i] != self._frame_index_to_file[i + 1]
-
-    def __setitem__(self, index, value):
-        if not self._initialized:
-            raise RuntimeError(
-                "the helper should be initialized first. Freezing the shape. Please call 'init_saver' before dumping any data to it"
-            )
-        if isinstance(index, slice):
-            # in case we are saving the full frame there is no need for any cache mecanism
-            self._frame_index_to_file[index.start, index.stop, index.step][:] = value
-        elif isinstance(index, (int, tuple)):
-            # in case we are saving the full frame there is no need for any cache mecanism
-            self._frame_index_to_file[index][:] = value
-        else:
-            raise NotImplementedError(
-                f"index is expected to be an instance of int or a tuple of int. Got {type(index)}"
-            )

tomoscan-2.3.0.dev0/tomoscan/esrf/volume/helpers/test/test_single_frame_saver.py

@@ -1,67 +0,0 @@
-import os
-import pytest
-import numpy
-from tomoscan.esrf.volume.helpers.single_frame_saver import SingleFrameSaverHelper
-from tomoscan.esrf.volume.edfvolume import EDFVolume
-from tomoscan.esrf.volume.jp2kvolume import JP2KVolume, has_glymur, has_minimal_openjpeg
-from tomoscan.esrf.volume.tiffvolume import TIFFVolume, has_tifffile
-from tomoscan.esrf.volume.mock import create_volume
-
-
-volume_constructors = [
-    EDFVolume,
-]
-if has_tifffile:
-    volume_constructors.append(TIFFVolume)
-if has_glymur and has_minimal_openjpeg:
-    volume_constructors.append(JP2KVolume)
-
-
-@pytest.mark.parametrize("cache_size", (None, 16, 256, 4096, 65536, numpy.inf))
-@pytest.mark.parametrize("dtype", (numpy.uint8, numpy.uint16, numpy.float128))
-@pytest.mark.parametrize("axis", (0, 1, 2))
-@pytest.mark.parametrize("volume_constructor", volume_constructors)
-def test_SingleFrameSaverHelper(tmp_path, axis, dtype, volume_constructor, cache_size):
-    """Test SingleFrameSaverHelper along all the axis and with all kind of 'single frame' volume"""
-
-    data = create_volume(frame_dims=(100, 100), z_size=100)
-    # rescale data. Because for example jp2k is rescaling it by default
-    if dtype is numpy.float128:
-        max_val = numpy.finfo(dtype).max
-    else:
-        max_val = numpy.iinfo(dtype).max
-    data = data / data.max() * max_val
-    data = data.astype(dtype)
-
-    output_folder = os.path.join(tmp_path, volume_constructor.DEFAULT_DATA_EXTENSION)
-    volume = volume_constructor(
-        folder=output_folder,
-    )
-
-    data_saver_helper = SingleFrameSaverHelper(
-        volume=volume,
-        data_shape=(100, 100, 100),
-        dtype=dtype,
-        cache_size=cache_size,
-    )
-    data_saver_helper.init_saver()
-
-    for i in range(100):
-        if axis == 0:
-            data_saver_helper[i] = data[i]
-        elif axis == 1:
-            data_saver_helper[:, i] = data[:, i]
-        elif axis == 2:
-            data_saver_helper[:, :, i] = data[:, :, i]
-
-    # note: saving is done directly on the file. So this will not affect the volume.data
-    # except if loaded and stored
-    volume_data = volume.load_data(store=False)
-
-    assert data.shape == volume_data.shape
-    assert data.dtype == volume_data.dtype
-
-    numpy.testing.assert_array_equal(
-        data,
-        volume_data,
-    )