# Authors: The MNE-Python contributors.
# License: BSD-3-Clause
# Copyright the MNE-Python contributors.
from copy import deepcopy
from pathlib import Path
import numpy as np
import pytest
from numpy.testing import assert_array_equal
from mne import (
Epochs,
channel_indices_by_type,
channel_type,
create_info,
make_ad_hoc_cov,
pick_channels,
pick_channels_cov,
pick_channels_regexp,
pick_info,
pick_types,
pick_types_forward,
read_forward_solution,
rename_channels,
)
from mne._fiff.constants import FIFF
from mne._fiff.pick import (
_DATA_CH_TYPES_SPLIT,
_contains_ch_type,
_picks_by_type,
_picks_to_idx,
get_channel_type_constants,
)
from mne.channels import make_standard_montage
from mne.datasets import testing
from mne.io import (
RawArray,
read_info,
read_raw_bti,
read_raw_fif,
read_raw_kit,
)
from mne.preprocessing import compute_current_source_density
from mne.utils import assert_object_equal, catch_logging
data_path = testing.data_path(download=False)
fname_meeg = data_path / "MEG" / "sample" / "sample_audvis_trunc-meg-eeg-oct-4-fwd.fif"
fname_mc = data_path / "SSS" / "test_move_anon_movecomp_raw_sss.fif"
io_dir = Path(__file__).parents[2] / "io"
ctf_fname = io_dir / "tests" / "data" / "test_ctf_raw.fif"
fif_fname = io_dir / "tests" / "data" / "test_raw.fif"
def _picks_by_type_old(info, meg_combined=False, ref_meg=False, exclude="bads"):
"""Use the old, slower _picks_by_type code."""
picks_list = []
has = [_contains_ch_type(info, k) for k in _DATA_CH_TYPES_SPLIT]
has = dict(zip(_DATA_CH_TYPES_SPLIT, has))
if has["mag"] and (meg_combined is not True or not has["grad"]):
picks_list.append(
(
"mag",
pick_types(
info,
meg="mag",
eeg=False,
stim=False,
ref_meg=ref_meg,
exclude=exclude,
),
)
)
if has["grad"] and (meg_combined is not True or not has["mag"]):
picks_list.append(
(
"grad",
pick_types(
info,
meg="grad",
eeg=False,
stim=False,
ref_meg=ref_meg,
exclude=exclude,
),
)
)
if has["mag"] and has["grad"] and meg_combined is True:
picks_list.append(
(
"meg",
pick_types(
info,
meg=True,
eeg=False,
stim=False,
ref_meg=ref_meg,
exclude=exclude,
),
)
)
for ch_type in _DATA_CH_TYPES_SPLIT:
if ch_type in ["grad", "mag"]: # exclude just MEG channels
continue
if has[ch_type]:
picks_list.append(
(
ch_type,
pick_types(
info,
meg=False,
stim=False,
ref_meg=ref_meg,
exclude=exclude,
**{ch_type: True},
),
)
)
return picks_list
def _channel_type_old(info, idx):
"""Get channel type using old, slower scheme."""
ch = info["chs"][idx]
# iterate through all defined channel types until we find a match with ch
# go in order from most specific (most rules entries) to least specific
channel_types = sorted(
get_channel_type_constants().items(), key=lambda x: len(x[1]), reverse=True
)
for t, rules in channel_types:
for key, vals in rules.items(): # all keys must match the values
if ch.get(key, None) not in np.array(vals):
break # not channel type t, go to next iteration
else:
return t
raise ValueError(f"Unknown channel type for {ch['ch_name']}")
def _assert_channel_types(info):
for k in range(info["nchan"]):
a, b = channel_type(info, k), _channel_type_old(info, k)
assert a == b
def test_pick_refs():
"""Test picking of reference sensors."""
infos = list()
# KIT
kit_dir = io_dir / "kit" / "tests" / "data"
sqd_path = kit_dir / "test.sqd"
mrk_path = kit_dir / "test_mrk.sqd"
elp_path = kit_dir / "test_elp.txt"
hsp_path = kit_dir / "test_hsp.txt"
raw_kit = read_raw_kit(sqd_path, str(mrk_path), str(elp_path), str(hsp_path))
infos.append(raw_kit.info)
# BTi
bti_dir = io_dir / "bti" / "tests" / "data"
bti_pdf = bti_dir / "test_pdf_linux"
bti_config = bti_dir / "test_config_linux"
bti_hs = bti_dir / "test_hs_linux"
raw_bti = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)
infos.append(raw_bti.info)
# CTF
fname_ctf_raw = io_dir / "tests" / "data" / "test_ctf_comp_raw.fif"
raw_ctf = read_raw_fif(fname_ctf_raw)
raw_ctf.apply_gradient_compensation(2)
for info in infos:
info["bads"] = []
_assert_channel_types(info)
with pytest.raises(ValueError, match="'planar2'] or bool, not foo"):
pick_types(info, meg="foo")
with pytest.raises(ValueError, match="'planar2', 'auto'] or bool,"):
pick_types(info, ref_meg="foo")
picks_meg_ref = pick_types(info, meg=True, ref_meg=True)
picks_meg = pick_types(info, meg=True, ref_meg=False)
picks_ref = pick_types(info, meg=False, ref_meg=True)
assert_array_equal(
picks_meg_ref, np.sort(np.concatenate([picks_meg, picks_ref]))
)
picks_grad = pick_types(info, meg="grad", ref_meg=False)
picks_ref_grad = pick_types(info, meg=False, ref_meg="grad")
picks_meg_ref_grad = pick_types(info, meg="grad", ref_meg="grad")
assert_array_equal(
picks_meg_ref_grad, np.sort(np.concatenate([picks_grad, picks_ref_grad]))
)
picks_mag = pick_types(info, meg="mag", ref_meg=False)
picks_ref_mag = pick_types(info, meg=False, ref_meg="mag")
picks_meg_ref_mag = pick_types(info, meg="mag", ref_meg="mag")
assert_array_equal(
picks_meg_ref_mag, np.sort(np.concatenate([picks_mag, picks_ref_mag]))
)
assert_array_equal(picks_meg, np.sort(np.concatenate([picks_mag, picks_grad])))
assert_array_equal(
picks_ref, np.sort(np.concatenate([picks_ref_mag, picks_ref_grad]))
)
assert_array_equal(
picks_meg_ref,
np.sort(
np.concatenate([picks_grad, picks_mag, picks_ref_grad, picks_ref_mag])
),
)
for pick in (
picks_meg_ref,
picks_meg,
picks_ref,
picks_grad,
picks_ref_grad,
picks_meg_ref_grad,
picks_mag,
picks_ref_mag,
picks_meg_ref_mag,
):
if len(pick) > 0:
pick_info(info, pick)
# test CTF expected failures directly
info = raw_ctf.info
info["bads"] = []
picks_meg_ref = pick_types(info, meg=True, ref_meg=True)
picks_meg = pick_types(info, meg=True, ref_meg=False)
picks_ref = pick_types(info, meg=False, ref_meg=True)
picks_mag = pick_types(info, meg="mag", ref_meg=False)
picks_ref_mag = pick_types(info, meg=False, ref_meg="mag")
picks_meg_ref_mag = pick_types(info, meg="mag", ref_meg="mag")
for pick in (picks_meg_ref, picks_ref, picks_ref_mag, picks_meg_ref_mag):
if len(pick) > 0:
pick_info(info, pick)
for pick in (picks_meg, picks_mag):
if len(pick) > 0:
with catch_logging() as log:
pick_info(info, pick, verbose=True)
assert (
"Removing {} compensators".format(len(info["comps"])) in log.getvalue()
)
picks_ref_grad = pick_types(info, meg=False, ref_meg="grad")
assert set(picks_ref_mag) == set(picks_ref)
assert len(picks_ref_grad) == 0
all_meg = np.arange(3, 306)
assert_array_equal(np.concatenate([picks_ref, picks_meg]), all_meg)
assert_array_equal(picks_meg_ref_mag, all_meg)
def test_pick_channels_regexp():
"""Test pick with regular expression."""
ch_names = ["MEG 2331", "MEG 2332", "MEG 2333"]
assert_array_equal(pick_channels_regexp(ch_names, "MEG ...1"), [0])
assert_array_equal(pick_channels_regexp(ch_names, "MEG ...[2-3]"), [1, 2])
assert_array_equal(pick_channels_regexp(ch_names, "MEG *"), [0, 1, 2])
def assert_indexing(info, picks_by_type, ref_meg=False, all_data=True):
"""Assert our indexing functions work properly."""
# First that our old and new channel typing functions are equivalent
_assert_channel_types(info)
# Next that channel_indices_by_type works
if not ref_meg:
idx = channel_indices_by_type(info)
for key in idx:
for p in picks_by_type:
if key == p[0]:
assert_array_equal(idx[key], p[1])
break
else:
assert len(idx[key]) == 0
# Finally, picks_by_type (if relevant)
if not all_data:
picks_by_type = [p for p in picks_by_type if p[0] in _DATA_CH_TYPES_SPLIT]
picks_by_type = [(p[0], np.array(p[1], int)) for p in picks_by_type]
actual = _picks_by_type(info, ref_meg=ref_meg)
assert_object_equal(actual, picks_by_type)
if not ref_meg and idx["hbo"]: # our old code had a bug
with pytest.raises(TypeError, match="unexpected keyword argument"):
_picks_by_type_old(info, ref_meg=ref_meg)
else:
old = _picks_by_type_old(info, ref_meg=ref_meg)
assert_object_equal(old, picks_by_type)
# test bads
info = info.copy()
info["bads"] = [info["chs"][picks_by_type[0][1][0]]["ch_name"]]
picks_by_type = deepcopy(picks_by_type)
picks_by_type[0] = (picks_by_type[0][0], picks_by_type[0][1][1:])
actual = _picks_by_type(info, ref_meg=ref_meg)
assert_object_equal(actual, picks_by_type)
def test_pick_seeg_ecog():
"""Test picking with sEEG and ECoG."""
names = "A1 A2 Fz O OTp1 OTp2 E1 OTp3 E2 E3".split()
types = "mag mag eeg eeg seeg seeg ecog seeg ecog ecog".split()
info = create_info(names, 1024.0, types)
picks_by_type = [
("mag", [0, 1]),
("eeg", [2, 3]),
("seeg", [4, 5, 7]),
("ecog", [6, 8, 9]),
]
assert_indexing(info, picks_by_type)
assert_array_equal(pick_types(info, meg=False, seeg=True), [4, 5, 7])
for i, t in enumerate(types):
assert channel_type(info, i) == types[i]
raw = RawArray(np.zeros((len(names), 10)), info)
events = np.array([[1, 0, 0], [2, 0, 0]])
epochs = Epochs(
raw,
events=events,
event_id={"event": 0},
tmin=-1e-5,
tmax=1e-5,
baseline=(0, 0),
) # only one sample
evoked = epochs.average(pick_types(epochs.info, meg=True, seeg=True))
e_seeg = evoked.copy().pick(picks="seeg")
for lt, rt in zip(e_seeg.ch_names, [names[4], names[5], names[7]]):
assert lt == rt
# Deal with constant debacle
raw = read_raw_fif(io_dir / "tests" / "data" / "test_chpi_raw_sss.fif")
assert len(pick_types(raw.info, meg=False, seeg=True, ecog=True)) == 0
def test_pick_dbs():
"""Test picking with DBS."""
# gh-8739
names = "A1 A2 Fz O OTp1 OTp2 OTp3".split()
types = "mag mag eeg eeg dbs dbs dbs".split()
info = create_info(names, 1024.0, types)
picks_by_type = [("mag", [0, 1]), ("eeg", [2, 3]), ("dbs", [4, 5, 6])]
assert_indexing(info, picks_by_type)
assert_array_equal(pick_types(info, meg=False, dbs=True), [4, 5, 6])
for i, t in enumerate(types):
assert channel_type(info, i) == types[i]
raw = RawArray(np.zeros((len(names), 7)), info)
events = np.array([[1, 0, 0], [2, 0, 0]])
epochs = Epochs(
raw,
events=events,
event_id={"event": 0},
tmin=-1e-5,
tmax=1e-5,
baseline=(0, 0),
) # only one sample
evoked = epochs.average(pick_types(epochs.info, meg=True, dbs=True))
e_dbs = evoked.copy().pick(picks="dbs")
for lt, rt in zip(e_dbs.ch_names, [names[4], names[5], names[6]]):
assert lt == rt
raw = read_raw_fif(io_dir / "tests" / "data" / "test_chpi_raw_sss.fif")
assert len(pick_types(raw.info, meg=False, dbs=True)) == 0
def test_pick_chpi():
"""Test picking cHPI."""
# Make sure we don't mis-classify cHPI channels
info = read_info(io_dir / "tests" / "data" / "test_chpi_raw_sss.fif")
_assert_channel_types(info)
channel_types = info.get_channel_types()
assert "chpi" in channel_types
assert "seeg" not in channel_types
assert "ecog" not in channel_types
def test_pick_csd():
"""Test picking current source density channels."""
# Make sure we don't mis-classify cHPI channels
names = ["MEG 2331", "MEG 2332", "MEG 2333", "A1", "A2", "Fz"]
types = "mag mag grad csd csd csd".split()
info = create_info(names, 1024.0, types)
picks_by_type = [("mag", [0, 1]), ("grad", [2]), ("csd", [3, 4, 5])]
assert_indexing(info, picks_by_type, all_data=False)
def test_pick_bio():
"""Test picking BIO channels."""
names = "A1 A2 Fz O BIO1 BIO2 BIO3".split()
types = "mag mag eeg eeg bio bio bio".split()
info = create_info(names, 1024.0, types)
picks_by_type = [("mag", [0, 1]), ("eeg", [2, 3]), ("bio", [4, 5, 6])]
assert_indexing(info, picks_by_type, all_data=False)
def test_pick_fnirs():
"""Test picking fNIRS channels."""
names = "A1 A2 Fz O hbo1 hbo2 hbr1 fnirsRaw1 fnirsRaw2 fnirsOD1".split()
types = (
"mag mag eeg eeg hbo hbo hbr fnirs_cw_"
"amplitude fnirs_cw_amplitude fnirs_od".split()
)
info = create_info(names, 1024.0, types)
picks_by_type = [
("mag", [0, 1]),
("eeg", [2, 3]),
("hbo", [4, 5]),
("hbr", [6]),
("fnirs_cw_amplitude", [7, 8]),
("fnirs_od", [9]),
]
assert_indexing(info, picks_by_type)
def test_pick_ref():
"""Test picking ref_meg channels."""
info = read_info(ctf_fname)
picks_by_type = [
("stim", [0]),
("eog", [306, 307]),
("ecg", [308]),
("misc", [1]),
("mag", np.arange(31, 306)),
("ref_meg", np.arange(2, 31)),
]
assert_indexing(info, picks_by_type, all_data=False)
picks_by_type.append(
("mag", np.concatenate([picks_by_type.pop(-1)[1], picks_by_type.pop(-1)[1]]))
)
assert_indexing(info, picks_by_type, ref_meg=True, all_data=False)
def _check_fwd_n_chan_consistent(fwd, n_expected):
n_ok = len(fwd["info"]["ch_names"])
n_sol = fwd["sol"]["data"].shape[0]
assert n_expected == n_sol
assert n_expected == n_ok
@testing.requires_testing_data
def test_pick_forward_seeg_ecog():
"""Test picking forward with SEEG and ECoG."""
fwd = read_forward_solution(fname_meeg)
counts = channel_indices_by_type(fwd["info"])
for key in counts.keys():
counts[key] = len(counts[key])
counts["meg"] = counts["mag"] + counts["grad"]
fwd_ = pick_types_forward(fwd, meg=True)
_check_fwd_n_chan_consistent(fwd_, counts["meg"])
fwd_ = pick_types_forward(fwd, meg=False, eeg=True)
_check_fwd_n_chan_consistent(fwd_, counts["eeg"])
# should raise exception related to emptiness
pytest.raises(ValueError, pick_types_forward, fwd, meg=False, seeg=True)
pytest.raises(ValueError, pick_types_forward, fwd, meg=False, ecog=True)
# change last chan from EEG to sEEG, second-to-last to ECoG
ecog_name = "E1"
seeg_name = "OTp1"
rename_channels(fwd["info"], {"EEG 059": ecog_name})
rename_channels(fwd["info"], {"EEG 060": seeg_name})
for ch in fwd["info"]["chs"]:
if ch["ch_name"] == seeg_name:
ch["kind"] = FIFF.FIFFV_SEEG_CH
ch["coil_type"] = FIFF.FIFFV_COIL_EEG
elif ch["ch_name"] == ecog_name:
ch["kind"] = FIFF.FIFFV_ECOG_CH
ch["coil_type"] = FIFF.FIFFV_COIL_EEG
fwd["sol"]["row_names"][-1] = fwd["info"]["chs"][-1]["ch_name"]
fwd["sol"]["row_names"][-2] = fwd["info"]["chs"][-2]["ch_name"]
counts["eeg"] -= 2
counts["seeg"] += 1
counts["ecog"] += 1
# repick & check
fwd_seeg = pick_types_forward(fwd, meg=False, seeg=True)
assert fwd_seeg["sol"]["row_names"] == [seeg_name]
assert fwd_seeg["info"]["ch_names"] == [seeg_name]
# should work fine
fwd_ = pick_types_forward(fwd, meg=True)
_check_fwd_n_chan_consistent(fwd_, counts["meg"])
fwd_ = pick_types_forward(fwd, meg=False, eeg=True)
_check_fwd_n_chan_consistent(fwd_, counts["eeg"])
fwd_ = pick_types_forward(fwd, meg=False, seeg=True)
_check_fwd_n_chan_consistent(fwd_, counts["seeg"])
fwd_ = pick_types_forward(fwd, meg=False, ecog=True)
_check_fwd_n_chan_consistent(fwd_, counts["ecog"])
def test_picks_by_channels():
"""Test creating pick_lists."""
rng = np.random.RandomState(909)
test_data = rng.random_sample((4, 2000))
ch_names = [f"MEG {i:03d}" for i in [1, 2, 3, 4]]
ch_types = ["grad", "mag", "mag", "eeg"]
sfreq = 250.0
info = create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
_assert_channel_types(info)
raw = RawArray(test_data, info)
pick_list = _picks_by_type(raw.info)
assert len(pick_list) == 3
assert pick_list[0][0] == "mag"
pick_list2 = _picks_by_type(raw.info, meg_combined=False)
assert len(pick_list) == len(pick_list2)
assert pick_list2[0][0] == "mag"
pick_list2 = _picks_by_type(raw.info, meg_combined=True)
assert len(pick_list) == len(pick_list2) + 1
assert pick_list2[0][0] == "meg"
test_data = rng.random_sample((4, 2000))
ch_names = [f"MEG {i:03d}" for i in [1, 2, 3, 4]]
ch_types = ["mag", "mag", "mag", "mag"]
sfreq = 250.0
info = create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
raw = RawArray(test_data, info)
# This acts as a set, not an order
assert_array_equal(
pick_channels(info["ch_names"], ["MEG 002", "MEG 001"], ordered=False), [0, 1]
)
# Make sure checks for list input work.
pytest.raises(ValueError, pick_channels, ch_names, "MEG 001")
pytest.raises(ValueError, pick_channels, ch_names, ["MEG 001"], "hi")
pick_list = _picks_by_type(raw.info)
assert len(pick_list) == 1
assert pick_list[0][0] == "mag"
pick_list2 = _picks_by_type(raw.info, meg_combined=True)
assert len(pick_list) == len(pick_list2)
assert pick_list2[0][0] == "mag"
# pick_types type check
with pytest.raises(ValueError, match="must be of type"):
raw.pick_types(eeg="string")
# duplicate check
names = ["MEG 002", "MEG 002"]
assert len(pick_channels(raw.info["ch_names"], names, ordered=False)) == 1
assert len(raw.copy().pick_channels(names, ordered=False)[0][0]) == 1
# missing ch_name
bad_names = names + ["BAD"]
with pytest.raises(ValueError, match="Missing channels"):
pick_channels(raw.info["ch_names"], bad_names, ordered=True)
with pytest.raises(ValueError, match="Missing channels"):
raw.copy().pick_channels(bad_names, ordered=True) # legacy method OK here
with pytest.raises(ValueError, match="could not be picked"):
raw.copy().pick(bad_names)
def test_clean_info_bads():
"""Test cleaning info['bads'] when bad_channels are excluded."""
raw_file = io_dir / "tests" / "data" / "test_raw.fif"
raw = read_raw_fif(raw_file)
_assert_channel_types(raw.info)
# select eeg channels
picks_eeg = pick_types(raw.info, meg=False, eeg=True)
# select 3 eeg channels as bads
idx_eeg_bad_ch = picks_eeg[[1, 5, 14]]
eeg_bad_ch = [raw.info["ch_names"][k] for k in idx_eeg_bad_ch]
# select meg channels
picks_meg = pick_types(raw.info, meg=True, eeg=False)
# select randomly 3 meg channels as bads
idx_meg_bad_ch = picks_meg[[0, 15, 34]]
meg_bad_ch = [raw.info["ch_names"][k] for k in idx_meg_bad_ch]
# simulate the bad channels
raw.info["bads"] = eeg_bad_ch + meg_bad_ch
assert len(raw.info["projs"]) == 3
raw.set_eeg_reference(projection=True)
assert len(raw.info["projs"]) == 4
# simulate the call to pick_info excluding the bad eeg channels
info_eeg = pick_info(raw.info, picks_eeg)
assert len(info_eeg["projs"]) == 1
# simulate the call to pick_info excluding the bad meg channels
info_meg = pick_info(raw.info, picks_meg)
assert len(info_meg["projs"]) == 3
assert info_eeg["bads"] == eeg_bad_ch
assert info_meg["bads"] == meg_bad_ch
info = pick_info(raw.info, picks_meg)
info._check_consistency()
with pytest.raises(ValueError, match="do not exist"):
info["bads"] += ["EEG 053"]
with pytest.raises(ValueError, match="unique"):
pick_info(raw.info, [0, 0])
@testing.requires_testing_data
def test_picks_to_idx():
"""Test checking type integrity checks of picks."""
info = create_info(12, 1000.0, "eeg")
_assert_channel_types(info)
picks = np.arange(info["nchan"])
# Array and list
assert_array_equal(picks, _picks_to_idx(info, picks))
assert_array_equal(picks, _picks_to_idx(info, list(picks)))
with pytest.raises(TypeError, match="data type float64 is invalid"):
_picks_to_idx(info, 1.0)
# None
assert_array_equal(picks, _picks_to_idx(info, None))
# Type indexing
assert_array_equal(picks, _picks_to_idx(info, "eeg"))
assert_array_equal(picks, _picks_to_idx(info, ["eeg"]))
# Negative indexing
assert_array_equal([len(picks) - 1], _picks_to_idx(info, len(picks) - 1))
assert_array_equal([len(picks) - 1], _picks_to_idx(info, -1))
assert_array_equal([len(picks) - 1], _picks_to_idx(info, [-1]))
# Name indexing
assert_array_equal([2], _picks_to_idx(info, info["ch_names"][2]))
assert_array_equal(np.arange(5, 9), _picks_to_idx(info, info["ch_names"][5:9]))
with pytest.raises(IndexError, match="must be >= "):
_picks_to_idx(info, -len(picks) - 1)
with pytest.raises(IndexError, match="must be < "):
_picks_to_idx(info, len(picks))
with pytest.raises(ValueError, match="could not be interpreted"):
_picks_to_idx(info, ["a", "b"])
with pytest.raises(ValueError, match="could not be interpreted"):
_picks_to_idx(info, "b")
# bads behavior
info["bads"] = info["ch_names"][1:2]
picks_good = np.array([0] + list(range(2, 12)))
assert_array_equal(picks_good, _picks_to_idx(info, None))
assert_array_equal(picks_good, _picks_to_idx(info, None, exclude=info["bads"]))
assert_array_equal(picks, _picks_to_idx(info, None, exclude=()))
with pytest.raises(ValueError, match=" 1D, got"):
_picks_to_idx(info, [[1]])
# MEG types
info = read_info(fname_mc)
meg_picks = np.arange(306)
mag_picks = np.arange(2, 306, 3)
grad_picks = np.setdiff1d(meg_picks, mag_picks)
assert_array_equal(meg_picks, _picks_to_idx(info, "meg"))
assert_array_equal(meg_picks, _picks_to_idx(info, ("mag", "grad")))
assert_array_equal(mag_picks, _picks_to_idx(info, "mag"))
assert_array_equal(grad_picks, _picks_to_idx(info, "grad"))
info = create_info(["eeg", "foo"], 1000.0, "eeg")
with pytest.raises(RuntimeError, match="equivalent to channel types"):
_picks_to_idx(info, "eeg")
with pytest.raises(ValueError, match="same length"):
create_info(["a", "b"], 1000.0, dict(hbo=["a"], hbr=["b"]))
info = create_info(["a", "b"], 1000.0, ["hbo", "hbr"])
assert_array_equal(np.arange(2), _picks_to_idx(info, "fnirs"))
assert_array_equal([0], _picks_to_idx(info, "hbo"))
assert_array_equal([1], _picks_to_idx(info, "hbr"))
info = create_info(["a", "b"], 1000.0, ["hbo", "misc"])
assert_array_equal(np.arange(len(info["ch_names"])), _picks_to_idx(info, "all"))
assert_array_equal([0], _picks_to_idx(info, "data"))
info = create_info(["a", "b"], 1000.0, ["fnirs_cw_amplitude", "fnirs_od"])
assert_array_equal(np.arange(2), _picks_to_idx(info, "fnirs"))
assert_array_equal([0], _picks_to_idx(info, "fnirs_cw_amplitude"))
assert_array_equal([1], _picks_to_idx(info, "fnirs_od"))
info = create_info(["a", "b"], 1000.0, ["fnirs_cw_amplitude", "misc"])
assert_array_equal(np.arange(len(info["ch_names"])), _picks_to_idx(info, "all"))
assert_array_equal([0], _picks_to_idx(info, "data"))
info = create_info(["a", "b"], 1000.0, ["fnirs_od", "misc"])
assert_array_equal(np.arange(len(info["ch_names"])), _picks_to_idx(info, "all"))
assert_array_equal([0], _picks_to_idx(info, "data"))
# MEG reference sensors
info_ref = read_info(ctf_fname)
picks_meg = pick_types(info_ref, meg=True, ref_meg=False)
assert len(picks_meg) == 275
picks_ref = pick_types(info_ref, meg=False, ref_meg=True)
assert len(picks_ref) == 29
picks_meg_ref = np.sort(np.concatenate([picks_meg, picks_ref]))
assert len(picks_meg_ref) == 275 + 29
assert_array_equal(picks_meg_ref, pick_types(info_ref, meg=True, ref_meg=True))
assert_array_equal(picks_meg, _picks_to_idx(info_ref, "meg", with_ref_meg=False))
assert_array_equal( # explicit trumps implicit
picks_ref, _picks_to_idx(info_ref, "ref_meg", with_ref_meg=False)
)
assert_array_equal(picks_meg_ref, _picks_to_idx(info_ref, "meg", with_ref_meg=True))
# Eyetrack
info = create_info(["a", "b"], 1000.0, ["eyegaze", "pupil"])
assert_array_equal(np.arange(2), _picks_to_idx(info, "eyetrack"))
assert_array_equal([0], _picks_to_idx(info, "eyegaze"))
assert_array_equal([1], _picks_to_idx(info, "pupil"))
def test_pick_channels_cov():
"""Test picking channels from a Covariance object."""
info = create_info(["CH1", "CH2", "CH3"], 1.0, ch_types="eeg")
cov = make_ad_hoc_cov(info)
cov["data"] = np.array([1.0, 2.0, 3.0])
cov_copy = pick_channels_cov(cov, ["CH2", "CH1"], ordered=False, copy=True)
assert cov_copy.ch_names == ["CH1", "CH2"]
assert_array_equal(cov_copy["data"], [1.0, 2.0])
# Test re-ordering channels
cov_copy = pick_channels_cov(cov, ["CH2", "CH1"], ordered=True, copy=True)
assert cov_copy.ch_names == ["CH2", "CH1"]
assert_array_equal(cov_copy["data"], [2.0, 1.0])
# Test picking in-place
pick_channels_cov(cov, ["CH2", "CH1"], copy=False, ordered=False)
assert cov.ch_names == ["CH1", "CH2"]
assert_array_equal(cov["data"], [1.0, 2.0])
# Test whether `method` and `loglik` are dropped when None
cov["method"] = None
cov["loglik"] = None
cov_copy = pick_channels_cov(cov, ["CH1", "CH2"], copy=True)
assert "method" not in cov_copy
assert "loglik" not in cov_copy
def test_pick_types_meg():
"""Test pick_types(meg=True)."""
# info with MEG channels at indices 1, 2, and 4
info1 = create_info(6, 256, ["eeg", "mag", "grad", "misc", "grad", "hbo"])
assert list(pick_types(info1, meg=True)) == [1, 2, 4]
assert list(pick_types(info1, meg=True, eeg=True)) == [0, 1, 2, 4]
assert list(pick_types(info1, meg=True)) == [1, 2, 4]
assert not list(pick_types(info1, meg=False)) # empty
assert list(pick_types(info1, meg="planar1")) == [2]
assert not list(pick_types(info1, meg="planar2")) # empty
# info without any MEG channels
info2 = create_info(6, 256, ["eeg", "eeg", "eog", "misc", "stim", "hbo"])
assert not list(pick_types(info2)) # empty
assert list(pick_types(info2, eeg=True)) == [0, 1]
def test_pick_types_csd():
"""Test pick_types(csd=True)."""
# info with laplacian/CSD channels at indices 1, 2
names = ["F1", "F2", "C1", "C2", "A1", "A2", "misc1", "CSD1"]
info1 = create_info(
names, 256, ["eeg", "eeg", "eeg", "eeg", "mag", "mag", "misc", "csd"]
)
raw = RawArray(np.zeros((8, 512)), info1)
raw.set_montage(make_standard_montage("standard_1020"), verbose="error")
raw_csd = compute_current_source_density(raw, verbose="error")
assert_array_equal(pick_types(info1, csd=True), [7])
# pick from the raw object
assert raw_csd.copy().pick("csd").ch_names == [
"F1",
"F2",
"C1",
"C2",
"CSD1",
]
@pytest.mark.parametrize("meg", [True, False, "grad", "mag"])
@pytest.mark.parametrize("eeg", [True, False])
@pytest.mark.parametrize("ordered", [True, False])
def test_get_channel_types_equiv(meg, eeg, ordered):
"""Test equivalence of get_channel_types."""
raw = read_raw_fif(fif_fname)
pick_types(raw.info, meg=meg, eeg=eeg)
picks = pick_types(raw.info, meg=meg, eeg=eeg)
if not ordered:
picks = np.random.RandomState(0).permutation(picks)
if not meg and not eeg:
with pytest.raises(ValueError, match="No appropriate channels"):
raw.get_channel_types(picks=picks)
return
types = np.array(raw.get_channel_types(picks=picks))
types_iter = np.array([channel_type(raw.info, idx) for idx in picks])
assert_array_equal(types, types_iter)
Datasets
Models
