nabu 2024.1.9__py3-none-any.whl → 2024.2.0__py3-none-any.whl

nabu/pipeline/helical/tests/test_strategy.py

@@ -1,61 +0,0 @@
-import pytest
-import numpy as np
-from nabu.testutils import get_data as nabu_get_data
-from nabu.pipeline.helical.span_strategy import SpanStrategy
-
-
-@pytest.fixture(scope="class")
-def bootstrap_TestStrategy(request):
-    cls = request.cls
-    cls.abs_tol = 1.0e-6
-
-    # from the Paul telephone dataset
-    test_data = nabu_get_data("data_test_strategy.npz")
-
-    cls.z_pix_per_proj = test_data["z_pix_per_proj"]
-    cls.x_pix_per_proj = test_data["x_pix_per_proj"]
-    cls.detector_shape_vh = test_data["detector_shape_vh"]
-    cls.phase_margin_pix = test_data["phase_margin_pix"]
-    cls.projection_angles_deg = test_data["projection_angles_deg"]
-    cls.require_redundancy = test_data["require_redundancy"]
-    cls.pixel_size_mm = test_data["pixel_size_mm"]
-
-    cls.result_angle_index_span = test_data["result_angle_index_span"]
-    cls.result_angles_rad = test_data["result_angles_rad"]
-    cls.result_fract_complement_to_integer_shift_v = test_data["result_fract_complement_to_integer_shift_v"]
-    cls.result_integer_shift_v = test_data["result_integer_shift_v"]
-    cls.result_span_v = test_data["result_span_v"]
-    cls.result_x_pix_per_proj = test_data["result_x_pix_per_proj"]
-    cls.result_z_pix_per_proj = test_data["result_z_pix_per_proj"]
-
-    cls.test_data = test_data
-
-
-@pytest.mark.usefixtures("bootstrap_TestStrategy")
-class TestStrategy:
-    def test_strategy(self):
-        # the python implementation is slow. so we take only a p[art of the scan
-        limit = 4000
-        span_info = SpanStrategy(
-            z_pix_per_proj=self.z_pix_per_proj[:limit],
-            x_pix_per_proj=self.x_pix_per_proj[:limit],
-            detector_shape_vh=self.detector_shape_vh,
-            phase_margin_pix=self.phase_margin_pix,
-            projection_angles_deg=self.projection_angles_deg[:limit],
-            pixel_size_mm=self.pixel_size_mm,
-            require_redundancy=self.require_redundancy,
-        )
-
-        print(span_info.get_informative_string())
-        chunk_info = span_info.get_chunk_info(self.result_span_v)
-
-        for key, val in chunk_info.__dict__.items():
-            reference = getattr(self, "result_" + key)
-            ref_array = np.array(reference)
-            res_array = np.array(val)
-            if res_array.dtype in [bool, np.int32, np.int64]:
-                message = f" different result for {key} attribute in the chunk_info returned value  "
-                assert np.array_equal(res_array, ref_array), message
-            elif res_array.dtype in [np.float32, np.float64]:
-                message = f" different result for {key} attribute in the chunk_info returned value  "
-                assert np.all(np.isclose(res_array, ref_array, atol=self.abs_tol)), message

nabu/pipeline/helical/utils.py

@@ -1,51 +0,0 @@
-from ...utils import *
-from ...io.writer import Writers, NXProcessWriter
-from ...io.tiffwriter_zmm import TIFFWriter
-from ...resources.logger import LoggerOrPrint
-from ...resources.utils import is_hdf5_extension
-from os import path, mkdir
-from ...utils import check_supported
-from ..fallback_utils import WriterConfigurator
-from ..params import files_formats
-
-Writers["tif"] = TIFFWriter
-Writers["tiff"] = TIFFWriter
-
-
-class WriterConfiguratorHelical(WriterConfigurator):
-    def _get_initial_writer_kwarg(self):
-        if self.file_format in ["tif", "tiff"]:
-            return {"heights_above_stage_mm": self.heights_above_stage_mm}
-        else:
-            return {}
-
-    def __init__(
-        self,
-        output_dir,
-        file_prefix,
-        file_format="hdf5",
-        overwrite=False,
-        start_index=None,
-        logger=None,
-        nx_info=None,
-        write_histogram=False,
-        histogram_entry="entry",
-        writer_options=None,
-        extra_options=None,
-        heights_above_stage_mm=None,
-    ):
-        self.heights_above_stage_mm = heights_above_stage_mm
-        self.file_format = file_format
-        super().__init__(
-            output_dir,
-            file_prefix,
-            file_format=file_format,
-            overwrite=overwrite,
-            start_index=start_index,
-            logger=logger,
-            nx_info=nx_info,
-            write_histogram=write_histogram,
-            histogram_entry=histogram_entry,
-            writer_options=writer_options,
-            extra_options=extra_options,
-        )

nabu/pipeline/tests/test_chunk_reader.py

@@ -1,74 +0,0 @@
-import numpy as np
-import pytest
-from nabu.io.utils import get_compacted_dataslices
-from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer
-from nabu.testutils import compare_arrays, __do_long_tests__, get_file
-from nabu.io.reader import ChunkReader
-
-
-@pytest.fixture(scope="class")
-def bootstrap(request):
-    cls = request.cls
-
-    cls.dataset_fname = get_file("bamboo_reduced.nx")
-    cls.tol = 1e-7
-
-
-def get_compacted_dataslices_as_sorted_tuples(reader):
-    slice_to_tuple = lambda s: (s.start, s.stop, s.step)
-    data_slices_tuples = list(
-        set(
-            [
-                slice_to_tuple(u.data_slice())
-                for u in get_compacted_dataslices(
-                    reader.files, subsampling=reader.dataset_subsampling, begin=reader._files_begin_idx
-                ).values()
-            ]
-        )
-    )
-    return sorted(data_slices_tuples, key=lambda t: t[0])
-
-
-@pytest.mark.skipif(not (__do_long_tests__), reason="Use __do_long_tests__ for this test")
-@pytest.mark.usefixtures("bootstrap")
-class TestChunkReader:
-    def test_subsampling(self):
-        """
-        Test reading data from even/odd projections
-        """
-        dataset_info = HDF5DatasetAnalyzer(self.dataset_fname)
-
-        # Read all projections, then only even-numbered ones, then odd-numbered ones
-        # Use the same object to hopefully use less memory (through garbage collection)
-        reader = ChunkReader(dataset_info.projections, dataset_subsampling=None)
-        reader.load_data()
-        first_sino_all = reader.data[:, 0, :].copy()
-        compacted_dataslices_all = get_compacted_dataslices_as_sorted_tuples(reader)
-
-        reader = ChunkReader(dataset_info.projections, dataset_subsampling=(2, 0))
-        reader.load_data()
-        first_sino_even = reader.data[:, 0, :].copy()
-        compacted_dataslices_even = get_compacted_dataslices_as_sorted_tuples(reader)
-
-        reader = ChunkReader(dataset_info.projections, dataset_subsampling=(2, 1))
-        reader.load_data()
-        first_sino_odd = reader.data[:, 0, :].copy()
-        compacted_dataslices_odd = get_compacted_dataslices_as_sorted_tuples(reader)
-
-        # Check that the compacted data slices are correct
-        assert len(compacted_dataslices_all) == len(compacted_dataslices_even) == len(compacted_dataslices_odd)
-        for data_slice_all, data_slice_even, data_slice_odd in zip(
-            compacted_dataslices_all, compacted_dataslices_even, compacted_dataslices_odd
-        ):
-            indices_all = np.arange(100000)[slice(*data_slice_all)]
-            indices_even = np.arange(100000)[slice(*data_slice_even)]
-            indices_odd = np.arange(100000)[slice(*data_slice_odd)]
-            assert indices_all[::2].size == indices_even.size
-            assert np.allclose(indices_all[::2], indices_even)
-            assert indices_all[1::2].size == indices_odd.size
-            assert np.allclose(indices_all[1::2], indices_odd)
-
-        is_close, max_err = compare_arrays(first_sino_all[::2, :], first_sino_even, self.tol, return_residual=True)
-        assert is_close, "ChunkReader: something wrong when subsampling for even projections. max_err=%.3e" % max_err
-        is_close, max_err = compare_arrays(first_sino_all[1::2, :], first_sino_odd, self.tol, return_residual=True)
-        assert is_close, "ChunkReader: something wrong when subsampling for odd projections. max_err=%.3e" % max_err