nimare 0.4.2__py3-none-any.whl

nimare/tests/test_utils.py

@@ -0,0 +1,200 @@
+"""Test nimare.utils."""
+
+import logging
+import os
+import os.path as op
+
+import nibabel as nib
+import numpy as np
+import pytest
+
+from nimare import utils
+from nimare.meta.utils import _apply_liberal_mask
+
+
+def test_find_stem():
+    """Test nimare.utils._find_stem."""
+    test_array = [
+        "/home/data/dataset/file1.nii.gz",
+        "/home/data/dataset/file2.nii.gz",
+        "/home/data/dataset/file3.nii.gz",
+        "/home/data/dataset/file4.nii.gz",
+        "/home/data/dataset/file5.nii.gz",
+    ]
+    stem = utils._find_stem(test_array)
+    assert stem == "/home/data/dataset/file"
+
+    test_array = [
+        "/home/data/dataset/subfolder1/file1.nii.gz",
+        "/home/data/dataset/subfolder1/file2.nii.gz",
+        "/home/data/dataset/subfolder2/file3.nii.gz",
+        "/home/data/dataset/subfolder2/file4.nii.gz",
+        "/home/data/dataset/subfolder3/file5.nii.gz",
+    ]
+    stem = utils._find_stem(test_array)
+    assert stem == "/home/data/dataset/subfolder"
+
+    test_array = [
+        "/home/data/file1_test-filename_test.nii.gz",
+        "/home/data/file2_test-filename_test.nii.gz",
+        "/home/data/file3_test-filename_test.nii.gz",
+        "/home/data/file4_test-filename_test.nii.gz",
+        "/home/data/file5_test-filename_test.nii.gz",
+    ]
+    stem = utils._find_stem(test_array)
+    assert stem == "/home/data/file"
+
+    test_array = [
+        "souse",
+        "youse",
+        "house",
+        "mouse",
+        "louse",
+    ]
+    stem = utils._find_stem(test_array)
+    assert stem == ""
+
+
+def test_get_template():
+    """Test nimare.utils.get_template."""
+    # 1mm template
+    img = utils.get_template(space="mni152_1mm", mask=None)
+    assert isinstance(img, nib.Nifti1Image)
+    assert not nib.is_proxy(img.dataobj)
+    img = utils.get_template(space="mni152_1mm", mask="brain")
+    assert isinstance(img, nib.Nifti1Image)
+
+    # 2mm template (default)
+    img = utils.get_template(space="mni152_2mm", mask=None)
+    assert isinstance(img, nib.Nifti1Image)
+    img = utils.get_template(space="mni152_2mm", mask="brain")
+    assert isinstance(img, nib.Nifti1Image)
+    assert not nib.is_proxy(img.dataobj)
+
+    # ALE template
+    img = utils.get_template(space="ale_2mm", mask=None)
+    assert isinstance(img, nib.Nifti1Image)
+    img = utils.get_template(space="ale_2mm", mask="brain")
+    assert isinstance(img, nib.Nifti1Image)
+    assert not nib.is_proxy(img.dataobj)
+
+    # Expect exceptions when incompatible spaces or masks are requested.
+    with pytest.raises(ValueError):
+        utils.get_template(space="something", mask=None)
+
+    with pytest.raises(ValueError):
+        utils.get_template(space="mni152_1mm", mask="gm")
+
+    with pytest.raises(ValueError):
+        utils.get_template(space="mni152_2mm", mask="gm")
+
+    with pytest.raises(ValueError):
+        utils.get_template(space="ale_2mm", mask="gm")
+
+
+def test_get_resource_path():
+    """Test nimare.utils.get_resource_path."""
+    print(utils.get_resource_path())
+    assert op.isdir(utils.get_resource_path())
+
+
+@pytest.mark.parametrize(
+    "has_low_memory,memory_limit",
+    [
+        (True, "1gb"),
+        (False, None),
+    ],
+)
+def test_use_memmap(caplog, has_low_memory, memory_limit):
+    """Test the memmapping decorator."""
+    LGR = logging.getLogger(__name__)
+
+    class DummyClass:
+        def __init__(self, has_low_memory, memory_limit):
+            self.has_low_memory = has_low_memory
+            self.memory_limit = memory_limit
+
+        @utils.use_memmap(LGR)
+        def test_decorator(self):
+            assert hasattr(self, "memmap_filenames")
+            if self.has_low_memory:
+                assert hasattr(self, "memory_limit")
+                if self.memory_limit:
+                    assert os.path.isfile(self.memmap_filenames[0])
+                else:
+                    assert self.memmap_filenames[0] is None
+            return self.memmap_filenames
+
+        @utils.use_memmap(LGR)
+        def bad_justin_timberlake(self):
+            raise ValueError("It's gonna be may!")
+
+    my_class = DummyClass(has_low_memory, memory_limit)
+
+    # make sure memmap file has been deleted
+    my_class.test_decorator()
+    first_memmap_filename = my_class.memmap_filenames[0]
+
+    # run bad function
+    with pytest.raises(ValueError):
+        my_class.bad_justin_timberlake()
+    assert "failed, removing" in caplog.text
+
+    if hasattr(my_class, "memory_limit") and my_class.memory_limit:
+        assert not os.path.isfile(first_memmap_filename)
+        assert not os.path.isfile(my_class.memmap_filenames[0])
+        # test when a function is called a new memmap file is created
+        assert first_memmap_filename != my_class.memmap_filenames[0]
+
+
+def test_tal2mni():
+    """TODO: Get converted coords from official site."""
+    test = np.array([[-44, 31, 27], [20, -32, 14], [28, -76, 28]])
+    true = np.array(
+        [
+            [-45.83997568, 35.97904559, 23.55194326],
+            [22.69248975, -31.34145016, 13.91284087],
+            [31.53113226, -76.61685748, 33.22105166],
+        ]
+    )
+    assert np.allclose(utils.tal2mni(test), true)
+
+
+def test_mni2tal():
+    """TODO: Get converted coords from official site."""
+    test = np.array([[-44, 31, 27], [20, -32, 14], [28, -76, 28]])
+    true = np.array(
+        [[-42.3176, 26.0594, 29.7364], [17.4781, -32.6076, 14.0009], [24.7353, -75.0184, 23.3283]]
+    )
+    assert np.allclose(utils.mni2tal(test), true)
+
+
+def test_vox2mm():
+    """Test vox2mm."""
+    test = np.array([[20, 20, 20], [0, 0, 0]])
+    true = np.array([[-50.0, -86.0, -32.0], [-90.0, -126.0, -72.0]])
+    img = utils.get_template(space="mni152_2mm", mask=None)
+    aff = img.affine
+    assert np.array_equal(utils.vox2mm(test, aff), true)
+
+
+def test_mm2vox():
+    """Test mm2vox."""
+    test = np.array([[20, 20, 20], [0, 0, 0]])
+    true = np.array([[55.0, 73.0, 46.0], [45.0, 63.0, 36.0]])
+    img = utils.get_template(space="mni152_2mm", mask=None)
+    aff = img.affine
+    assert np.array_equal(utils.mm2vox(test, aff), true)
+
+
+def test_apply_liberal_mask():
+    """Test _apply_liberal_mask."""
+    data = np.array([[1, 2, np.nan, np.nan], [4, np.nan, 6, 5], [0, 8, 9, 3]])
+    true_data = [np.array([[1], [4]]), np.array([[2], [8]]), np.array([[6, 5], [9, 3]])]
+
+    pred_data, _, _ = _apply_liberal_mask(data)
+
+    assert len(pred_data) == len(true_data)
+
+    for pred_val, true_val in zip(pred_data, true_data):
+        assert np.array_equal(pred_val, true_val)

nimare/tests/test_workflows.py

@@ -0,0 +1,221 @@
+"""Test nimare.workflows."""
+
+import os.path as op
+
+import nibabel as nib
+import numpy as np
+import pytest
+
+import nimare
+from nimare.correct import FWECorrector
+from nimare.diagnostics import FocusCounter, Jackknife
+from nimare.meta.cbma import ALE, ALESubtraction, MKDAChi2
+from nimare.meta.ibma import Fishers, PermutedOLS, Stouffers
+from nimare.workflows import (
+    CBMAWorkflow,
+    IBMAWorkflow,
+    PairwiseCBMAWorkflow,
+    conjunction_analysis,
+)
+
+
+@pytest.mark.parametrize(
+    "estimator,corrector,diagnostics",
+    [
+        (ALE, FWECorrector(method="montecarlo", n_iters=10), [Jackknife]),
+        ("ales", "bonferroni", Jackknife),
+        ("ale", "bonferroni", [Jackknife, FocusCounter]),
+        ("kda", "fdr", Jackknife),
+        ("mkdadensity", "fdr", "focuscounter"),
+        (MKDAChi2, "montecarlo", None),
+        (Fishers, "montecarlo", "jackknife"),
+    ],
+)
+def test_cbma_workflow_smoke(
+    tmp_path_factory,
+    testdata_cbma_full,
+    estimator,
+    corrector,
+    diagnostics,
+):
+    """Run smoke test for CBMA workflow."""
+    tmpdir = tmp_path_factory.mktemp("test_cbma_workflow_smoke")
+
+    if estimator == MKDAChi2:
+        with pytest.raises(AttributeError):
+            CBMAWorkflow(estimator=estimator, corrector=corrector, diagnostics=diagnostics)
+    elif estimator == Fishers:
+        with pytest.raises((AttributeError, ValueError)):
+            CBMAWorkflow(estimator=estimator, corrector=corrector, diagnostics=diagnostics)
+    elif estimator == "ales":
+        with pytest.raises(ValueError):
+            CBMAWorkflow(estimator=estimator, corrector=corrector, diagnostics=diagnostics)
+    else:
+        workflow = CBMAWorkflow(
+            estimator=estimator,
+            corrector=corrector,
+            diagnostics=diagnostics,
+            output_dir=tmpdir,
+        )
+        cres = workflow.fit(testdata_cbma_full)
+
+        assert isinstance(cres, nimare.results.MetaResult)
+        assert op.isfile(op.join(tmpdir, "boilerplate.txt"))
+        assert op.isfile(op.join(tmpdir, "references.bib"))
+
+        for imgtype in cres.maps.keys():
+            filename = f"{imgtype}.nii.gz"
+            outpath = op.join(tmpdir, filename)
+            # For ALE maps are None
+            if not cres.maps[imgtype] is None:
+                assert op.isfile(outpath)
+
+        for tabletype in cres.tables.keys():
+            filename = f"{tabletype}.tsv"
+            outpath = op.join(tmpdir, filename)
+            # For ALE tables are None
+            if not cres.tables[tabletype] is None:
+                assert op.isfile(outpath)
+
+
+@pytest.mark.parametrize(
+    "estimator,corrector,diagnostics",
+    [
+        (MKDAChi2, FWECorrector(method="montecarlo", n_iters=10), [FocusCounter]),
+        ("mkdachi", "bonferroni", FocusCounter),
+        ("mkdachi2", "bonferroni", "jackknife"),
+        (ALESubtraction(n_iters=10), "fdr", Jackknife(voxel_thresh=0.01)),
+        (ALE, "montecarlo", None),
+        (Fishers, "montecarlo", "jackknife"),
+    ],
+)
+def test_pairwise_cbma_workflow_smoke(
+    tmp_path_factory,
+    testdata_cbma_full,
+    estimator,
+    corrector,
+    diagnostics,
+):
+    """Run smoke test for CBMA workflow."""
+    tmpdir = tmp_path_factory.mktemp("test_pairwise_cbma_workflow_smoke")
+
+    dset1 = testdata_cbma_full.slice(testdata_cbma_full.ids[:10])
+    dset2 = testdata_cbma_full.slice(testdata_cbma_full.ids[10:])
+    if estimator in [ALE, "mkdachi"]:
+        with pytest.raises(ValueError):
+            PairwiseCBMAWorkflow(estimator=estimator, corrector=corrector, diagnostics=diagnostics)
+    elif estimator == Fishers:
+        with pytest.raises((AttributeError, ValueError)):
+            PairwiseCBMAWorkflow(estimator=estimator, corrector=corrector, diagnostics=diagnostics)
+    else:
+        workflow = PairwiseCBMAWorkflow(
+            estimator=estimator,
+            corrector=corrector,
+            diagnostics=diagnostics,
+            output_dir=tmpdir,
+        )
+        cres = workflow.fit(dset1, dset2)
+
+        assert isinstance(cres, nimare.results.MetaResult)
+        assert op.isfile(op.join(tmpdir, "boilerplate.txt"))
+        assert op.isfile(op.join(tmpdir, "references.bib"))
+
+        for imgtype in cres.maps.keys():
+            filename = f"{imgtype}.nii.gz"
+            outpath = op.join(tmpdir, filename)
+            # For MKDAChi2 maps are None
+            if cres.maps[imgtype] is not None:
+                assert op.isfile(outpath)
+
+        for tabletype in cres.tables.keys():
+            filename = f"{tabletype}.tsv"
+            outpath = op.join(tmpdir, filename)
+            # For MKDAChi2 tables are None
+            if cres.tables[tabletype] is not None:
+                assert op.isfile(outpath)
+
+
+@pytest.mark.parametrize(
+    "estimator,corrector,diagnostics",
+    [
+        (PermutedOLS, FWECorrector(method="montecarlo", n_iters=10), "jackknife"),
+        (Stouffers, "bonferroni", "jackknife"),
+        ("fishers", "fdr", "jackknife"),
+    ],
+)
+def test_ibma_workflow_smoke(
+    tmp_path_factory,
+    testdata_ibma,
+    estimator,
+    corrector,
+    diagnostics,
+):
+    """Run smoke test for CBMA workflow."""
+    tmpdir = tmp_path_factory.mktemp("test_ibma_workflow_smoke")
+
+    workflow = IBMAWorkflow(
+        estimator=estimator,
+        corrector=corrector,
+        diagnostics=diagnostics,
+        output_dir=tmpdir,
+    )
+    cres = workflow.fit(testdata_ibma)
+
+    assert isinstance(cres, nimare.results.MetaResult)
+    assert op.isfile(op.join(tmpdir, "boilerplate.txt"))
+    assert op.isfile(op.join(tmpdir, "references.bib"))
+
+    for imgtype in cres.maps.keys():
+        filename = f"{imgtype}.nii.gz"
+        outpath = op.join(tmpdir, filename)
+        assert op.isfile(outpath)
+
+    for tabletype in cres.tables.keys():
+        filename = f"{tabletype}.tsv"
+        outpath = op.join(tmpdir, filename)
+        assert op.isfile(outpath)
+
+
+def test_conjunction_analysis_smoke(tmp_path_factory):
+    """Run smoke test for conjunction analysis workflow."""
+    # Create two 3D arrays with random values
+    arr1 = np.random.rand(10, 10, 10)
+    arr2 = np.random.rand(10, 10, 10)
+
+    # Create two Nifti1Image objects from the arrays
+    img1 = nib.Nifti1Image(arr1, np.eye(4))
+    img2 = nib.Nifti1Image(arr2, np.eye(4))
+
+    # Perform conjunction analysis on the two images
+    conj_img = conjunction_analysis([img1, img2])
+
+    # Check that the output is a Nifti1Image object
+    assert isinstance(conj_img, nib.Nifti1Image)
+
+    # Check that the output has the same shape as the input images
+    assert conj_img.shape == img1.shape
+
+    # Check that the output has the correct values
+    expected_output = np.minimum.reduce([arr1, arr2])
+    np.testing.assert_array_equal(conj_img.get_fdata(), expected_output)
+
+    # Test passing in a list of strings
+    tmpdir = tmp_path_factory.mktemp("test_conjunction_analysis_smoke")
+    img1_fn = op.join(tmpdir, "image1.nii.gz")
+    img2_fn = op.join(tmpdir, "image2.nii.gz")
+    img1.to_filename(img1_fn)
+    img2.to_filename(img2_fn)
+
+    # Perform conjunction analysis on the two images from nifti files
+    conj_img_fromstr = conjunction_analysis([img1_fn, img2_fn])
+
+    # Check that the output has the correct values
+    np.testing.assert_array_equal(conj_img.get_fdata(), conj_img_fromstr.get_fdata())
+
+    # Raise error if only one image is provided
+    with pytest.raises(ValueError):
+        conjunction_analysis([img1])
+
+    # Raise error if invalid image type is provided
+    with pytest.raises(ValueError):
+        conjunction_analysis([1, 2])

nimare/tests/utils.py

@@ -0,0 +1,126 @@
+"""Utility functions for testing nimare."""
+
+import logging
+import os.path as op
+from contextlib import ExitStack as does_not_raise
+
+import nibabel as nib
+import numpy as np
+import pytest
+
+from nimare.meta.utils import compute_kda_ma
+
+# set significance levels used for testing.
+# duplicated in test_estimator_performance
+ALPHA = 0.05
+
+LGR = logging.getLogger(__name__)
+
+
+def get_test_data_path():
+    """Return the path to test datasets, terminated with separator.
+
+    Test-related data are kept in tests folder in "data".
+    Based on function by Yaroslav Halchenko used in Neurosynth Python package.
+    """
+    return op.abspath(op.join(op.dirname(__file__), "data") + op.sep)
+
+
+def _create_signal_mask(ground_truth_foci_ijks, mask):
+    """Create binary images to identify areas of likely significance and nonsignificance.
+
+    Parameters
+    ----------
+    ground_truth_foci_ijks : array_like
+        Ground truth ijk coordinates of foci.
+    mask : :obj:`nibabel.Nifti1Image`
+        Input mask to define shape and size of output binary masks
+
+    Returns
+    -------
+    sig_map : :obj:`nibabel.Nifti1Image`
+        Binary image representing regions around the
+        ground truth foci expected to be significant.
+    nonsig_map : :obj:`nibabel.Nifti1Image`
+        Binary image representing regions not expected
+        to be significant within the brain.
+    """
+    # area where I'm reasonably certain there are significant results
+    sig_prob_map = compute_kda_ma(mask, ground_truth_foci_ijks, r=2, value=1, sum_overlap=False)
+    sig_prob_map = sig_prob_map[0].todense()
+
+    # area where I'm reasonably certain there are not significant results
+    nonsig_prob_map = compute_kda_ma(
+        mask, ground_truth_foci_ijks, r=14, value=1, sum_overlap=False
+    )
+    nonsig_prob_map = nonsig_prob_map[0].todense()
+
+    sig_map = nib.Nifti1Image((sig_prob_map == 1).astype(np.int32), affine=mask.affine)
+    nonsig_map = nib.Nifti1Image((nonsig_prob_map == 0).astype(np.int32), affine=mask.affine)
+    return sig_map, nonsig_map
+
+
+def _check_p_values(
+    p_array,
+    masker,
+    sig_idx,
+    nonsig_idx,
+    alpha,
+    ground_truth_foci_ijks,
+    n_iters=None,
+    good_sensitivity=True,
+    good_specificity=True,
+):
+    """Check if p-values are within the correct range."""
+    ################################################
+    # CHECK IF P-VALUES ARE WITHIN THE CORRECT RANGE
+    ################################################
+    if n_iters:
+        assert p_array.min() >= (1.0 / n_iters)
+        assert p_array.max() <= 1.0 - (1.0 / n_iters)
+    else:
+        assert (p_array >= 0).all() and (p_array <= 1).all()
+
+    p_map = masker.inverse_transform(p_array).get_fdata()
+
+    # reformat coordinate indices to index p_map
+    gtf_idx = [
+        [ground_truth_foci_ijks[i][j] for i in range(len(ground_truth_foci_ijks))]
+        for j in range(3)
+    ]
+
+    best_chance_p_values = p_map[tuple(gtf_idx)]
+    assert all(best_chance_p_values < ALPHA) == good_sensitivity
+
+    p_array_sig = p_array[sig_idx]
+    p_array_nonsig = p_array[nonsig_idx]
+
+    # assert that at least 50% of voxels surrounding the foci
+    # are significant at alpha = .05
+    observed_sig = p_array_sig < alpha
+    observed_sig_perc = observed_sig.sum() / len(observed_sig)
+    assert (observed_sig_perc >= 0.5) == good_sensitivity
+
+    # assert that more than 95% of voxels farther away
+    # from foci are nonsignificant at alpha = 0.05
+    observed_nonsig = p_array_nonsig > alpha
+    observed_nonsig_perc = observed_nonsig.sum() / len(observed_nonsig)
+    assert np.isclose(observed_nonsig_perc, (1 - alpha), atol=0.05) == good_specificity
+
+
+def _transform_res(meta, meta_res, corr):
+    """Evaluate whether meta estimator and corrector work together."""
+    #######################################
+    # CHECK IF META/CORRECTOR WORK TOGETHER
+    #######################################
+    # all combinations of meta-analysis estimators and multiple comparison correctors
+    # that do not work together
+    corr_expectation = does_not_raise()
+
+    with corr_expectation:
+        cres = corr.transform(meta_res)
+
+    # if multiple correction failed (expected) do not continue
+    if isinstance(corr_expectation, type(pytest.raises(ValueError))):
+        pytest.xfail("this meta-analysis & corrector combo fails")
+    return cres