def test_locale_encoding(tmp_path):
"""Test NIRx encoding."""
fname = tmp_path / 'latin'
shutil.copytree(fname_nirx_15_2, fname)
hdr_fname = op.join(fname, 'NIRS-2019-10-02_003.hdr')
hdr = list()
with open(hdr_fname, 'rb') as fid:
hdr.extend(line for line in fid)
# French
hdr[2] = b'Date="jeu. 13 f\xe9vr. 2020"\r\n'
with open(hdr_fname, 'wb') as fid:
for line in hdr:
fid.write(line)
read_raw_nirx(fname, verbose='debug')
# German
hdr[2] = b'Date="mi 13 dez 2020"\r\n'
with open(hdr_fname, 'wb') as fid:
for line in hdr:
fid.write(line)
read_raw_nirx(fname, verbose='debug')
# Italian
hdr[2] = b'Date="ven 24 gen 2020"\r\n'
hdr[3] = b'Time="10:57:41.454"\r\n'
with open(hdr_fname, 'wb') as fid:
for line in hdr:
fid.write(line)
raw = read_raw_nirx(fname, verbose='debug')
want_dt = dt.datetime(
2020, 1, 24, 10, 57, 41, 454000, tzinfo=dt.timezone.utc)
assert raw.info['meas_date'] == want_dt
def test_nirsport_v1_w_bad_sat(preload, meas_date):
"""Test NIRSport1 file with NaNs."""
fname = nirsport1_w_fullsat
raw = read_raw_nirx(fname, preload=preload)
data = raw.get_data()
assert not np.isnan(data).any()
assert len(raw.annotations) == 5
# annotated version and ignore should have same data but different annot
raw_ignore = read_raw_nirx(fname, saturated='ignore', preload=preload)
assert_allclose(raw_ignore.get_data(), data)
assert len(raw_ignore.annotations) == 2
assert not any('NAN' in d for d in raw_ignore.annotations.description)
# nan version should not have same data, but we can give it the same annot
raw_nan = read_raw_nirx(fname, saturated='nan', preload=preload)
data_nan = raw_nan.get_data()
assert np.isnan(data_nan).any()
assert not np.allclose(raw_nan.get_data(), data)
raw_nan_annot = raw_ignore.copy()
if meas_date is None:
raw.set_meas_date(None)
raw_nan.set_meas_date(None)
raw_nan_annot.set_meas_date(None)
nan_annots = annotate_nan(raw_nan)
assert nan_annots.orig_time == raw_nan.info["meas_date"]
raw_nan_annot.set_annotations(nan_annots)
use_mask = np.where(raw.annotations.description == 'BAD_SATURATED')
for key in ('onset', 'duration'):
a = getattr(raw_nan_annot.annotations, key)[::2] # one ch in each
b = getattr(raw.annotations, key)[use_mask] # two chs in each
assert_allclose(a, b)
def test_fnirs_check_bads(fname):
"""Test checking of bad markings."""
# No bad channels, so these should all pass
raw = read_raw_nirx(fname)
_fnirs_check_bads(raw.info)
raw = optical_density(raw)
_fnirs_check_bads(raw.info)
raw = beer_lambert_law(raw)
_fnirs_check_bads(raw.info)
# Mark pairs of bad channels, so these should all pass
raw = read_raw_nirx(fname)
raw.info['bads'] = raw.ch_names[0:2]
_fnirs_check_bads(raw.info)
raw = optical_density(raw)
_fnirs_check_bads(raw.info)
raw = beer_lambert_law(raw)
_fnirs_check_bads(raw.info)
# Mark single channel as bad, so these should all fail
raw = read_raw_nirx(fname)
raw.info['bads'] = raw.ch_names[0:1]
pytest.raises(RuntimeError, _fnirs_check_bads, raw.info)
with pytest.raises(RuntimeError, match='bad labelling'):
raw = optical_density(raw)
pytest.raises(RuntimeError, _fnirs_check_bads, raw.info)
with pytest.raises(RuntimeError, match='bad labelling'):
raw = beer_lambert_law(raw)
pytest.raises(RuntimeError, _fnirs_check_bads, raw.info)
def test_nirx_dat_warn(tmp_path):
"""Test reading NIRX files when missing data."""
shutil.copytree(fname_nirx_15_2_short, str(tmp_path) + "/data/")
os.rename(tmp_path / "data" / "NIRS-2019-08-23_001.dat",
tmp_path / "data" / "NIRS-2019-08-23_001.tmp")
fname = tmp_path / "data" / "NIRS-2019-08-23_001.hdr"
with pytest.raises(RuntimeWarning, match='A single dat'):
read_raw_nirx(fname, preload=True)
def test_encoding(tmpdir):
"""Test NIRx encoding."""
fname = str(tmpdir.join('latin'))
shutil.copytree(fname_nirx_15_2, fname)
hdr_fname = op.join(fname, 'NIRS-2019-10-02_003.hdr')
hdr = list()
with open(hdr_fname, 'rb') as fid:
hdr.extend(line for line in fid)
hdr[2] = b'Date="jeu. 13 f\xe9vr. 2020"\r\n'
with open(hdr_fname, 'wb') as fid:
for line in hdr:
fid.write(line)
# smoke test
read_raw_nirx(fname)
def test_encoding(tmp_path):
"""Test NIRx encoding."""
fname = tmp_path / 'latin'
shutil.copytree(fname_nirx_15_2, fname)
hdr_fname = op.join(fname, 'NIRS-2019-10-02_003.hdr')
hdr = list()
with open(hdr_fname, 'rb') as fid:
hdr.extend(line for line in fid)
hdr[2] = b'Date="jeu. 13 f\xe9vr. 2020"\r\n'
with open(hdr_fname, 'wb') as fid:
for line in hdr:
fid.write(line)
# smoke test
with pytest.raises(RuntimeWarning, match='Extraction of measurement date'):
read_raw_nirx(fname)
def test_label_finder():
"""Test locating labels."""
raw = read_raw_nirx(fname_nirx_15_3_short, preload=True)
reference_locations = _generate_montage_locations()
# Test central head position source
raw_tmp = raw.copy().pick(25)
assert _find_closest_standard_location(
raw_tmp.info['chs'][0]['loc'][3:6],
reference_locations) == "Cz"
# Test right auditory position detector
raw_tmp = raw.copy().pick(4)
assert _find_closest_standard_location(
raw_tmp.info['chs'][0]['loc'][6:9],
reference_locations) == "T8"
# Test right auditory position source
raw_tmp = raw.copy().pick(4)
assert _find_closest_standard_location(
raw_tmp.info['chs'][0]['loc'][3:6],
reference_locations) == "TP8"
# Test left auditory position source
raw_tmp = raw.copy().pick(1)
assert _find_closest_standard_location(
raw_tmp.info['chs'][0]['loc'][3:6],
reference_locations) == "T7"
# Test left auditory position detector
raw_tmp = raw.copy().pick(1)
assert _find_closest_standard_location(
raw_tmp.info['chs'][0]['loc'][6:9],
reference_locations) == "TP7"
def test_fold_workflow():
# Read raw data
raw = read_raw_nirx(fname_nirx_15_3_short, preload=True)
reference_locations = _generate_montage_locations()
channel_of_interest = raw.copy().pick(1)
# Get source and detector labels
source_locs = channel_of_interest.info['chs'][0]['loc'][3:6]
source_label = _find_closest_standard_location(source_locs,
reference_locations)
assert source_label == "T7"
detector_locs = channel_of_interest.info['chs'][0]['loc'][6:9]
detector_label = _find_closest_standard_location(detector_locs,
reference_locations)
assert detector_label == "TP7"
# Find correct fOLD elements
tbl = _read_fold_xls(foldfile, atlas="Juelich")
tbl = tbl.query("Source == @source_label").\
query("Detector == @detector_label")
# Query region of interest
specificity = tbl.query("Landmark == 'L Mid Orbital Gyrus'")["Specificity"]
assert specificity.values == 12.34
def test_temporal_derivative_distribution_repair(fname, tmp_path):
"""Test running artifact rejection."""
raw = read_raw_nirx(fname)
raw_od = optical_density(raw)
raw_hb = beer_lambert_law(raw_od)
# With optical densities
# Add a baseline shift artifact about half way through data
max_shift = np.max(np.diff(raw_od._data[0]))
shift_amp = 5 * max_shift
raw_od._data[0, 0:30] = raw_od._data[0, 0:30] - shift_amp
# make one channel zero std
raw_od._data[1] = 0.
raw_od._data[2] = 1.
assert np.max(np.diff(raw_od._data[0])) > shift_amp
# Ensure that applying the algorithm reduces the step change
raw_od = tddr(raw_od)
assert np.max(np.diff(raw_od._data[0])) < shift_amp
assert_allclose(raw_od._data[1], 0.) # unchanged
assert_allclose(raw_od._data[2], 1.) # unchanged
# With Hb
# Add a baseline shift artifact about half way through data
max_shift = np.max(np.diff(raw_hb._data[0]))
shift_amp = 5 * max_shift
raw_hb._data[0, 0:30] = raw_hb._data[0, 0:30] - (1.1 * shift_amp)
# make one channel zero std
raw_hb._data[1] = 0.
raw_hb._data[2] = 1.
assert np.max(np.diff(raw_hb._data[0])) > shift_amp
# Ensure that applying the algorithm reduces the step change
raw_hb = tddr(raw_hb)
assert np.max(np.diff(raw_hb._data[0])) < shift_amp
assert_allclose(raw_hb._data[1], 0.) # unchanged
assert_allclose(raw_hb._data[2], 1.) # unchanged
def test_beer_lambert_v_matlab():
"""Compare MNE results to MATLAB toolbox."""
from pymatreader import read_mat
raw = read_raw_nirx(fname_nirx_15_0)
raw = optical_density(raw)
raw = beer_lambert_law(raw, ppf=0.121)
raw._data *= 1e6 # Scale to uM for comparison to MATLAB
matlab_fname = op.join(testing_path, 'NIRx', 'nirscout', 'validation',
'nirx_15_0_recording_bl.mat')
matlab_data = read_mat(matlab_fname)
matlab_names = ["_"] * len(raw.ch_names)
for idx in range(len(raw.ch_names)):
matlab_names[idx] = ("S" + str(int(matlab_data['sources'][idx])) +
"_D" + str(int(matlab_data['detectors'][idx])) +
" " + matlab_data['type'][idx])
matlab_to_mne = np.argsort(matlab_names)
for idx in range(raw.get_data().shape[0]):
matlab_idx = matlab_to_mne[idx]
mean_error = np.mean(matlab_data['data'][:, matlab_idx] -
raw._data[idx])
assert mean_error < 0.1
matlab_name = ("S" + str(int(matlab_data['sources'][matlab_idx])) +
"_D" + str(int(matlab_data['detectors'][matlab_idx])) +
" " + matlab_data['type'][matlab_idx])
assert raw.info['ch_names'][idx] == matlab_name
def test_optical_density_zeromean():
"""Test that optical density can process zero mean data."""
raw = read_raw_nirx(fname_nirx, preload=True)
raw._data[4] -= np.mean(raw._data[4])
with pytest.warns(RuntimeWarning, match='Negative'):
raw = optical_density(raw)
assert 'fnirs_od' in raw
def test_scalp_coupling_index(fname, fmt, tmpdir):
"""Test converting NIRX files."""
assert fmt in ('nirx', 'fif')
raw = read_raw_nirx(fname)
raw = optical_density(raw)
sci = scalp_coupling_index(raw)
# All values should be between -1 and +1
assert_array_less(sci, 1.0)
assert_array_less(sci * -1.0, 1.0)
# Fill in some data with known correlation values
rng = np.random.RandomState(0)
new_data = rng.rand(raw._data[0].shape[0])
# Set first two channels to perfect correlation
raw._data[0] = new_data
raw._data[1] = new_data
# Set next two channels to perfect correlation
raw._data[2] = new_data
raw._data[3] = new_data * 0.3 # check scale invariance
# Set next two channels to anti correlation
raw._data[4] = new_data
raw._data[5] = new_data * -1.0
# Set next two channels to be uncorrelated
raw._data[6] = new_data
raw._data[7] = rng.rand(raw._data[0].shape[0])
# Check values
sci = scalp_coupling_index(raw)
assert_allclose(sci[0:6], [1, 1, 1, 1, -1, -1], atol=0.01)
assert np.abs(sci[6]) < 0.5
assert np.abs(sci[7]) < 0.5
def test_snirf_write(fname, tmpdir):
"""Test reading NIRX files."""
raw_orig = read_raw_nirx(fname, preload=True)
write_raw_snirf(raw_orig, tmpdir.join('test_raw.snirf'))
raw = read_raw_snirf(tmpdir.join('test_raw.snirf'))
# Check annotations are the same
assert_allclose(raw.annotations.onset, raw_orig.annotations.onset)
assert_allclose([float(d) for d in raw.annotations.description],
[float(d) for d in raw_orig.annotations.description])
assert_allclose(raw.annotations.duration, raw_orig.annotations.duration)
# Check data is the same
assert_allclose(raw.get_data(), raw_orig.get_data())
assert abs(raw_orig.info["meas_date"] - raw.info["meas_date"]) < \
datetime.timedelta(seconds=1)
# Check info object is the same
obj_diff = object_diff(raw.info, raw_orig.info)
diffs = ''
for line in obj_diff.splitlines():
if ('logno' not in line) and ('scanno' not in line) and\
('datetime mismatch' not in line):
# logno and scanno are not used in processing
diffs += f'\n{line}'
assert diffs == ''
def test_nirx_15_2():
"""Test reading NIRX files."""
raw = read_raw_nirx(fname_nirx_15_2, preload=True)
# Test data import
assert raw._data.shape == (64, 67)
assert raw.info['sfreq'] == 3.90625
# Test channel naming
assert raw.info['ch_names'][:4] == [
"S1_D1 760", "S1_D1 850", "S1_D10 760", "S1_D10 850"
]
# Test info import
assert raw.info['subject_info'] == dict(sex=1, first_name="TestRecording")
# Test trigger events
assert_array_equal(raw.annotations.description, ['4.0', '6.0', '2.0'])
# Test location of detectors
allowed_dist_error = 0.0002
locs = [ch['loc'][6:9] for ch in raw.info['chs']]
head_mri_t, _ = _get_trans('fsaverage', 'head', 'mri')
mni_locs = apply_trans(head_mri_t, locs)
assert raw.info['ch_names'][0][3:5] == 'D1'
assert_allclose(mni_locs[0], [-0.0292, 0.0852, -0.0142],
atol=allowed_dist_error)
assert raw.info['ch_names'][15][3:5] == 'D4'
assert_allclose(mni_locs[15], [-0.0739, -0.0756, -0.0075],
atol=allowed_dist_error)
def test_beer_lambert(fname, fmt, tmpdir):
"""Test converting NIRX files."""
assert fmt in ('nirx', 'fif')
raw = read_raw_nirx(fname)
if fmt == 'fif':
raw.save(tmpdir.join('test_raw.fif'))
raw = read_raw_fif(tmpdir.join('test_raw.fif'))
assert 'fnirs_cw_amplitude' in raw
with pytest.deprecated_call():
assert 'fnirs_raw' in raw
assert 'fnirs_od' not in raw
raw = optical_density(raw)
_validate_type(raw, BaseRaw, 'raw')
assert 'fnirs_cw_amplitude' not in raw
with pytest.deprecated_call():
assert 'fnirs_raw' not in raw
assert 'fnirs_od' in raw
assert 'hbo' not in raw
raw = beer_lambert_law(raw)
_validate_type(raw, BaseRaw, 'raw')
assert 'fnirs_cw_amplitude' not in raw
with pytest.deprecated_call():
assert 'fnirs_raw' not in raw
assert 'fnirs_od' not in raw
assert 'hbo' in raw
assert 'hbr' in raw
def test_fnirs_picks():
"""Test picking of fnirs types after different conversions."""
raw = read_raw_nirx(fname_nirx_15_0)
picks = _picks_to_idx(raw.info, 'fnirs_cw_amplitude')
assert len(picks) == len(raw.ch_names)
raw_subset = raw.copy().pick(picks='fnirs_cw_amplitude')
for ch in raw_subset.info["chs"]:
assert ch['coil_type'] == FIFF.FIFFV_COIL_FNIRS_CW_AMPLITUDE
picks = _picks_to_idx(raw.info, ['fnirs_cw_amplitude', 'fnirs_od'])
assert len(picks) == len(raw.ch_names)
picks = _picks_to_idx(raw.info, ['fnirs_cw_amplitude', 'fnirs_od', 'hbr'])
assert len(picks) == len(raw.ch_names)
pytest.raises(ValueError, _picks_to_idx, raw.info, 'fnirs_od')
pytest.raises(ValueError, _picks_to_idx, raw.info, 'hbo')
pytest.raises(ValueError, _picks_to_idx, raw.info, ['hbr'])
pytest.raises(ValueError, _picks_to_idx, raw.info, 'fnirs_fd_phase')
pytest.raises(ValueError, _picks_to_idx, raw.info, 'junk')
raw = optical_density(raw)
picks = _picks_to_idx(raw.info, 'fnirs_od')
assert len(picks) == len(raw.ch_names)
raw_subset = raw.copy().pick(picks='fnirs_od')
for ch in raw_subset.info["chs"]:
assert ch['coil_type'] == FIFF.FIFFV_COIL_FNIRS_OD
picks = _picks_to_idx(raw.info, ['fnirs_cw_amplitude', 'fnirs_od'])
assert len(picks) == len(raw.ch_names)
picks = _picks_to_idx(raw.info, ['fnirs_cw_amplitude', 'fnirs_od', 'hbr'])
assert len(picks) == len(raw.ch_names)
pytest.raises(ValueError, _picks_to_idx, raw.info, 'fnirs_cw_amplitude')
pytest.raises(ValueError, _picks_to_idx, raw.info, 'hbo')
pytest.raises(ValueError, _picks_to_idx, raw.info, 'hbr')
pytest.raises(ValueError, _picks_to_idx, raw.info, 'fnirs_fd_phase')
pytest.raises(ValueError, _picks_to_idx, raw.info, 'junk')
raw = beer_lambert_law(raw)
picks = _picks_to_idx(raw.info, 'hbo')
assert len(picks) == len(raw.ch_names) / 2
raw_subset = raw.copy().pick(picks='hbo')
for ch in raw_subset.info["chs"]:
assert ch['coil_type'] == FIFF.FIFFV_COIL_FNIRS_HBO
picks = _picks_to_idx(raw.info, ['hbr'])
assert len(picks) == len(raw.ch_names) / 2
raw_subset = raw.copy().pick(picks=['hbr'])
for ch in raw_subset.info["chs"]:
assert ch['coil_type'] == FIFF.FIFFV_COIL_FNIRS_HBR
picks = _picks_to_idx(raw.info, ['hbo', 'hbr'])
assert len(picks) == len(raw.ch_names)
picks = _picks_to_idx(raw.info, ['hbo', 'fnirs_od', 'hbr'])
assert len(picks) == len(raw.ch_names)
picks = _picks_to_idx(raw.info, ['hbo', 'fnirs_od'])
assert len(picks) == len(raw.ch_names) / 2
pytest.raises(ValueError, _picks_to_idx, raw.info, 'fnirs_cw_amplitude')
pytest.raises(ValueError, _picks_to_idx, raw.info, ['fnirs_od'])
pytest.raises(ValueError, _picks_to_idx, raw.info, 'junk')
pytest.raises(ValueError, _picks_to_idx, raw.info, 'fnirs_fd_phase')
def test_channel_specificity(monkeypatch, tmp_path, fold_files):
raw = read_raw_nirx(fname_nirx_15_3_short, preload=True)
raw.pick(range(2))
kwargs = dict()
n_want = 6
if fold_files is list:
kwargs = dict(fold_files=[foldfile])
elif fold_files is str:
kwargs = dict(fold_files=tmp_path)
n_want *= 2
else:
assert fold_files is None
monkeypatch.setenv('MNE_NIRS_FOLD_PATH', str(tmp_path))
assert len(kwargs) == 0
with pytest.raises(FileNotFoundError, match=r'fold_files\[0\] does.*'):
fold_channel_specificity(raw)
n_want *= 2
copyfile(foldfile, tmp_path / '10-10.xls')
copyfile(foldfile, tmp_path / '10-5.xls')
res = fold_channel_specificity(raw, **kwargs)
assert len(res) == 2
assert res[0].shape == (n_want, 14)
montage = make_standard_montage(
'standard_1005', head_size=0.09700884729534559)
fids = read_fiducials(
Path(mne.__file__).parent / 'data' / 'fsaverage' /
'fsaverage-fiducials.fif')[0]
for f in fids:
f['coord_frame'] = montage.dig[0]['coord_frame']
montage.dig[:3] = fids
S, D = raw.ch_names[0].split()[0].split('_')
assert S == 'S1' and D == 'D2'
montage.rename_channels({'PO8': S, 'P6': D}) # not in the tables!
# taken from standard_1020.elc
s_mri = np.array([55.6666, -97.6251, 2.7300]) / 1000.
d_mri = np.array([67.8877, -75.9043, 28.0910]) / 1000.
trans = mne.transforms._get_trans('fsaverage', 'mri', 'head')[0]
ch_pos = montage.get_positions()['ch_pos']
assert_allclose(ch_pos[S], s_mri, atol=1e-6)
assert_allclose(ch_pos[D], d_mri, atol=1e-6)
raw.set_montage(montage)
montage = transform_to_head(montage)
s_head = mne.transforms.apply_trans(trans, s_mri)
d_head = mne.transforms.apply_trans(trans, d_mri)
assert_allclose(montage._get_ch_pos()['S1'], s_head, atol=1e-6)
assert_allclose(montage._get_ch_pos()['D2'], d_head, atol=1e-6)
for ch in raw.info['chs']:
assert_allclose(ch['loc'][3:6], s_head, atol=1e-6)
assert_allclose(ch['loc'][6:9], d_head, atol=1e-6)
res_1 = fold_channel_specificity(raw, **kwargs)[0]
assert res_1.shape == (0, 14)
# TODO: This is wrong, should be P08 not P08h, and distance should be 0 mm!
with pytest.warns(RuntimeWarning, match='.*PO8h?/P6.*TP8/T8.*'):
res_1 = fold_channel_specificity(raw, interpolate=True, **kwargs)[0]
montage.rename_channels({S: D, D: S}) # reversed
with pytest.warns(RuntimeWarning, match='.*PO8h?/P6.*TP8/T8.*'):
res_2 = fold_channel_specificity(raw, interpolate=True, **kwargs)[0]
# We should check the whole thing, but this is probably good enough
assert (res_1['Specificity'] == res_2['Specificity']).all()
def test_nirx_missing_evt(tmp_path):
"""Test reading NIRX files when missing data."""
shutil.copytree(fname_nirx_15_2_short, str(tmp_path) + "/data/")
os.rename(tmp_path / "data" / "NIRS-2019-08-23_001.evt",
tmp_path / "data" / "NIRS-2019-08-23_001.xxx")
fname = tmp_path / "data" / "NIRS-2019-08-23_001.hdr"
raw = read_raw_nirx(fname, preload=True)
assert raw.annotations.onset.shape == (0, )
def test_nirx_hdr_load():
"""Test reading NIRX files using path to header file."""
fname = fname_nirx_15_2_short + "/NIRS-2019-08-23_001.hdr"
raw = read_raw_nirx(fname, preload=True)
# Test data import
assert raw._data.shape == (26, 145)
assert raw.info['sfreq'] == 12.5
def test_snirf_nobday(fname, tmpdir):
"""Ensure writing works when no birthday is present."""
raw_orig = read_raw_nirx(fname, preload=True)
raw_orig.info['subject_info'].pop('birthday', None)
test_file = tmpdir.join('test_raw.snirf')
write_raw_snirf(raw_orig, test_file)
raw = read_raw_snirf(test_file)
assert_allclose(raw.get_data(), raw_orig.get_data())
def test_channel_order(fname, want_order):
"""Test that logical channel order is preserved."""
raw = read_raw_nirx(fname)
ch_names = raw.ch_names
prefixes = [ch_name.split()[0] for ch_name in ch_names]
assert prefixes[::2] == prefixes[1::2]
prefixes = prefixes[::2]
assert prefixes == want_order
def test_landmark_specificity():
raw = read_raw_nirx(fname_nirx_15_3_short, preload=True)
with pytest.warns(RuntimeWarning, match='No fOLD table entry'):
res = fold_landmark_specificity(raw, "L Superior Frontal Gyrus",
[foldfile], interpolate=True)
assert len(res) == len(raw.ch_names)
assert np.max(res) <= 100
assert np.min(res) >= 0
def test_nirx_15_0():
"""Test reading NIRX files."""
raw = read_raw_nirx(fname_nirx_15_0, preload=True)
# Test data import
assert raw._data.shape == (20, 92)
assert raw.info['sfreq'] == 6.25
assert raw.info['meas_date'] == dt.datetime(2019,
10,
27,
13,
53,
34,
209000,
tzinfo=dt.timezone.utc)
# Test channel naming
assert raw.info['ch_names'][:12] == [
"S1_D1 760", "S1_D1 850", "S2_D2 760", "S2_D2 850", "S3_D3 760",
"S3_D3 850", "S4_D4 760", "S4_D4 850", "S5_D5 760", "S5_D5 850",
"S6_D6 760", "S6_D6 850"
]
# Test info import
assert raw.info['subject_info'] == {
'birthday': (2004, 10, 27),
'first_name': 'NIRX',
'last_name': 'Test',
'sex': FIFF.FIFFV_SUBJ_SEX_UNKNOWN,
'his_id': "NIRX_Test"
}
# Test trigger events
assert_array_equal(raw.annotations.description, ['1.0', '2.0', '2.0'])
# Test location of detectors
allowed_dist_error = 0.0002
locs = [ch['loc'][6:9] for ch in raw.info['chs']]
head_mri_t, _ = _get_trans('fsaverage', 'head', 'mri')
mni_locs = apply_trans(head_mri_t, locs)
assert raw.info['ch_names'][0][3:5] == 'D1'
assert_allclose(mni_locs[0], [0.0287, -0.1143, -0.0332],
atol=allowed_dist_error)
assert raw.info['ch_names'][15][3:5] == 'D8'
assert_allclose(mni_locs[15], [-0.0693, -0.0480, 0.0657],
atol=allowed_dist_error)
# Test distance between optodes matches values from
allowed_distance_error = 0.0002
assert_allclose(source_detector_distances(
raw.copy().pick("S1_D1 760").info), [0.0300],
atol=allowed_distance_error)
assert_allclose(source_detector_distances(
raw.copy().pick("S7_D7 760").info), [0.0392],
atol=allowed_distance_error)
def test_optical_density():
"""Test return type for optical density."""
raw = read_raw_nirx(fname_nirx, preload=False)
assert 'fnirs_cw_amplitude' in raw
assert 'fnirs_od' not in raw
raw = optical_density(raw)
_validate_type(raw, BaseRaw, 'raw')
assert 'fnirs_cw_amplitude' not in raw
assert 'fnirs_od' in raw
def test_fnirs_channel_naming_and_order_readers(fname):
"""Ensure fNIRS channel checking on standard readers."""
# fNIRS data requires specific channel naming and ordering.
# All standard readers should pass tests
raw = read_raw_nirx(fname)
freqs = np.unique(_channel_frequencies(raw.info))
assert_array_equal(freqs, [760, 850])
chroma = np.unique(_channel_chromophore(raw.info))
assert len(chroma) == 0
picks = _check_channels_ordered(raw.info, freqs)
assert len(picks) == len(raw.ch_names) # as all fNIRS only data
# Check that dropped channels are detected
# For each source detector pair there must be two channels,
# removing one should throw an error.
raw_dropped = raw.copy().drop_channels(raw.ch_names[4])
with pytest.raises(ValueError, match='not ordered correctly'):
_check_channels_ordered(raw_dropped.info, freqs)
# The ordering must be increasing for the pairs, if provided
raw_names_reversed = raw.copy().ch_names
raw_names_reversed.reverse()
raw_reversed = raw.copy().pick_channels(raw_names_reversed, ordered=True)
with pytest.raises(ValueError, match='The frequencies.*sorted.*'):
_check_channels_ordered(raw_reversed.info, [850, 760])
# So if we flip the second argument it should pass again
picks = _check_channels_ordered(raw_reversed.info, freqs)
got_first = set(raw_reversed.ch_names[pick].split()[1]
for pick in picks[::2])
assert got_first == {'760'}
got_second = set(raw_reversed.ch_names[pick].split()[1]
for pick in picks[1::2])
assert got_second == {'850'}
# Check on OD data
raw = optical_density(raw)
freqs = np.unique(_channel_frequencies(raw.info))
assert_array_equal(freqs, [760, 850])
chroma = np.unique(_channel_chromophore(raw.info))
assert len(chroma) == 0
picks = _check_channels_ordered(raw.info, freqs)
assert len(picks) == len(raw.ch_names) # as all fNIRS only data
# Check on haemoglobin data
raw = beer_lambert_law(raw)
freqs = np.unique(_channel_frequencies(raw.info))
assert len(freqs) == 0
assert len(_channel_chromophore(raw.info)) == len(raw.ch_names)
chroma = np.unique(_channel_chromophore(raw.info))
assert_array_equal(chroma, ["hbo", "hbr"])
picks = _check_channels_ordered(raw.info, chroma)
assert len(picks) == len(raw.ch_names)
with pytest.raises(ValueError, match='chromophore in info'):
_check_channels_ordered(raw.info, ["hbr", "hbo"])
def fnirs_epochs():
"""Create an fnirs epoch structure."""
raw_intensity = read_raw_nirx(fname_nirx, preload=False)
raw_od = optical_density(raw_intensity)
raw_haemo = beer_lambert_law(raw_od, ppf=6.)
evts, _ = events_from_annotations(raw_haemo, event_id={'1.0': 1})
evts_dct = {'A': 1}
tn, tx = -1, 2
epochs = Epochs(raw_haemo, evts, event_id=evts_dct, tmin=tn, tmax=tx)
return epochs
def test_nirsport_v1_w_sat():
"""Test NIRSport1 file with NaNs but not in channel of interest."""
raw = read_raw_nirx(nirsport1_w_sat)
# Test data import
data = raw.get_data()
assert data.shape == (26, 176)
assert raw.info['sfreq'] == 10.416667
assert np.sum(np.isnan(data)) == 0
raw = read_raw_nirx(nirsport1_w_sat, saturated='nan')
data = raw.get_data()
assert data.shape == (26, 176)
assert np.sum(np.isnan(data)) == 0
raw = read_raw_nirx(nirsport1_w_sat, saturated='annotate')
data = raw.get_data()
assert data.shape == (26, 176)
assert np.sum(np.isnan(data)) == 0
def test_optical_density():
"""Test return type for optical density."""
raw = read_raw_nirx(fname_nirx, preload=False)
assert 'fnirs_cw_amplitude' in raw
assert 'fnirs_od' not in raw
raw = optical_density(raw)
_validate_type(raw, BaseRaw, 'raw')
assert 'fnirs_cw_amplitude' not in raw
assert 'fnirs_od' in raw
with pytest.raises(RuntimeError, match='on continuous wave'):
optical_density(raw)
def test_nirsport_v1_wo_sat():
"""Test NIRSport1 file with no saturation."""
raw = read_raw_nirx(nirsport1_wo_sat, preload=True)
# Test data import
assert raw._data.shape == (26, 164)
assert raw.info['sfreq'] == 10.416667
# By default real data is returned
assert np.sum(np.isnan(raw.get_data())) == 0
raw = read_raw_nirx(nirsport1_wo_sat, preload=True, saturated='nan')
data = raw.get_data()
assert data.shape == (26, 164)
assert np.sum(np.isnan(data)) == 0
raw = read_raw_nirx(nirsport1_wo_sat, saturated='annotate')
data = raw.get_data()
assert data.shape == (26, 164)
assert np.sum(np.isnan(data)) == 0
def test_nirsport_v2_matches_snirf(fname_nirx, fname_snirf):
"""Test NIRSport2 raw files return same data as snirf."""
raw = read_raw_nirx(fname_nirx, preload=True)
raw_snirf = read_raw_snirf(fname_snirf, preload=True)
assert_allclose(raw._data, raw_snirf._data)
# Check the timing of annotations match (naming is different)
assert_allclose(raw.annotations.onset, raw_snirf.annotations.onset)
assert_array_equal(raw.ch_names, raw_snirf.ch_names)