dcnum 0.11.4__py3-none-any.whl → 0.11.5__py3-none-any.whl

tests/test_feat_haralick.py

@@ -1,120 +0,0 @@
-import pathlib
-
-import h5py
-import numpy as np
-
-from dcnum.feat import feat_texture
-
-from helper_methods import retrieve_data
-
-data_path = pathlib.Path(__file__).parent / "data"
-
-
-def test_basic_haralick():
-    # This original file was generated with dcevent for reference.
-    path = retrieve_data(data_path /
-                         "fmt-hdf5_cytoshot_full-features_2023.zip")
-    # Make data available
-    with h5py.File(path) as h5:
-        ret_arr = feat_texture.haralick_texture_features(
-            image=h5["events/image"][:],
-            image_bg=h5["events/image_bg"][:],
-            mask=h5["events/mask"][:],
-        )
-
-        assert np.allclose(ret_arr["tex_asm_avg"][1],
-                           0.001514295993357114,
-                           atol=0, rtol=1e-10)
-        for feat in feat_texture.haralick_names:
-            assert np.allclose(h5["events"][feat],
-                               ret_arr[feat])
-        # control test
-        assert not np.allclose(h5["events"]["tex_asm_avg"],
-                               ret_arr["tex_asm_ptp"])
-
-
-def test_empty_image():
-    masks = np.array([
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 1, 1, 0, 0],
-        [0, 0, 1, 1, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-    ], dtype=bool)[np.newaxis]
-    image_corr = np.zeros(6*6, dtype=np.int16).reshape(1, 6, 6)
-    tex = feat_texture.haralick_texture_features(
-        image_corr=image_corr,
-        mask=masks,
-    )
-    assert np.allclose(tex["tex_con_avg"][0], 0)
-
-
-def test_empty_mask():
-    masks = np.array([
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-    ], dtype=bool)[np.newaxis]
-    image_corr = np.arange(6*6, dtype=np.int16).reshape(1, 6, 6)
-    tex = feat_texture.haralick_texture_features(
-        image_corr=image_corr,
-        mask=masks,
-    )
-    assert np.isnan(tex["tex_con_avg"][0])
-
-
-def test_1d_mask_image():
-    masks = np.array([
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 1, 0, 0, 0],
-        [0, 0, 1, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-    ], dtype=bool)[np.newaxis]
-    image_corr = np.arange(6*6, dtype=np.int16).reshape(1, 6, 6)
-    tex = feat_texture.haralick_texture_features(
-        image_corr=image_corr,
-        mask=masks,
-    )
-    assert np.isnan(tex["tex_con_avg"][0])
-
-
-def test_nd_mask_with_1d_image():
-    mask = np.array([
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 1, 1, 0, 0],
-        [0, 0, 1, 1, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-    ], dtype=bool)
-    masks = np.stack([mask, mask, mask, mask])
-    image_corr = np.arange(6*6, dtype=np.int16).reshape(1, 6, 6)
-    tex = feat_texture.haralick_texture_features(
-        image_corr=image_corr,
-        mask=masks,
-    )
-    assert len(tex["tex_con_avg"]) == 4
-    assert np.allclose(tex["tex_con_avg"][0], 27.75)
-
-
-def test_simple_mask_image():
-    masks = np.array([
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 1, 1, 0, 0],
-        [0, 0, 1, 1, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-    ], dtype=bool)[np.newaxis]
-    image_corr = np.arange(6*6, dtype=np.int16).reshape(1, 6, 6)
-    tex = feat_texture.haralick_texture_features(
-        image_corr=image_corr,
-        mask=masks,
-    )
-    assert np.allclose(tex["tex_con_avg"][0], 27.75)

tests/test_feat_moments_based.py

@@ -1,108 +0,0 @@
-import pathlib
-
-import h5py
-import numpy as np
-
-from dcnum.feat import feat_moments
-
-from helper_methods import retrieve_data
-
-data_path = pathlib.Path(__file__).parent / "data"
-
-
-def test_moments_based_features():
-    # This original file was generated with dcevent for reference.
-    path = retrieve_data(data_path /
-                         "fmt-hdf5_cytoshot_full-features_2023.zip")
-    feats = [
-        "deform",
-        "size_x",
-        "size_y",
-        "pos_x",
-        "pos_y",
-        "area_msd",
-        "area_ratio",
-        "area_um",
-        "aspect",
-        "tilt",
-        "inert_ratio_cvx",
-        "inert_ratio_raw",
-        "inert_ratio_prnc",
-    ]
-
-    # Make data available
-    with h5py.File(path) as h5:
-        data = feat_moments.moments_based_features(
-            mask=h5["events/mask"][:],
-            pixel_size=0.2645
-        )
-        for feat in feats:
-            if feat.count("inert"):
-                rtol = 2e-5
-                atol = 1e-8
-            else:
-                rtol = 1e-5
-                atol = 1e-8
-            assert np.allclose(h5["events"][feat][:],
-                               data[feat],
-                               rtol=rtol,
-                               atol=atol), f"Feature {feat} mismatch!"
-        # control test
-        assert not np.allclose(h5["events"]["inert_ratio_cvx"][:],
-                               data["tilt"])
-
-
-def test_mask_0d():
-    masks = np.array([
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 1, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-    ], dtype=bool)[np.newaxis]
-    data = feat_moments.moments_based_features(
-                mask=masks,
-                pixel_size=0.2645
-            )
-    assert data["deform"].shape == (1,)
-    assert np.isnan(data["deform"][0])
-    assert np.isnan(data["area_um"][0])
-
-
-def test_mask_1d():
-    masks = np.array([
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 1, 0, 0, 0],
-        [0, 0, 1, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-    ], dtype=bool)[np.newaxis]
-    data = feat_moments.moments_based_features(
-                mask=masks,
-                pixel_size=0.2645
-            )
-    assert data["deform"].shape == (1,)
-    assert np.isnan(data["deform"][0])
-    assert np.isnan(data["area_um"][0])
-
-
-def test_mask_2d():
-    masks = np.array([
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 1, 1, 0, 0],
-        [0, 0, 1, 1, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0],
-    ], dtype=bool)[np.newaxis]
-    data = feat_moments.moments_based_features(
-                mask=masks,
-                pixel_size=0.2645
-            )
-    assert data["deform"].shape == (1,)
-    # This is the deformation of a square (compared to circle)
-    assert np.allclose(data["deform"][0], 0.11377307454724206)
-    # Without moments-based computation, this would be 4*pxsize=0.066125
-    assert np.allclose(data["area_um"][0], 0.06996025)

tests/test_init.py

@@ -1,5 +0,0 @@
-import dcnum
-
-
-def test_init():
-    assert hasattr(dcnum, "__version__")

tests/test_ppid.py

@@ -1,94 +0,0 @@
-import inspect
-
-import pytest
-
-from dcnum.meta import ppid
-
-
-class ExampleClass:
-    def cook(self, *,
-             temperature: float = 90.0,
-             te: str = "a",
-             outside: bool = False,
-             with_water: bool = True,
-             amount: int = 1000,
-             wine_type: str = "red",
-             test_oven: bool = True):
-        return id(self)
-
-    @classmethod
-    def key(cls):
-        return cls.__name__
-
-
-@pytest.mark.parametrize("in_list,out_list", [
-    (["camera", "campus"],
-     ["came", "camp"]),
-    (["cole", "coleman"],
-     ["cole", "colem"]),
-    (["cole", "coleman", "colemine"],
-     ["cole", "colema", "colemi"]),
-    (["cole", "coleman", "cundis"],
-     ["cole", "colem", "cu"]),
-    (["an", "and", "anderson", "andersrum", "ant"],
-     ["an", "and", "anderso", "andersr", "ant"]),
-])
-def test_unique_prefix_ordered(in_list, out_list):
-    t_list = ppid.get_unique_prefix(in_list)
-    assert t_list == out_list
-
-
-@pytest.mark.parametrize("in_list,out_list", [
-    (["campus", "camera"],
-     ["camp", "came"]),
-    (["coleman", "cole"],
-     ["colem", "cole"]),
-    (["coleman", "cole", "colemine"],
-     ["colema", "cole", "colemi"]),
-    (["cole", "cundis", "coleman"],
-     ["cole", "cu", "colem"]),
-    (["an", "andersrum", "and", "anderson", "ant"],
-     ["an", "andersr", "and", "anderso", "ant"]),
-])
-def test_unique_prefix_unordered(in_list, out_list):
-    t_list = ppid.get_unique_prefix(in_list)
-    assert t_list == out_list
-
-
-@pytest.mark.parametrize("kwargs, pid", [
-    ({},
-     "tem=90^te=a^o=0^wit=1^a=1000^win=red^tes=1"),
-    ({"temperature": 10.1},
-     "tem=10.1^te=a^o=0^wit=1^a=1000^win=red^tes=1"),
-    ({"with_water": False, "wine_type": "blue"},
-     "tem=90^te=a^o=0^wit=0^a=1000^win=blue^tes=1"),
-])
-def test_kwargs_to_ppid(kwargs, pid):
-    ptest = ppid.kwargs_to_ppid(ExampleClass, "cook", kwargs)
-    assert pid == ptest
-
-
-@pytest.mark.parametrize("kwargs, pid", [
-    ({},
-     "tem=90^te=a^o=0^wit=1^a=1000^win=red^tes=1"),
-    ({"temperature": 10.1},
-     "tem=10.1^te=a^o=0^wit=1^a=1000^win=red^tes=1"),
-    ({"with_water": False, "wine_type": "blue"},
-     "tem=90^te=a^o=0^wit=0^a=1000^win=blue^tes=1"),
-    ({},
-     "te=a^tem=90^o=0^wit=1^a=1000^win=red^tes=1"),  # switch order (evil!)
-    ({},
-     "tem=90^te=a^o=0^wit=1^a=1000^win=red"),  # remove things
-    ({},
-     "tem=90^te=a^o=0^w=1^a=1000"),  # remove more things!
-])
-def test_ppid_to_kwargs(kwargs, pid):
-    # get the default keyword arguments
-    meth = getattr(ExampleClass, "cook")
-    spec = inspect.getfullargspec(meth)
-    kwargs_full = spec.kwonlydefaults
-    # update with given kwargs
-    kwargs_full.update(kwargs)
-
-    kwargs_test = ppid.ppid_to_kwargs(ExampleClass, "cook", pid)
-    assert kwargs_test == kwargs_full

tests/test_ppid_segm.py

@@ -1,8 +0,0 @@
-from dcnum import segm
-
-
-def test_ppid_segm_base_with_thresh():
-    scls = segm.get_available_segmenters()["thresh"]
-    sthr = scls(thresh=-3)
-    assert sthr.key() == "thresh"
-    assert sthr.get_ppid() == "thresh:t=-3:cle=1^f=1^clo=2"

tests/test_read_concat_hdf5.py

@@ -1,54 +0,0 @@
-import pathlib
-
-from dcnum import read
-import h5py
-import numpy as np
-import pytest
-
-from helper_methods import retrieve_data
-
-data_path = pathlib.Path(__file__).parent / "data"
-
-
-@pytest.mark.parametrize("path_out", [None, True])
-def test_concat_basic(path_out):
-    path = retrieve_data(data_path /
-                         "fmt-hdf5_cytoshot_full-features_2023.zip")
-    # create simple concatenated dataset, repeating a file
-    data = read.concatenated_hdf5_data([path, path, path],
-                                       path_out=path_out)
-    assert len(data) == 120
-
-
-@pytest.mark.parametrize("path_out", [None, True])
-def test_concat_basic_frame(path_out):
-    path = retrieve_data(data_path /
-                         "fmt-hdf5_cytoshot_full-features_2023.zip")
-    # create simple concatenated dataset, repeating a file
-    data = read.concatenated_hdf5_data([path, path, path],
-                                       path_out=path_out)
-    with h5py.File(path) as h5:
-        frame = h5["events/frame"][:]
-    assert frame[0] == 101
-
-    assert np.allclose(data["frame"][:frame.size],
-                       frame - 101 + 1)
-    offset1 = frame[-1] - 101 + 1
-    assert np.allclose(offset1, data["frame"][frame.size-1])
-    assert np.allclose(offset1 + 1, data["frame"][frame.size])
-    assert np.allclose(data["frame"][frame.size:2*frame.size],
-                       frame - 101 + offset1 + 1)
-    diff = frame[-1] - frame[0]
-    assert np.allclose(data["frame"][-1], 3 * (diff + 1))
-
-
-def test_concat_basic_to_file(tmp_path):
-    path = retrieve_data(data_path /
-                         "fmt-hdf5_cytoshot_full-features_2023.zip")
-    # create simple concatenated dataset, repeating a file
-    path_out = tmp_path / "test.rtdc"
-    assert not path_out.exists()
-    data = read.concatenated_hdf5_data([path, path, path],
-                                       path_out=path_out)
-    assert len(data) == 120
-    assert path_out.exists()

tests/test_read_hdf5.py

@@ -1,196 +0,0 @@
-import pathlib
-import pickle
-
-import h5py
-import numpy as np
-import pytest
-
-from dcnum import read
-
-from helper_methods import retrieve_data
-
-data_path = pathlib.Path(__file__).parent / "data"
-
-
-def test_image_cache(tmp_path):
-    path = tmp_path / "test.hdf5"
-    with h5py.File(path, "w") as hw:
-        hw["events/image"] = np.random.rand(210, 80, 180)
-
-    with h5py.File(path, "r") as h5:
-        hic = read.HDF5ImageCache(h5["events/image"],
-                                  chunk_size=100,
-                                  cache_size=2)
-
-        # Get something from the first chunk
-        assert np.allclose(hic[10], h5["events/image"][10])
-        assert len(hic.cache) == 1
-        assert 0 in hic.cache
-
-        # Get something from the last chunk
-        assert np.allclose(hic[205], h5["events/image"][205])
-        assert len(hic.cache) == 2
-        assert 0 in hic.cache
-        assert 2 in hic.cache
-        assert np.allclose(hic.cache[2], h5["events/image"][200:])
-
-        # Get something from the first chunk again
-        assert np.allclose(hic[90], h5["events/image"][90])
-        assert len(hic.cache) == 2
-        assert 0 in hic.cache
-        assert 2 in hic.cache
-
-        # Get something from the middle chunk
-        assert np.allclose(hic[140], h5["events/image"][140])
-        assert len(hic.cache) == 2  # limited to two
-        assert 0 not in hic.cache  # first item gets removed
-        assert 1 in hic.cache
-        assert 2 in hic.cache
-
-
-def test_image_cache_index_out_of_range(tmp_path):
-    path = tmp_path / "test.hdf5"
-    size = 20
-    chunk_size = 8
-    with h5py.File(path, "w") as hw:
-        hw["events/image"] = np.random.rand(size, 80, 180)
-    with h5py.File(path, "r") as h5:
-        hic = read.HDF5ImageCache(h5["events/image"],
-                                  chunk_size=chunk_size,
-                                  cache_size=2)
-        # Get something from first chunk. This should just work
-        hic.__getitem__(10)
-        # Now test out-of-bounds error
-        with pytest.raises(IndexError, match="of bounds for HDF5ImageCache"):
-            hic.__getitem__(20)
-
-
-def test_image_chache_get_chunk_size(tmp_path):
-    path = tmp_path / "test.hdf5"
-    size = 20
-    chunk_size = 8
-    with h5py.File(path, "w") as hw:
-        hw["events/image"] = np.random.rand(size, 80, 180)
-    with h5py.File(path, "r") as h5:
-        hic = read.HDF5ImageCache(h5["events/image"],
-                                  chunk_size=chunk_size,
-                                  cache_size=2)
-        # Get something from first chunk. This should just work
-        assert hic.get_chunk_size(0) == 8
-        assert hic.get_chunk_size(1) == 8
-        assert hic.get_chunk_size(2) == 4
-        with pytest.raises(IndexError, match="only has 3 chunks"):
-            hic.get_chunk_size(3)
-
-
-@pytest.mark.parametrize("size, chunks", [(209, 21),
-                                          (210, 21),
-                                          (211, 22)])
-def test_image_cache_iter_chunks(size, chunks, tmp_path):
-    path = tmp_path / "test.hdf5"
-    with h5py.File(path, "w") as hw:
-        hw["events/image"] = np.random.rand(size, 80, 180)
-    with h5py.File(path, "r") as h5:
-        hic = read.HDF5ImageCache(h5["events/image"],
-                                  chunk_size=10,
-                                  cache_size=2)
-        assert list(hic.iter_chunks()) == list(range(chunks))
-
-
-def test_pixel_size_getset(tmp_path):
-    path = tmp_path / "test.hdf5"
-    with h5py.File(path, "w") as hw:
-        hw["events/image"] = np.random.rand(10, 80, 180)
-        hw.attrs["imaging:pixel size"] = 0.123
-
-    h5dat = read.HDF5Data(path)
-    assert np.allclose(h5dat.pixel_size, 0.123)
-    h5dat.pixel_size = 0.321
-    assert np.allclose(h5dat.pixel_size, 0.321)
-
-
-def test_open_real_data():
-    path = retrieve_data(data_path /
-                         "fmt-hdf5_cytoshot_full-features_2023.zip")
-    with read.HDF5Data(path) as h5dat:  # context manager
-        # properties
-        assert len(h5dat) == 40
-        assert h5dat.md5_5m == "599c8c7a112632d007be60b9c37961c5"
-
-        # scalar features
-        fsc = h5dat.features_scalar_frame
-        exp = ['bg_med', 'frame', 'time']
-        assert set(fsc) == set(exp)
-
-        # feature names
-        assert len(h5dat.keys()) == 48
-        assert "deform" in h5dat.keys()
-        assert "deform" in h5dat
-
-
-def test_pickling_state():
-    path = retrieve_data(data_path /
-                         "fmt-hdf5_cytoshot_full-features_2023.zip")
-
-    h5d1 = read.HDF5Data(path)
-    h5d1.pixel_size = 0.124
-    pstate = pickle.dumps(h5d1)
-    h5d2 = pickle.loads(pstate)
-    assert h5d1.md5_5m == h5d2.md5_5m
-    assert h5d1.md5_5m == h5d2.md5_5m
-    assert h5d1.pixel_size == h5d2.pixel_size
-    assert np.allclose(h5d2.pixel_size, 0.124)
-
-
-def test_pickling_state_logs():
-    path = retrieve_data(
-        data_path / "fmt-hdf5_cytoshot_full-features_legacy_allev_2023.zip")
-    h5d1 = read.HDF5Data(path)
-    h5d1.pixel_size = 0.124
-    pstate = pickle.dumps(h5d1)
-    h5d2 = pickle.loads(pstate)
-    assert h5d1.logs
-    for lk in h5d1.logs:
-        assert h5d1.logs[lk] == h5d2.logs[lk]
-
-
-def test_pickling_state_tables():
-    path = retrieve_data(
-        data_path / "fmt-hdf5_cytoshot_full-features_legacy_allev_2023.zip")
-    # The original file does not contain any tables, so we write
-    # generate a table
-    columns = ["alot", "of", "tables"]
-    ds_dt = np.dtype({'names': columns,
-                      'formats': [float] * len(columns)})
-    tab_data = np.zeros((11, len(columns)))
-    tab_data[:, 0] = np.arange(11)
-    tab_data[:, 1] = 1000
-    tab_data[:, 2] = np.linspace(1, np.sqrt(2), 11)
-    rec_arr = np.rec.array(tab_data, dtype=ds_dt)
-
-    # add table to source file
-    with h5py.File(path, "a") as h5:
-        h5tab = h5.require_group("tables")
-        h5tab.create_dataset(name="sample_table",
-                             data=rec_arr)
-
-    h5d1 = read.HDF5Data(path)
-    h5d1.pixel_size = 0.124
-    pstate = pickle.dumps(h5d1)
-    h5d2 = pickle.loads(pstate)
-    assert h5d1.tables
-    table = h5d1.tables["sample_table"]
-    assert len(table) == 3
-    for lk in table:
-        assert np.allclose(h5d1.tables["sample_table"][lk],
-                           h5d2.tables["sample_table"][lk])
-
-
-def test_read_empty_logs():
-    path = retrieve_data(
-        data_path / "fmt-hdf5_cytoshot_full-features_legacy_allev_2023.zip")
-    with h5py.File(path, "a") as h5:
-        h5.require_group("logs").create_dataset(name="empty_log",
-                                                data=[])
-    h5r = read.HDF5Data(path)
-    assert "empty_log" not in h5r.logs