def test_resample(): """Test resample (with I/O and multiple files) """ raw = Raw(fif_fname, preload=True).crop(0, 3, False) raw_resamp = raw.copy() sfreq = raw.info['sfreq'] # test parallel on upsample raw_resamp.resample(sfreq * 2, n_jobs=2) assert_true(raw_resamp.n_times == len(raw_resamp._times)) raw_resamp.save(op.join(tempdir, 'raw_resamp.fif')) raw_resamp = Raw(op.join(tempdir, 'raw_resamp.fif'), preload=True) assert_true(sfreq == raw_resamp.info['sfreq'] / 2) assert_true(raw.n_times == raw_resamp.n_times / 2) assert_true(raw_resamp._data.shape[1] == raw_resamp.n_times) assert_true(raw._data.shape[0] == raw_resamp._data.shape[0]) # test non-parallel on downsample raw_resamp.resample(sfreq, n_jobs=1) assert_true(raw_resamp.info['sfreq'] == sfreq) assert_true(raw._data.shape == raw_resamp._data.shape) assert_true(raw.first_samp == raw_resamp.first_samp) assert_true(raw.last_samp == raw.last_samp) # upsampling then downsampling doubles resampling error, but this still # works (hooray). Note that the stim channels had to be sub-sampled # without filtering to be accurately preserved # note we have to treat MEG and EEG+STIM channels differently (tols) assert_allclose(raw._data[:306, 200:-200], raw_resamp._data[:306, 200:-200], rtol=1e-2, atol=1e-12) assert_allclose(raw._data[306:, 200:-200], raw_resamp._data[306:, 200:-200], rtol=1e-2, atol=1e-7) # now check multiple file support w/resampling, as order of operations # (concat, resample) should not affect our data raw1 = raw.copy() raw2 = raw.copy() raw3 = raw.copy() raw4 = raw.copy() raw1 = concatenate_raws([raw1, raw2]) raw1.resample(10) raw3.resample(10) raw4.resample(10) raw3 = concatenate_raws([raw3, raw4]) assert_array_equal(raw1._data, raw3._data) assert_array_equal(raw1._first_samps, raw3._first_samps) assert_array_equal(raw1._last_samps, raw3._last_samps) assert_array_equal(raw1._raw_lengths, raw3._raw_lengths) assert_equal(raw1.first_samp, raw3.first_samp) assert_equal(raw1.last_samp, raw3.last_samp) assert_equal(raw1.info['sfreq'], raw3.info['sfreq'])
def test_crop(): """Test cropping raw files """ # split a concatenated file to test a difficult case raw = Raw([fif_fname, fif_fname], preload=True) split_size = 10. # in seconds sfreq = raw.info['sfreq'] nsamp = (raw.last_samp - raw.first_samp + 1) # do an annoying case (off-by-one splitting) tmins = np.r_[1., np.round(np.arange(0., nsamp - 1, split_size * sfreq))] tmins = np.sort(tmins) tmaxs = np.concatenate((tmins[1:] - 1, [nsamp - 1])) tmaxs /= sfreq tmins /= sfreq raws = [None] * len(tmins) for ri, (tmin, tmax) in enumerate(zip(tmins, tmaxs)): raws[ri] = raw.crop(tmin, tmax, True) all_raw_2 = concatenate_raws(raws, preload=True) assert_true(raw.first_samp == all_raw_2.first_samp) assert_true(raw.last_samp == all_raw_2.last_samp) assert_array_equal(raw[:, :][0], all_raw_2[:, :][0]) tmins = np.round(np.arange(0., nsamp - 1, split_size * sfreq)) tmaxs = np.concatenate((tmins[1:] - 1, [nsamp - 1])) tmaxs /= sfreq tmins /= sfreq # going in revere order so the last fname is the first file (need it later) raws = [None] * len(tmins) for ri, (tmin, tmax) in enumerate(zip(tmins, tmaxs)): raws[ri] = raw.copy() raws[ri].crop(tmin, tmax, False) # test concatenation of split file all_raw_1 = concatenate_raws(raws, preload=True) all_raw_2 = raw.crop(0, None, True) for ar in [all_raw_1, all_raw_2]: assert_true(raw.first_samp == ar.first_samp) assert_true(raw.last_samp == ar.last_samp) assert_array_equal(raw[:, :][0], ar[:, :][0])
def test_multiple_files(): """Test loading multiple files simultaneously """ # split file raw = Raw(fif_fname, preload=True) split_size = 10. # in seconds sfreq = raw.info['sfreq'] nsamp = (raw.last_samp - raw.first_samp) tmins = np.round(np.arange(0., nsamp, split_size * sfreq)) tmaxs = np.concatenate((tmins[1:] - 1, [nsamp])) tmaxs /= sfreq tmins /= sfreq # going in reverse order so the last fname is the first file (need later) raws = [None] * len(tmins) for ri in range(len(tmins) - 1, -1, -1): fname = op.join(tempdir, 'test_raw_split-%d_raw.fif' % ri) raw.save(fname, tmin=tmins[ri], tmax=tmaxs[ri]) raws[ri] = Raw(fname) events = [find_events(r) for r in raws] last_samps = [r.last_samp for r in raws] first_samps = [r.first_samp for r in raws] # test concatenation of split file all_raw_1 = concatenate_raws(raws, preload=False) assert_true(raw.first_samp == all_raw_1.first_samp) assert_true(raw.last_samp == all_raw_1.last_samp) assert_array_almost_equal(raw[:, :][0], all_raw_1[:, :][0]) raws[0] = Raw(fname) all_raw_2 = concatenate_raws(raws, preload=True) assert_array_almost_equal(raw[:, :][0], all_raw_2[:, :][0]) # test proper event treatment for split files events = concatenate_events(events, first_samps, last_samps) events2 = find_events(all_raw_2) assert_array_equal(events, events2) # test various methods of combining files n_combos = 9 raw_combos = [None] * n_combos raw = Raw(fif_fname, preload=True) raw_combos[0] = Raw([fif_fname, fif_fname], preload=True) raw_combos[1] = Raw([fif_fname, fif_fname], preload=False) raw_combos[2] = Raw([fif_fname, fif_fname], preload='memmap8.dat') assert_raises(ValueError, Raw, [fif_fname, ctf_fname]) assert_raises(ValueError, Raw, [fif_fname, fif_bad_marked_fname]) n_times = len(raw._times) assert_true(raw[:, :][0].shape[1] * 2 == raw_combos[0][:, :][0].shape[1]) assert_true(raw_combos[0][:, :][0].shape[1] == len(raw_combos[0]._times)) # with all data preloaded, result should be preloaded raw_combos[3] = Raw(fif_fname, preload=True) raw_combos[3].append(Raw(fif_fname, preload=True)) assert_true(raw_combos[0]._preloaded == True) # with any data not preloaded, don't set result as preloaded raw_combos[4] = concatenate_raws([Raw(fif_fname, preload=True), Raw(fif_fname, preload=False)]) assert_true(raw_combos[1]._preloaded == False) assert_array_equal(find_events(raw_combos[4]), find_events(raw_combos[0])) # user should be able to force data to be preloaded upon concat raw_combos[5] = concatenate_raws([Raw(fif_fname, preload=False), Raw(fif_fname, preload=True)], preload=True) assert_true(raw_combos[2]._preloaded == True) raw_combos[6] = concatenate_raws([Raw(fif_fname, preload=False), Raw(fif_fname, preload=True)], preload='memmap3.dat') raw_combos[7] = concatenate_raws([Raw(fif_fname, preload=True), Raw(fif_fname, preload=True)], preload='memmap4.dat') raw_combos[8] = concatenate_raws([Raw(fif_fname, preload=False), Raw(fif_fname, preload=False)], preload='memmap5.dat') # make sure that all our data match times = range(0, 2 * n_times, 999) # add potentially problematic points times.extend([n_times - 1, n_times, 2 * n_times - 1]) for ti in times: # let's do a subset of points for speed orig = raw[:, ti % n_times][0] for raw_combo in raw_combos: # these are almost_equals because of possible dtype differences assert_array_almost_equal(orig, raw_combo[:, ti][0]) # verify that combining raws with different projectors throws an exception raw.add_proj([], remove_existing=True) assert_raises(ValueError, raw.append, Raw(fif_fname, preload=True)) # now test event treatment for concatenated raw files events = [find_events(raw), find_events(raw)] last_samps = [raw.last_samp, raw.last_samp] first_samps = [raw.first_samp, raw.first_samp] events = concatenate_events(events, first_samps, last_samps) events2 = find_events(raw_combos[0]) assert_array_equal(events, events2) # check out the len method assert_true(len(raw) == raw.n_times) assert_true(len(raw) == raw.last_samp - raw.first_samp + 1)
def test_multiple_files(): """Test loading multiple files simultaneously """ # split file raw = Raw(fif_fname, preload=True).crop(0, 10) split_size = 3. # in seconds sfreq = raw.info['sfreq'] nsamp = (raw.last_samp - raw.first_samp) tmins = np.round(np.arange(0., nsamp, split_size * sfreq)) tmaxs = np.concatenate((tmins[1:] - 1, [nsamp])) tmaxs /= sfreq tmins /= sfreq assert_equal(raw.n_times, len(raw._times)) # going in reverse order so the last fname is the first file (need later) raws = [None] * len(tmins) for ri in range(len(tmins) - 1, -1, -1): fname = op.join(tempdir, 'test_raw_split-%d_raw.fif' % ri) raw.save(fname, tmin=tmins[ri], tmax=tmaxs[ri]) raws[ri] = Raw(fname) events = [find_events(r, stim_channel='STI 014') for r in raws] last_samps = [r.last_samp for r in raws] first_samps = [r.first_samp for r in raws] # test concatenation of split file all_raw_1 = concatenate_raws(raws, preload=False) assert_true(raw.first_samp == all_raw_1.first_samp) assert_true(raw.last_samp == all_raw_1.last_samp) assert_allclose(raw[:, :][0], all_raw_1[:, :][0]) raws[0] = Raw(fname) all_raw_2 = concatenate_raws(raws, preload=True) assert_allclose(raw[:, :][0], all_raw_2[:, :][0]) # test proper event treatment for split files events = concatenate_events(events, first_samps, last_samps) events2 = find_events(all_raw_2, stim_channel='STI 014') assert_array_equal(events, events2) # test various methods of combining files raw = Raw(fif_fname, preload=True) n_times = len(raw._times) # make sure that all our data match times = list(range(0, 2 * n_times, 999)) # add potentially problematic points times.extend([n_times - 1, n_times, 2 * n_times - 1]) raw_combo0 = Raw([fif_fname, fif_fname], preload=True) _compare_combo(raw, raw_combo0, times, n_times) raw_combo = Raw([fif_fname, fif_fname], preload=False) _compare_combo(raw, raw_combo, times, n_times) raw_combo = Raw([fif_fname, fif_fname], preload='memmap8.dat') _compare_combo(raw, raw_combo, times, n_times) assert_raises(ValueError, Raw, [fif_fname, ctf_fname]) assert_raises(ValueError, Raw, [fif_fname, fif_bad_marked_fname]) assert_true(raw[:, :][0].shape[1] * 2 == raw_combo0[:, :][0].shape[1]) assert_true(raw_combo0[:, :][0].shape[1] == len(raw_combo0._times)) # with all data preloaded, result should be preloaded raw_combo = Raw(fif_fname, preload=True) raw_combo.append(Raw(fif_fname, preload=True)) assert_true(raw_combo._preloaded is True) assert_true(len(raw_combo._times) == raw_combo._data.shape[1]) _compare_combo(raw, raw_combo, times, n_times) # with any data not preloaded, don't set result as preloaded raw_combo = concatenate_raws([Raw(fif_fname, preload=True), Raw(fif_fname, preload=False)]) assert_true(raw_combo._preloaded is False) assert_array_equal(find_events(raw_combo, stim_channel='STI 014'), find_events(raw_combo0, stim_channel='STI 014')) _compare_combo(raw, raw_combo, times, n_times) # user should be able to force data to be preloaded upon concat raw_combo = concatenate_raws([Raw(fif_fname, preload=False), Raw(fif_fname, preload=True)], preload=True) assert_true(raw_combo._preloaded is True) _compare_combo(raw, raw_combo, times, n_times) raw_combo = concatenate_raws([Raw(fif_fname, preload=False), Raw(fif_fname, preload=True)], preload='memmap3.dat') _compare_combo(raw, raw_combo, times, n_times) raw_combo = concatenate_raws([Raw(fif_fname, preload=True), Raw(fif_fname, preload=True)], preload='memmap4.dat') _compare_combo(raw, raw_combo, times, n_times) raw_combo = concatenate_raws([Raw(fif_fname, preload=False), Raw(fif_fname, preload=False)], preload='memmap5.dat') _compare_combo(raw, raw_combo, times, n_times) # verify that combining raws with different projectors throws an exception raw.add_proj([], remove_existing=True) assert_raises(ValueError, raw.append, Raw(fif_fname, preload=True)) # now test event treatment for concatenated raw files events = [find_events(raw, stim_channel='STI 014'), find_events(raw, stim_channel='STI 014')] last_samps = [raw.last_samp, raw.last_samp] first_samps = [raw.first_samp, raw.first_samp] events = concatenate_events(events, first_samps, last_samps) events2 = find_events(raw_combo0, stim_channel='STI 014') assert_array_equal(events, events2) # check out the len method assert_true(len(raw) == raw.n_times) assert_true(len(raw) == raw.last_samp - raw.first_samp + 1)
def test_multiple_files(): """Test loading multiple files simultaneously """ # split file raw = Raw(fif_fname, preload=True) split_size = 10. # in seconds sfreq = raw.info['sfreq'] nsamp = (raw.last_samp - raw.first_samp) tmins = np.round(np.arange(0., nsamp, split_size * sfreq)) tmaxs = np.concatenate((tmins[1:] - 1, [nsamp])) tmaxs /= sfreq tmins /= sfreq # going in reverse order so the last fname is the first file (need later) raws = [None] * len(tmins) for ri in range(len(tmins) - 1, -1, -1): fname = op.join(tempdir, 'test_raw_split-%d_raw.fif' % ri) raw.save(fname, tmin=tmins[ri], tmax=tmaxs[ri]) raws[ri] = Raw(fname) events = [find_events(r, stim_channel='STI 014') for r in raws] last_samps = [r.last_samp for r in raws] first_samps = [r.first_samp for r in raws] # test concatenation of split file all_raw_1 = concatenate_raws(raws, preload=False) assert_true(raw.first_samp == all_raw_1.first_samp) assert_true(raw.last_samp == all_raw_1.last_samp) assert_allclose(raw[:, :][0], all_raw_1[:, :][0]) raws[0] = Raw(fname) all_raw_2 = concatenate_raws(raws, preload=True) assert_allclose(raw[:, :][0], all_raw_2[:, :][0]) # test proper event treatment for split files events = concatenate_events(events, first_samps, last_samps) events2 = find_events(all_raw_2, stim_channel='STI 014') assert_array_equal(events, events2) # test various methods of combining files n_combos = 9 raw_combos = [None] * n_combos raw = Raw(fif_fname, preload=True) raw_combos[0] = Raw([fif_fname, fif_fname], preload=True) raw_combos[1] = Raw([fif_fname, fif_fname], preload=False) raw_combos[2] = Raw([fif_fname, fif_fname], preload='memmap8.dat') assert_raises(ValueError, Raw, [fif_fname, ctf_fname]) assert_raises(ValueError, Raw, [fif_fname, fif_bad_marked_fname]) n_times = len(raw._times) assert_true(raw[:, :][0].shape[1] * 2 == raw_combos[0][:, :][0].shape[1]) assert_true(raw_combos[0][:, :][0].shape[1] == len(raw_combos[0]._times)) # with all data preloaded, result should be preloaded raw_combos[3] = Raw(fif_fname, preload=True) raw_combos[3].append(Raw(fif_fname, preload=True)) assert_true(raw_combos[0]._preloaded == True) assert_true(len(raw_combos[3]._times) == raw_combos[3]._data.shape[1]) # with any data not preloaded, don't set result as preloaded raw_combos[4] = concatenate_raws( [Raw(fif_fname, preload=True), Raw(fif_fname, preload=False)]) assert_true(raw_combos[1]._preloaded == False) assert_array_equal(find_events(raw_combos[4], stim_channel='STI 014'), find_events(raw_combos[0], stim_channel='STI 014')) # user should be able to force data to be preloaded upon concat raw_combos[5] = concatenate_raws( [Raw(fif_fname, preload=False), Raw(fif_fname, preload=True)], preload=True) assert_true(raw_combos[2]._preloaded == True) raw_combos[6] = concatenate_raws( [Raw(fif_fname, preload=False), Raw(fif_fname, preload=True)], preload='memmap3.dat') raw_combos[7] = concatenate_raws( [Raw(fif_fname, preload=True), Raw(fif_fname, preload=True)], preload='memmap4.dat') raw_combos[8] = concatenate_raws( [Raw(fif_fname, preload=False), Raw(fif_fname, preload=False)], preload='memmap5.dat') # make sure that all our data match times = range(0, 2 * n_times, 999) # add potentially problematic points times.extend([n_times - 1, n_times, 2 * n_times - 1]) for ti in times: # let's do a subset of points for speed orig = raw[:, ti % n_times][0] for raw_combo in raw_combos: # these are almost_equals because of possible dtype differences assert_allclose(orig, raw_combo[:, ti][0]) # verify that combining raws with different projectors throws an exception raw.add_proj([], remove_existing=True) assert_raises(ValueError, raw.append, Raw(fif_fname, preload=True)) # now test event treatment for concatenated raw files events = [ find_events(raw, stim_channel='STI 014'), find_events(raw, stim_channel='STI 014') ] last_samps = [raw.last_samp, raw.last_samp] first_samps = [raw.first_samp, raw.first_samp] events = concatenate_events(events, first_samps, last_samps) events2 = find_events(raw_combos[0], stim_channel='STI 014') assert_array_equal(events, events2) # check out the len method assert_true(len(raw) == raw.n_times) assert_true(len(raw) == raw.last_samp - raw.first_samp + 1)