Identify the last good echo in adaptive mask instead of sum of good echoes

tedana/tests/test_utils.py

@@ -80,73 +80,130 @@ def test_make_adaptive_mask():
     mask_file = pjoin(datadir, "mask.nii.gz")
     data = io.load_data(fnames, n_echos=len(tes))[0]
 
+    # Add in simulated values
+    base_val = np.mean(data[:, 0, :])  # mean value of first echo
+    idx = 5457
+    # Three good echoes (3)
+    data[idx, :, :] = np.array([base_val, base_val - 1, base_val - 2])[:, None]
+    # Dropout: good bad good (3)
+    # Decay: good good bad (2)
+    data[idx + 1, :, :] = np.array([base_val, 1, base_val])[:, None]
+    # Dropout: good bad bad (1)
+    # Decay: good good bad (2)
+    data[idx + 2, :, :] = np.array([base_val, 1, 1])[:, None]
+    # Dropout: good good good (3)
+    # Decay: good bad bad (1)
+    data[idx + 3, :, :] = np.array([base_val, base_val, base_val])[:, None]
+    # Dropout: bad bad bad (0)
+    # Decay: good good good (3)
+    data[idx + 4, :, :] = np.array([1, 0.9, 0.8])[:, None]
+    # Base: good good bad (2)
+    # Dropout: bad bad bad (0)
+    # Decay: good good good (3)
+    data[idx + 5, :, :] = np.array([1, 0.9, -1])[:, None]
+
     # Just dropout method
-    mask, masksum = utils.make_adaptive_mask(
+    mask, adaptive_mask = utils.make_adaptive_mask(
         data,
         mask=mask_file,
         threshold=1,
         methods=["dropout"],
     )
 
-    assert mask.shape == masksum.shape == (64350,)
-    assert np.allclose(mask, (masksum >= 1).astype(bool))
-    assert mask.sum() == 49376
-    vals, counts = np.unique(masksum, return_counts=True)
+    assert mask.shape == adaptive_mask.shape == (64350,)
+    assert np.allclose(mask, (adaptive_mask >= 1).astype(bool))
+    assert adaptive_mask[idx] == 3
+    assert adaptive_mask[idx + 1] == 3
+    assert adaptive_mask[idx + 2] == 1
+    assert adaptive_mask[idx + 3] == 3
+    assert adaptive_mask[idx + 4] == 0
+    assert adaptive_mask[idx + 5] == 0
+    assert mask.sum() == 49374
+    vals, counts = np.unique(adaptive_mask, return_counts=True)
     assert np.allclose(vals, np.array([0, 1, 2, 3]))
-    assert np.allclose(counts, np.array([14974, 3682, 5128, 40566]))
+    assert np.allclose(counts, np.array([14976, 1817, 4427, 43130]))
 
     # Just decay method
-    mask, masksum = utils.make_adaptive_mask(
+    mask, adaptive_mask = utils.make_adaptive_mask(
         data,
         mask=mask_file,
         threshold=1,
         methods=["decay"],
     )
 
-    assert mask.shape == masksum.shape == (64350,)
-    assert np.allclose(mask, (masksum >= 1).astype(bool))
+    assert mask.shape == adaptive_mask.shape == (64350,)
+    assert np.allclose(mask, (adaptive_mask >= 1).astype(bool))
+    assert adaptive_mask[idx] == 3
+    assert adaptive_mask[idx + 1] == 2
+    assert adaptive_mask[idx + 2] == 2
+    assert adaptive_mask[idx + 3] == 1
+    assert adaptive_mask[idx + 4] == 3
+    assert adaptive_mask[idx + 5] == 2
     assert mask.sum() == 60985  # This method can't flag first echo as bad
-    vals, counts = np.unique(masksum, return_counts=True)
+    vals, counts = np.unique(adaptive_mask, return_counts=True)
     assert np.allclose(vals, np.array([0, 1, 2, 3]))
-    assert np.allclose(counts, np.array([3365, 4365, 5971, 50649]))
+    assert np.allclose(counts, np.array([3365, 4366, 5973, 50646]))
 
     # Dropout and decay methods combined
-    mask, masksum = utils.make_adaptive_mask(
+    mask, adaptive_mask = utils.make_adaptive_mask(
         data,
         mask=mask_file,
         threshold=1,
         methods=["dropout", "decay"],
     )
 
-    assert mask.shape == masksum.shape == (64350,)
-    assert np.allclose(mask, (masksum >= 1).astype(bool))
-    assert mask.sum() == 49376
-    vals, counts = np.unique(masksum, return_counts=True)
+    assert mask.shape == adaptive_mask.shape == (64350,)
+    assert np.allclose(mask, (adaptive_mask >= 1).astype(bool))
+    assert adaptive_mask[idx] == 3
+    assert adaptive_mask[idx + 1] == 2
+    assert adaptive_mask[idx + 2] == 1
+    assert adaptive_mask[idx + 3] == 1
+    assert adaptive_mask[idx + 4] == 0
+    assert adaptive_mask[idx + 5] == 0
+    assert mask.sum() == 49374
+    vals, counts = np.unique(adaptive_mask, return_counts=True)
     assert np.allclose(vals, np.array([0, 1, 2, 3]))
-    assert np.allclose(counts, np.array([14974, 4386, 5604, 39386]))
+    assert np.allclose(counts, np.array([14976, 3111, 6248, 40015]))
 
     # Adding "none" should have no effect
-    mask, masksum = utils.make_adaptive_mask(
+    mask, adaptive_mask = utils.make_adaptive_mask(
         data,
         mask=mask_file,
         threshold=1,
         methods=["dropout", "decay", "none"],
     )
 
-    assert mask.shape == masksum.shape == (64350,)
-    assert np.allclose(mask, (masksum >= 1).astype(bool))
-    assert mask.sum() == 49376
-    vals, counts = np.unique(masksum, return_counts=True)
+    assert mask.shape == adaptive_mask.shape == (64350,)
+    assert np.allclose(mask, (adaptive_mask >= 1).astype(bool))
+    assert adaptive_mask[idx] == 3
+    assert adaptive_mask[idx + 1] == 2
+    assert adaptive_mask[idx + 2] == 1
+    assert adaptive_mask[idx + 3] == 1
+    assert adaptive_mask[idx + 4] == 0
+    assert adaptive_mask[idx + 5] == 0
+    assert mask.sum() == 49374
+    vals, counts = np.unique(adaptive_mask, return_counts=True)
     assert np.allclose(vals, np.array([0, 1, 2, 3]))
-    assert np.allclose(counts, np.array([14974, 4386, 5604, 39386]))
+    assert np.allclose(counts, np.array([14976, 3111, 6248, 40015]))
 
     # Just "none"
-    mask, masksum = utils.make_adaptive_mask(data, mask=mask_file, threshold=1, methods=["none"])
+    mask, adaptive_mask = utils.make_adaptive_mask(
+        data,
+        mask=mask_file,
+        threshold=1,
+        methods=["none"],
+    )
 
-    assert mask.shape == masksum.shape == (64350,)
-    assert np.allclose(mask, (masksum >= 1).astype(bool))
+    assert mask.shape == adaptive_mask.shape == (64350,)
+    assert np.allclose(mask, (adaptive_mask >= 1).astype(bool))
+    assert adaptive_mask[idx] == 3
+    assert adaptive_mask[idx + 1] == 3
+    assert adaptive_mask[idx + 2] == 3
+    assert adaptive_mask[idx + 3] == 3
+    assert adaptive_mask[idx + 4] == 3
+    assert adaptive_mask[idx + 5] == 2
     assert mask.sum() == 60985
-    vals, counts = np.unique(masksum, return_counts=True)
+    vals, counts = np.unique(adaptive_mask, return_counts=True)
     assert np.allclose(vals, np.array([0, 1, 2, 3]))
     assert np.allclose(counts, np.array([3365, 1412, 1195, 58378]))
 

tedana/utils.py

@@ -62,8 +62,8 @@ def make_adaptive_mask(data, mask, threshold=1, methods=["dropout"]):
         Without a mask limiting the voxels to consider,
         the adaptive mask will generally select voxels outside the brain as exemplars.
     threshold : :obj:`int`, optional
-        Minimum echo count to retain in the mask. Default is 1, which is
-        equivalent not thresholding.
+        Minimum echo count to retain in the mask.
+        Default is 1, which is equivalent to not thresholding.
     methods : :obj:`list`, optional
         List of methods to use for adaptive mask generation. Default is ["dropout"].
         Valid methods are "decay", "dropout", and "none".
@@ -103,9 +103,14 @@ def make_adaptive_mask(data, mask, threshold=1, methods=["dropout"]):
         -   This is the threshold for "good" data.
         -   The 1/3 value is arbitrary.
         -   If there was more than one exemplar voxel, retain the the highest value for each echo.
-    d.  For each voxel, count the number of echoes that have a mean value greater than the
+    d.  For each voxel, identify the last echo with a mean value greater than the
         corresponding echo's threshold.
 
+        -   Preceding echoes (including ones with mean values less than the threshold)
+            are considered "good" data. That means, if echoes 1-3 in a voxel are
+            [good, good, bad] the adaptive mask will assign a 2, and if they are
+            [good, bad, good], the adaptive mask will assign a 3.
+
     Decay
 
     Determine the echo at which the signal stops decreasing for each voxel.
@@ -187,9 +192,17 @@ def make_adaptive_mask(data, mask, threshold=1, methods=["dropout"]):
 
         LGR.info("Echo-wise intensity thresholds for adaptive mask: %s", lthrs)
 
-        # determine samples where absolute value is greater than echo-specific thresholds
-        # and count # of echos that pass criterion
-        dropout_adaptive_mask = (np.abs(echo_means) > lthrs).sum(axis=-1)
+        # Find the last good echo for each voxel
+        # Start with every voxel's value==0, increment up the echoes, and
+        # change to a new value every time a later good echo is found
+        dropout_adaptive_mask = np.zeros(n_samples, dtype=np.int16)
+        for echo_idx in range(n_echos):
+            dropout_adaptive_mask[(np.abs(echo_means[:, echo_idx]) > lthrs[echo_idx])] = (
+                echo_idx + 1
+            )
+
+        adaptive_masks.append(dropout_adaptive_mask)
+
         adaptive_masks.append(dropout_adaptive_mask)
 
     if "decay" in methods: