nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

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

@@ -1,180 +0,0 @@
-# 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/build/lib/build/lib/nabu/stitching/tests/test_overlap.py

@@ -1,98 +0,0 @@
-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/build/lib/build/lib/nabu/stitching/tests/test_sample_normalization.py

@@ -1,49 +0,0 @@
-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/build/lib/build/lib/nabu/stitching/tests/test_slurm_utils.py

@@ -1,146 +0,0 @@
-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/build/lib/build/lib/nabu/stitching/tests/test_utils.py

@@ -1,21 +0,0 @@
-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