nabu 2024.1.0rc4__py3-none-any.whl → 2024.1.1__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/stitching/tests/test_frame_composition.py

@@ -0,0 +1,180 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+
+__authors__ = ["H. Payno"]
+__license__ = "MIT"
+__date__ = "17/05/2022"
+
+
+import pytest
+from nabu.stitching.frame_composition import ZFrameComposition
+import numpy
+
+from nabu.stitching.overlap import OverlapStitchingStrategy, ZStichOverlapKernel
+
+
+def test_frame_composition():
+    """
+    Test _ZFrameComposition
+    """
+    frame_0 = numpy.zeros((100, 1))
+    frame_1 = numpy.ones((98, 1))
+    frame_2 = numpy.ones((205, 1)) * 2.0
+
+    frames = (frame_0, frame_1, frame_2)
+
+    y_shifts = -20, -10
+
+    kernels = [
+        ZStichOverlapKernel(
+            frame_width=1,
+            stitching_strategy=OverlapStitchingStrategy.LINEAR_WEIGHTS,
+            overlap_size=4,
+        ),
+        ZStichOverlapKernel(
+            frame_width=1,
+            stitching_strategy=OverlapStitchingStrategy.MEAN,
+            overlap_size=8,
+        ),
+    ]
+    # check raw composition
+    raw_composition = ZFrameComposition.compute_raw_frame_compositions(
+        frames=frames,
+        key_lines=(
+            (90, 10),
+            (98 - 5, 5),
+        ),
+        overlap_kernels=kernels,
+        stitching_axis=0,
+    )
+    assert isinstance(raw_composition, ZFrameComposition)
+
+    assert raw_composition.local_start_y == (0, 12, 9)
+    assert raw_composition.local_end_y == (88, 89, 205)
+    assert raw_composition.global_start_y == (0, 92, 177)
+    assert raw_composition.global_end_y == (88, 169, 373)
+
+    stitched_data = numpy.empty((100 + 98 + 205 - 30, 1))
+    raw_composition.compose(output_frame=stitched_data, input_frames=frames)
+    assert stitched_data[0, 0] == 0
+    assert stitched_data[150, 0] == 1.0
+    assert stitched_data[-1, 0] == 2.0
+
+    # check stitch composition
+    stitch_composition = ZFrameComposition.compute_stitch_frame_composition(
+        frames=frames,
+        key_lines=(
+            (90, 10),
+            (98 - 5, 5),
+        ),
+        overlap_kernels=kernels,
+        stitching_axis=0,
+    )
+
+    ZFrameComposition.pprint_z_stitching(raw_composition, stitch_composition)
+
+    assert stitch_composition.local_start_y == (0, 0)
+    assert stitch_composition.local_end_y == (4, 8)
+    assert stitch_composition.global_start_y == (88, 169)
+    assert stitch_composition.global_end_y == (92, 177)
+
+    stitched_frames = []
+    for frame_0, frame_1, kernel, y_shift in zip(frames[:-1], frames[1:], kernels, y_shifts):
+        # take frames once shifted
+        frame_0_overlap = frame_0[y_shift:]
+        frame_1_overlap = frame_1[:-y_shift]
+        # select the overlap area
+        frame_0_overlap = frame_0[-kernel.overlap_size :]
+        frame_1_overlap = frame_1[: kernel.overlap_size]
+
+        stitched_frames.append(kernel.stitch(frame_0_overlap, frame_1_overlap)[0])
+
+    stitch_composition.compose(
+        output_frame=stitched_data,
+        input_frames=stitched_frames,
+    )
+    assert 0.0 < stitched_data[90, 0] < 1.0
+    assert 1.0 < stitched_data[172, 0] < 2.0
+
+
+_raw_comp_config = (
+    {
+        "key_lines": (
+            (17, 2),
+            (36, 3),
+        ),
+        "raw_global_start": (0, 19, 53),
+        "raw_global_end": (16, 49, 68),
+        "raw_local_start": (0, 4, 5),
+        "raw_local_end": (16, 34, 20),
+        "kernels": (
+            ZStichOverlapKernel(
+                frame_width=1,
+                stitching_strategy=OverlapStitchingStrategy.LINEAR_WEIGHTS,
+                overlap_size=3,
+            ),
+            ZStichOverlapKernel(
+                frame_width=1,
+                stitching_strategy=OverlapStitchingStrategy.MEAN,
+                overlap_size=4,
+            ),
+        ),
+    },
+)
+
+
+@pytest.mark.parametrize("configuration", _raw_comp_config)
+def test_raw_frame_composition_exotic_config(configuration):
+    """
+    Test some
+    """
+    frame_0 = numpy.zeros((20, 1))
+    frame_1 = numpy.ones((40, 1))
+    frame_2 = numpy.ones((20, 1)) * 2.0
+
+    frames = (frame_0, frame_1, frame_2)
+
+    key_lines = configuration.get("key_lines")
+    kernels = configuration.get("kernels")
+    # check raw composition
+    raw_composition = ZFrameComposition.compute_raw_frame_compositions(
+        frames=frames,
+        overlap_kernels=kernels,
+        key_lines=key_lines,
+        stitching_axis=0,
+    )
+
+    assert raw_composition.global_start_y == configuration.get("raw_global_start")
+    assert raw_composition.global_end_y == configuration.get("raw_global_end")
+    assert raw_composition.local_start_y == configuration.get("raw_local_start")
+    assert raw_composition.local_end_y == configuration.get("raw_local_end")
+
+    stitched_data = numpy.empty(
+        (
+            (raw_composition.global_end_y[-1] - raw_composition.global_start_y[0]),
+            1,
+        )
+    )
+    raw_composition.compose(output_frame=stitched_data, input_frames=frames)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/stitching/tests/test_overlap.py

@@ -0,0 +1,98 @@
+import numpy
+import pytest
+
+from nabu.stitching.overlap import compute_image_minimum_divergence, compute_image_higher_signal, check_overlaps
+from nabu.testutils import get_data
+
+
+def test_compute_image_minimum_divergence():
+    """make sure the compute_image_minimum_divergence function is processing"""
+    raw_data_1 = get_data("brain_phantom.npz")["data"]
+    raw_data_2 = numpy.random.rand(*raw_data_1.shape) * 255.0
+
+    stitching = compute_image_minimum_divergence(raw_data_1, raw_data_2, high_frequency_threshold=2)
+    assert stitching.shape == raw_data_1.shape
+
+
+def test_compute_image_higher_signal():
+    """
+    make sure compute_image_higher_signal is processing
+    """
+    raw_data = get_data("brain_phantom.npz")["data"]
+    raw_data_1 = raw_data.copy()
+    raw_data_1[40:75] = 0.0
+    raw_data_1[:, 210:245] = 0.0
+
+    raw_data_2 = raw_data.copy()
+    raw_data_2[:, 100:120] = 0.0
+
+    stitching = compute_image_higher_signal(raw_data_1, raw_data_2)
+
+    numpy.testing.assert_array_equal(
+        stitching,
+        raw_data,
+    )
+
+
+def test_check_overlaps():
+    """test 'check_overlaps' function"""
+
+    # two frames, ordered and with an overlap
+    check_overlaps(
+        frames=(
+            numpy.ones(10),
+            numpy.ones(20),
+        ),
+        positions=((10,), (0,)),
+        axis=0,
+        raise_error=True,
+    )
+
+    # two frames, ordered and without an overlap
+    with pytest.raises(ValueError):
+        check_overlaps(
+            frames=(
+                numpy.ones(10),
+                numpy.ones(20),
+            ),
+            positions=((0,), (100,)),
+            axis=0,
+            raise_error=True,
+        )
+
+    # two frames, frame 0 fully overlap frame 1
+    with pytest.raises(ValueError):
+        check_overlaps(
+            frames=(
+                numpy.ones(20),
+                numpy.ones(10),
+            ),
+            positions=((8,), (5,)),
+            axis=0,
+            raise_error=True,
+        )
+
+    # three frames 'overlaping' as expected
+    check_overlaps(
+        frames=(
+            numpy.ones(10),
+            numpy.ones(20),
+            numpy.ones(10),
+        ),
+        positions=((20,), (10,), (0,)),
+        axis=0,
+        raise_error=True,
+    )
+
+    # three frames: frame 0 overlap frame 1 but also frame 2
+    with pytest.raises(ValueError):
+        check_overlaps(
+            frames=(
+                numpy.ones(20),
+                numpy.ones(10),
+                numpy.ones(10),
+            ),
+            positions=((20,), (15,), (11,)),
+            axis=0,
+            raise_error=True,
+        )

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/stitching/tests/test_sample_normalization.py

@@ -0,0 +1,49 @@
+import numpy
+import pytest
+from nabu.stitching.sample_normalization import normalize_frame, SampleSide, Method
+
+
+def test_normalize_frame():
+    """
+    test normalize_frame function
+    """
+    with pytest.raises(TypeError):
+        normalize_frame("toto", "left", "median")
+    with pytest.raises(TypeError):
+        normalize_frame(numpy.linspace(0, 100), "left", "median")
+
+    frame = numpy.ones((10, 40))
+    frame[:, 15:25] = numpy.arange(1, 101, step=1).reshape((10, 10))
+
+    numpy.testing.assert_array_equal(
+        normalize_frame(
+            frame=frame,
+            side="left",
+            method="mean",
+            sample_width=10,
+            margin_before_sample=2,
+        )[:, 15:25],
+        numpy.arange(0, 100, step=1).reshape((10, 10)),
+    )
+
+    numpy.testing.assert_array_equal(
+        normalize_frame(
+            frame=frame,
+            side="right",
+            method="median",
+            sample_width=10,
+            margin_before_sample=2,
+        )[:, 15:25],
+        numpy.arange(0, 100, step=1).reshape((10, 10)),
+    )
+
+    assert not numpy.array_equal(
+        normalize_frame(
+            frame=frame,
+            side="right",
+            method="mean",
+            sample_width=10,
+            margin_before_sample=20,
+        )[:, 15:25],
+        numpy.arange(0, 100, step=1).reshape((10, 10)),
+    )

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/stitching/tests/test_slurm_utils.py

@@ -0,0 +1,146 @@
+import os
+import numpy
+import pytest
+from tomoscan.esrf import NXtomoScan
+from tomoscan.esrf.volume import HDF5Volume
+from tomoscan.esrf.scan.utils import cwd_context
+from nabu.stitching.config import PreProcessedZStitchingConfiguration, SlurmConfig
+from nabu.stitching.overlap import OverlapStitchingStrategy
+from nabu.stitching.slurm_utils import (
+    split_slices,
+    get_working_directory,
+    split_stitching_configuration_to_slurm_job,
+)
+from tomoscan.esrf.mock import MockNXtomo
+
+try:
+    import sluurp
+except ImportError:
+    has_sluurp = False
+else:
+    has_sluurp = True
+
+
+def test_split_slices():
+    """test split_slices function"""
+    assert tuple(split_slices(slice(0, 100, 1), n_parts=4)) == (
+        slice(0, 25, 1),
+        slice(25, 50, 1),
+        slice(50, 75, 1),
+        slice(75, 100, 1),
+    )
+
+    assert tuple(split_slices(slice(0, 50, 2), n_parts=3)) == (
+        slice(0, 17, 2),
+        slice(17, 34, 2),
+        slice(34, 50, 2),
+    )
+
+    assert tuple(split_slices(slice(0, 100, 1), n_parts=1)) == (slice(0, 100, 1),)
+
+    assert tuple(split_slices(("first", "middle", "last"), 2)) == (
+        ("first", "middle"),
+        ("last",),
+    )
+    assert tuple(
+        split_slices(
+            (
+                10,
+                12,
+                13,
+            ),
+            4,
+        )
+    ) == ((10,), (12,), (13,))
+
+    with pytest.raises(TypeError):
+        next(split_slices("dsad", 12))
+
+
+def test_get_working_directory():
+    """test get_working_directory function"""
+    assert get_working_directory(NXtomoScan("/this/is/my/hdf5file.hdf5", "entry")) == "/this/is/my"
+    assert get_working_directory(HDF5Volume("/this/is/my/volume.hdf5", "entry")) == "/this/is/my"
+
+
+@pytest.mark.skipif(not has_sluurp, reason="sluurp not installed")
+def test_split_stitching_configuration_to_slurm_job(tmp_path):
+    """
+    test split_stitching_configuration_to_slurm_job behavior
+
+    This test is stitching two existing NXtomo (scan1 and scan2 contained in inputs_dir) and create a final_nx_tomo.nx to the output_dir
+
+    The stitching will be split in two slurm jobs.
+    One will create output_dir/final_nx_tomo/final_nx_tomo_part_0.nx and the second output_dir/final_nx_tomo/final_nx_tomo_part_1.nx
+    then the concatenation (not tested here) will create a output_dir/final_nx_tomo.nx redirecting to the sub parts
+
+    This test only focus on checking each sub configuration is as expected
+    """
+
+    inputs_dir = tmp_path / "inputs"
+    inputs_dir.mkdir()
+    output_dir = tmp_path / "outputs"
+    output_dir.mkdir()
+
+    with cwd_context(inputs_dir):
+        # the current working directory context help to check file path are moved to absolute.
+        # which is important because those jobs will be launched on slurm
+        scan_1 = MockNXtomo(
+            os.path.join("scan_1"),
+            n_proj=10,
+            n_ini_proj=10,
+            dim=100,
+        ).scan
+
+        scan_2 = MockNXtomo(
+            os.path.join("scan_2"),
+            n_proj=10,
+            n_ini_proj=10,
+            dim=100,
+        ).scan
+
+        n_jobs = 2
+
+        raw_config = PreProcessedZStitchingConfiguration(
+            axis_0_pos_px=None,
+            axis_0_pos_mm=None,
+            axis_0_params={},
+            axis_1_pos_px=None,
+            axis_1_pos_mm=None,
+            axis_1_params={},
+            axis_2_pos_px=None,
+            axis_2_pos_mm=None,
+            axis_2_params={},
+            stitching_strategy=OverlapStitchingStrategy.MEAN,
+            overwrite_results=True,
+            slurm_config=SlurmConfig(
+                partition="par-test",
+                mem="45G",
+                n_jobs=n_jobs,
+                other_options="",
+                preprocessing_command="source /my/venv",
+                clean_script=True,
+            ),
+            slices=slice(0, 120, 1),
+            input_scans=(scan_1, scan_2),
+            output_file_path=os.path.join("../outputs/", "final_nx_tomo.nx"),
+            output_data_path="stitched_entry",
+            output_nexus_version=None,
+            slice_for_cross_correlation="middle",
+            pixel_size=None,
+        )
+
+        sbatch_script_jobs = []
+        stitching_configurations = []
+        for job, configuration in split_stitching_configuration_to_slurm_job(raw_config, yield_configuration=True):
+            sbatch_script_jobs.append(job)
+            stitching_configurations.append(configuration)
+
+        assert len(stitching_configurations) == n_jobs == len(sbatch_script_jobs)
+        for i_sub_config, sub_config in enumerate(stitching_configurations):
+            assert isinstance(sub_config, type(raw_config))
+            assert sub_config.slurm_config is None
+            assert sub_config.output_file_path == os.path.join(
+                output_dir, "final_nx_tomo", f"final_nx_tomo_part_{i_sub_config}.nx"
+            )
+        assert raw_config.output_file_path == os.path.join(output_dir, "final_nx_tomo.nx")

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/stitching/tests/test_utils.py

@@ -0,0 +1,21 @@
+from nabu.stitching.utils import has_itk, find_shift_with_itk
+from scipy.ndimage import shift as shift_scipy
+import numpy
+import pytest
+from nabu.testutils import get_data
+
+
+@pytest.mark.parametrize("data_type", (numpy.float32, numpy.uint16))
+@pytest.mark.skipif(not has_itk, reason="itk not installed")
+def test_find_shift_with_itk(data_type):
+    shift = (5, 2)
+    img1 = get_data("chelsea.npz")["data"].astype(data_type)
+    img2 = shift_scipy(
+        img1.copy(),
+        shift=shift,
+        order=1,
+    )
+
+    img1 = img1[10:-10, 10:-10]
+    img2 = img2[10:-10, 10:-10]
+    assert find_shift_with_itk(img1=img1, img2=img2) == shift