nimare 0.4.2__py3-none-any.whl

nimare/tests/test_nimads.py

@@ -0,0 +1,21 @@
+"""Test NiMADS functionality."""
+
+from nimare import nimads
+from nimare.dataset import Dataset
+
+
+def test_load_nimads(example_nimads_studyset, example_nimads_annotation):
+    """Test loading a NiMADS studyset."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+    studyset.annotations = example_nimads_annotation
+    # filter the studyset to only include analyses with include=True
+    annotation = studyset.annotations[0]
+    analysis_ids = [n.analysis.id for n in annotation.notes if n.note["include"]]
+    analysis_ids = analysis_ids[:5]
+    filtered_studyset = studyset.slice(analyses=analysis_ids)
+    # Combine analyses after filtering
+    filtered_studyset = filtered_studyset.combine_analyses()
+
+    assert isinstance(filtered_studyset, nimads.Studyset)
+    dataset = filtered_studyset.to_dataset()
+    assert isinstance(dataset, Dataset)

nimare/tests/test_reports.py

@@ -0,0 +1,110 @@
+"""Test nimare.reports."""
+
+import os.path as op
+
+import pytest
+
+from nimare.correct import FWECorrector
+from nimare.diagnostics import FocusCounter, Jackknife
+from nimare.meta.cbma import ALESubtraction
+from nimare.meta.ibma import FixedEffectsHedges, Stouffers
+from nimare.reports.base import run_reports
+from nimare.workflows import CBMAWorkflow, IBMAWorkflow, PairwiseCBMAWorkflow
+
+
+@pytest.mark.parametrize(
+    "estimator,corrector,diagnostics,meta_type",
+    [
+        ("ale", FWECorrector(method="montecarlo", n_iters=10), "jackknife", "cbma"),
+        ("kda", "fdr", "focuscounter", "cbma"),
+        (
+            "mkdachi2",
+            FWECorrector(method="montecarlo", n_iters=10),
+            Jackknife(voxel_thresh=0.1),
+            "pairwise_cbma",
+        ),
+        (
+            ALESubtraction(n_iters=10),
+            "fdr",
+            FocusCounter(voxel_thresh=0.01, display_second_group=True),
+            "pairwise_cbma",
+        ),
+    ],
+)
+def test_reports_function_smoke(
+    tmp_path_factory,
+    testdata_cbma_full,
+    estimator,
+    corrector,
+    diagnostics,
+    meta_type,
+):
+    """Run smoke test for CBMA workflow."""
+    tmpdir = tmp_path_factory.mktemp("test_reports_function_smoke")
+
+    if meta_type == "cbma":
+        workflow = CBMAWorkflow(
+            estimator=estimator,
+            corrector=corrector,
+            diagnostics=diagnostics,
+            output_dir=tmpdir,
+        )
+        results = workflow.fit(testdata_cbma_full)
+
+    elif meta_type == "pairwise_cbma":
+        dset1 = testdata_cbma_full.slice(testdata_cbma_full.ids[:10])
+        dset2 = testdata_cbma_full.slice(testdata_cbma_full.ids[10:])
+
+        workflow = PairwiseCBMAWorkflow(
+            estimator=estimator,
+            corrector=corrector,
+            diagnostics=diagnostics,
+            output_dir=tmpdir,
+        )
+        results = workflow.fit(dset1, dset2)
+
+    run_reports(results, tmpdir)
+
+    filename = "report.html"
+    outpath = op.join(tmpdir, filename)
+    assert op.isfile(outpath)
+
+
+@pytest.mark.parametrize("aggressive_mask", [True, False], ids=["aggressive", "liberal"])
+def test_reports_ibma_smoke(tmp_path_factory, testdata_ibma, aggressive_mask):
+    """Smoke test for IBMA reports."""
+    tmpdir = tmp_path_factory.mktemp("test_reports_ibma_smoke")
+
+    # Generate a report with z maps as inputs
+    stouffers_dir = op.join(tmpdir, "stouffers")
+    workflow = IBMAWorkflow(
+        estimator=Stouffers(aggressive_mask=aggressive_mask),
+        corrector="fdr",
+        diagnostics="jackknife",
+        voxel_thresh=3.2,
+        output_dir=stouffers_dir,
+    )
+    results = workflow.fit(testdata_ibma)
+
+    run_reports(results, stouffers_dir)
+
+    filename = "report.html"
+    outpath = op.join(stouffers_dir, filename)
+    assert op.isfile(outpath)
+
+    # Generate a report with t maps as inputs
+    hedges_dir = op.join(tmpdir, "hedges")
+    workflow = IBMAWorkflow(
+        estimator=FixedEffectsHedges(aggressive_mask=aggressive_mask),
+        corrector="fdr",
+        diagnostics="jackknife",
+        voxel_thresh=3.2,
+        output_dir=hedges_dir,
+    )
+    results = workflow.fit(testdata_ibma)
+
+    run_reports(results, hedges_dir)
+
+    filename = "report.html"
+    outpath = op.join(hedges_dir, filename)
+    assert op.isfile(outpath)

nimare/tests/test_stats.py

@@ -0,0 +1,101 @@
+"""Test nimare.stats."""
+
+import math
+
+import numpy as np
+
+from nimare.stats import null_to_p, nullhist_to_p
+
+
+def test_null_to_p_float():
+    """Test null_to_p with single float input, assuming asymmetric null dist."""
+    null = [-10, -9, -9, -3, -2, -1, -1, 0, 1, 1, 1, 2, 3, 3, 4, 4, 7, 8, 8, 9]
+
+    # Two-tailed
+    assert math.isclose(null_to_p(0, null, "two"), 0.8)
+    assert math.isclose(null_to_p(9, null, "two"), 0.1)
+    assert math.isclose(null_to_p(10, null, "two"), 0.05)
+    assert math.isclose(null_to_p(-9, null, "two"), 0.3)
+    assert math.isclose(null_to_p(-10, null, "two"), 0.1)
+    # Still 0.05 because minimum valid p-value is 1 / len(null)
+    result = null_to_p(20, null, "two")
+    assert result == null_to_p(-20, null, "two")
+    assert math.isclose(result, 0.05)
+
+    # Left/lower-tailed
+    assert math.isclose(null_to_p(9, null, "lower"), 0.95)
+    assert math.isclose(null_to_p(-9, null, "lower"), 0.15)
+    assert math.isclose(null_to_p(0, null, "lower"), 0.4)
+
+    # Right/upper-tailed
+    assert math.isclose(null_to_p(9, null, "upper"), 0.05)
+    assert math.isclose(null_to_p(-9, null, "upper"), 0.95)
+    assert math.isclose(null_to_p(0, null, "upper"), 0.65)
+
+    # Test that 1/n(null) is preserved with extreme values
+    nulldist = np.random.normal(size=10000)
+    assert math.isclose(null_to_p(20, nulldist, "two"), 1 / 10000)
+    assert math.isclose(null_to_p(20, nulldist, "lower"), 1 - 1 / 10000)
+
+
+def test_null_to_p_float_symmetric():
+    """Test null_to_p with single float input, assuming symmetric null dist."""
+    null = [-10, -9, -9, -3, -2, -1, -1, 0, 1, 1, 1, 2, 3, 3, 4, 4, 7, 8, 8, 9]
+
+    # Only need to test two-tailed; symmetry is irrelevant for one-tailed
+    assert math.isclose(null_to_p(0, null, "two", symmetric=True), 0.95)
+    result = null_to_p(9, null, "two", symmetric=True)
+    assert result == null_to_p(-9, null, "two", symmetric=True)
+    assert math.isclose(result, 0.2)
+    result = null_to_p(10, null, "two", symmetric=True)
+    assert result == null_to_p(-10, null, "two", symmetric=True)
+    assert math.isclose(result, 0.05)
+    # Still 0.05 because minimum valid p-value is 1 / len(null)
+    result = null_to_p(20, null, "two", symmetric=True)
+    assert result == null_to_p(-20, null, "two", symmetric=True)
+    assert math.isclose(result, 0.05)
+
+
+def test_null_to_p_array():
+    """Test nimare.stats.null_to_p with 1d array input."""
+    N = 10000
+    nulldist = np.random.normal(size=N)
+    t = np.sort(np.random.normal(size=N))
+    p = np.sort(null_to_p(t, nulldist))
+    assert p.shape == (N,)
+    assert (p < 1).all()
+    assert (p > 0).all()
+    # Resulting distribution should be roughly uniform
+    assert np.abs(p.mean() - 0.5) < 0.02
+    assert np.abs(p.var() - 1 / 12) < 0.02
+
+
+def test_nullhist_to_p():
+    """Test nimare.stats.nullhist_to_p."""
+    n_voxels = 5
+
+    # Test cross-voxel null distribution
+    histogram_bins = np.arange(0, 101, 1)  # 101 bins
+    histogram_weights = np.ones(histogram_bins.shape)
+    histogram_weights[-1] = 0  # last bin is outside range, so there are 100 bins with values
+
+    # When input is a single value
+    assert math.isclose(nullhist_to_p(0, histogram_weights, histogram_bins), 1.0)
+    assert math.isclose(nullhist_to_p(1, histogram_weights, histogram_bins), 0.99)
+    assert math.isclose(nullhist_to_p(99, histogram_weights, histogram_bins), 0.01)
+    assert math.isclose(nullhist_to_p(100, histogram_weights, histogram_bins), 0.01)
+
+    # When input is an array
+    assert np.allclose(
+        nullhist_to_p([0, 1, 99, 100, 101], histogram_weights, histogram_bins),
+        np.array([1.0, 0.99, 0.01, 0.01, 0.01]),
+    )
+
+    # Test voxel-wise null distributions
+    histogram_weights = np.ones((histogram_bins.shape[0], n_voxels))
+    histogram_weights[-1, :] = 0  # last bin is outside range, so there are 100 bins with values
+
+    assert np.allclose(
+        nullhist_to_p([0, 1, 99, 100, 101], histogram_weights, histogram_bins),
+        np.array([1.0, 0.99, 0.01, 0.01, 0.01]),
+    )

nimare/tests/test_transforms.py

@@ -0,0 +1,272 @@
+"""Test nimare.transforms."""
+
+import re
+
+import nibabel as nib
+import numpy as np
+import pytest
+
+from nimare import transforms
+
+
+def test_ImageTransformer(testdata_ibma):
+    """Smoke test on transforms.ImageTransformer."""
+    dset = testdata_ibma
+    z_files = dset.images["z"].tolist()
+    z_transformer = transforms.ImageTransformer(target="z")
+    new_dset = z_transformer.transform(dset)
+    new_z_files = new_dset.images["z"].tolist()
+    assert z_files[:-1] == new_z_files[:-1]
+    # new z statistic map should have 3 dimensions
+    assert len(nib.load(new_z_files[-1]).shape) == 3
+    assert all([nzf is not None for nzf in new_z_files])
+
+    varcope_files = dset.images["varcope"].tolist()
+    varcope_p_transformer = transforms.ImageTransformer(target=["varcope", "p"])
+    new_dset = varcope_p_transformer.transform(dset)
+    new_varcope_files = new_dset.images["varcope"].tolist()
+    assert not all([isinstance(vf, str) for vf in varcope_files])
+    assert all([isinstance(vf, str) for vf in new_varcope_files])
+    new_p_files = new_dset.images["p"].tolist()
+    assert all([isinstance(pf, str) for pf in new_p_files])
+
+    t_files = dset.images["t"].tolist()
+    t_transformer = transforms.ImageTransformer(target="t")
+    new_dset = t_transformer.transform(dset)
+    new_t_files = new_dset.images["t"].tolist()
+    assert t_files[:-1] == new_t_files[:-1]
+
+
+def test_transform_images(testdata_ibma):
+    """Smoke test on transforms.transform_images."""
+    dset = testdata_ibma
+    z_files = dset.images["z"].tolist()
+    new_images = transforms.transform_images(
+        dset.images, target="z", masker=dset.masker, metadata_df=dset.metadata
+    )
+    new_z_files = new_images["z"].tolist()
+    assert z_files[:-1] == new_z_files[:-1]
+    # new z statistic map should have 3 dimensions
+    assert len(nib.load(new_z_files[-1]).shape) == 3
+    assert all([nzf is not None for nzf in new_z_files])
+
+    varcope_files = dset.images["varcope"].tolist()
+    new_images = transforms.transform_images(
+        dset.images, target="varcope", masker=dset.masker, metadata_df=dset.metadata
+    )
+    new_varcope_files = new_images["varcope"].tolist()
+    assert not all([isinstance(vf, str) for vf in varcope_files])
+    assert all([isinstance(vf, str) for vf in new_varcope_files])
+
+
+def test_sample_sizes_to_dof():
+    """Unit tests for transforms.sample_sizes_to_dof."""
+    sample_sizes = [20, 20, 20]
+    dof = 57
+    assert transforms.sample_sizes_to_dof(sample_sizes) == dof
+    sample_sizes = [20]
+    dof = 19
+    assert transforms.sample_sizes_to_dof(sample_sizes) == dof
+
+
+def test_sample_sizes_to_sample_size():
+    """Unit tests for transforms.sample_sizes_to_sample_size."""
+    sample_sizes = [20, 20, 20]
+    sample_size = 60
+    assert transforms.sample_sizes_to_sample_size(sample_sizes) == sample_size
+    sample_sizes = [20]
+    sample_size = 20
+    assert transforms.sample_sizes_to_sample_size(sample_sizes) == sample_size
+
+
+def test_t_to_z():
+    """Smoke test for transforms.t_to_z."""
+    t_arr = np.random.random(100)
+    z_arr = transforms.t_to_z(t_arr, dof=20)
+    assert z_arr.shape == t_arr.shape
+    t_arr2 = transforms.z_to_t(z_arr, dof=20)
+    assert np.allclose(t_arr, t_arr2)
+
+
+NO_OUTPUT_PATTERN = re.compile(
+    (
+        r"^No clusters were found for ([\w\.0-9+-]+) at a threshold of [0-9]+\.[0-9]+$|"
+        r"No Z or p map for ([\w-]+), skipping..."
+    )
+)
+
+
+@pytest.mark.parametrize(
+    "kwargs,drop_data,add_data",
+    [
+        ({"merge_strategy": "fill"}, "z", "p"),
+        ({"merge_strategy": "replace"}, None, None),
+        ({"merge_strategy": "demolish", "remove_subpeaks": True}, None, None),
+        ({"merge_strategy": "fill", "two_sided": True}, "z", "p"),
+        (
+            {
+                "merge_strategy": "demolish",
+                "two_sided": True,
+                "z_threshold": 1.9,
+            },
+            None,
+            None,
+        ),
+        ({"merge_strategy": "demolish", "z_threshold": 10.0}, None, None),
+    ],
+)
+def test_images_to_coordinates(tmp_path, caplog, testdata_ibma, kwargs, drop_data, add_data):
+    """Test conversion of statistical images to coordinates."""
+    # only catch warnings from the transforms logger
+    caplog.set_level("WARNING", logger=transforms.LGR.name)
+
+    img2coord = transforms.ImagesToCoordinates(**kwargs)
+    tst_dset = testdata_ibma.copy()
+
+    if add_data:
+        tst_dset.images = transforms.transform_images(
+            tst_dset.images,
+            add_data,
+            tst_dset.masker,
+            tst_dset.metadata,
+            tmp_path,
+        )
+
+    if drop_data:
+        tst_dset.images = tst_dset.images.drop(columns=drop_data)
+
+    new_dset = img2coord.transform(tst_dset)
+
+    # metadata column "coordinate_source" should exist
+    assert "coordinate_source" in new_dset.metadata.columns
+
+    # get the studies that did not generate coordinates
+    # either because the threshold was too high or
+    # because there were no images to generate coordinates
+    studies_without_coordinates = []
+    for msg in caplog.messages:
+        match = NO_OUTPUT_PATTERN.match(msg)
+        if match:
+            studies_without_coordinates.append(
+                match.group(1) if match.group(1) else match.group(2)
+            )
+
+    # if there is not a z map for a study contrast, raise a warning
+    # unless the strategy is fill since all studies already have coordinates
+    if drop_data == "z" and add_data == "p" and img2coord.merge_strategy != "fill":
+        assert "No Z map for" in caplog.messages[0]
+
+        # if someone is trying to use two-sided on a study contrast with a p map, raise a warning
+        if img2coord.two_sided:
+            assert "Cannot use two_sided threshold using a p map for" in caplog.messages[0]
+
+    # if two_sided was specified and z maps were used, there
+    # should be peaks with negative values.
+    if img2coord.two_sided and not drop_data and not add_data:
+        assert np.any(new_dset.coordinates["z_stat"] < 0.0)
+
+    # since testdata_ibma already has coordinate data for every study
+    # this transformation should retain the same number of unique ids
+    # unless the merge_strategy was demolish
+    if img2coord.merge_strategy == "demolish":
+        expected_studies_with_coordinates = set(
+            tst_dset.images.loc[~tst_dset.images["z"].isnull(), "id"]
+        ) - set(studies_without_coordinates)
+    else:
+        expected_studies_with_coordinates = set(tst_dset.coordinates["id"]).union(
+            ["pain_01.nidm-1"]
+        )
+
+    assert set(new_dset.coordinates["id"]) == expected_studies_with_coordinates, set(
+        new_dset.coordinates["id"]
+    )
+
+
+def test_ddimages_to_coordinates_merge_strategy(testdata_ibma):
+    """Test different merging strategies."""
+    img2coord = transforms.ImagesToCoordinates(z_threshold=1.9)
+
+    # keep pain_01.nidm-1, pain_02.nidm-1, pain_03.nidm-1, pain_04.nidm-1
+    tst_dset = testdata_ibma.slice(
+        ["pain_01.nidm-1", "pain_02.nidm-1", "pain_03.nidm-1", "pain_04.nidm-1"]
+    )
+
+    # remove image data for pain_01.nidm-1 and pain_03.nidm-1
+    # coordinate data for pain_01.nidm-1 and pain_02.nidm-1 are already removed
+    tst_dset.images = tst_dset.images.query("id != 'pain_01.nidm-1'")
+    tst_dset.images = tst_dset.images.query("id != 'pain_03.nidm-1'")
+
+    # | study        | image | coordinate |
+    # |--------------|-------|------------|
+    # | pain_01.nidm | no    | no         |
+    # | pain_02.nidm | yes   | no         |
+    # | pain_03.nidm | no    | yes        |
+    # | pain_04.nidm | yes   | yes        |
+
+    # test 'fill' strategy
+    # only pain_02.nidm should have new data.
+    # pain_01.nidm, pain_03.nidm, and pain_04.nidm should remain the same
+    img2coord.merge_strategy = "fill"
+    fill_dset = img2coord.transform(tst_dset)
+    # pain_01.nidm and pain_03.nidm should be unchanged
+    assert set(fill_dset.coordinates.query("id != 'pain_02.nidm-1'")["x"]) == set(
+        tst_dset.coordinates["x"]
+    )
+    # pain_02.nidm should be in the coordinates now
+    assert "pain_02.nidm-1" in fill_dset.coordinates["id"].unique()
+
+    # test 'replace' strategy
+    # pain_02.nidm and pain_04.nidm should have new data,
+    # but pain_01.nidm and pain_03.nidm should remain the same
+    img2coord.merge_strategy = "replace"
+    replace_dset = img2coord.transform(tst_dset)
+
+    # pain_01.nidm should remain the same
+    assert set(replace_dset.coordinates.query("id == 'pain_01.nidm-1'")["x"]) == set(
+        tst_dset.coordinates.query("id == 'pain_01.nidm-1'")["x"]
+    )
+    # pain_02.nidm should be new
+    assert "pain_02.nidm-1" in replace_dset.coordinates["id"].unique()
+    # pain_03.nidm should remain the same
+    assert set(replace_dset.coordinates.query("id == 'pain_03.nidm-1'")["x"]) == set(
+        tst_dset.coordinates.query("id == 'pain_03.nidm-1'")["x"]
+    )
+    # pain_04.nidm should be new (and have different coordinates from the old version)
+    assert set(replace_dset.coordinates.query("id == 'pain_04.nidm-1'")["x"]) != set(
+        tst_dset.coordinates.query("id == 'pain_04.nidm-1'")["x"]
+    )
+
+    # test 'demolish' strategy
+    # pain_03.nidm will be removed, and pain_02.nidm and pain_04.nidm will be new
+    img2coord.merge_strategy = "demolish"
+    demolish_dset = img2coord.transform(tst_dset)
+
+    # pain_01.nidm should not be in the dset
+    assert "pain_01.nidm-1" not in demolish_dset.coordinates["id"].unique()
+    # pain_02.nidm should be new
+    assert "pain_02.nidm-1" in demolish_dset.coordinates["id"].unique()
+    # pain_03.nidm should not be in the dset
+    assert "pain_03.nidm-1" not in demolish_dset.coordinates["id"].unique()
+    # pain_04.nidm should be new (and have different coordinates from the old version)
+    assert set(demolish_dset.coordinates.query("id == 'pain_04.nidm-1'")["x"]) != set(
+        tst_dset.coordinates.query("id == 'pain_04.nidm-1'")["x"]
+    )
+
+
+@pytest.mark.parametrize(
+    "z,tail,expected_p",
+    [
+        (0.0, "two", 1.0),
+        (0.0, "one", 0.5),
+        (1.959963, "two", 0.05),
+        (1.959963, "one", 0.025),
+        (-1.959963, "one", 0.975),
+        (-1.959963, "two", 0.05),
+        ([0.0, 1.959963, -1.959963], "two", [1.0, 0.05, 0.05]),
+    ],
+)
+def test_z_to_p(z, tail, expected_p):
+    """Test z to p conversion."""
+    p = transforms.z_to_p(z, tail)
+
+    assert np.all(np.isclose(p, expected_p))