def test_eeg_read_keep_buffer(self):
# OLD READERS
events = self.read_ptsa_events()
# in case fancy indexing looses Eventness of events we need to create Events object explicitely
if not isinstance(events, Events):
events = Events(events)
eegs = events.get_data(channels=['002', '003'],
start_time=0.0,
end_time=1.6,
buffer_time=1.0,
eoffset='eegoffset',
keep_buffer=True,
eoffset_in_time=False,
verbose=True)
# NEW READERS
base_events = self.read_base_events()
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events,
start_time=0.0,
end_time=1.6,
buffer_time=1.0,
keep_buffer=True)
time_series_reader.read(channels=['002', '003'])
base_eegs = time_series_reader.get_output()
# testing
assert_array_equal(eegs, base_eegs.data)
def test_eeg_read_keep_buffer(self):
# OLD READERS
events = self.read_ptsa_events()
# in case fancy indexing looses Eventness of events we need to create Events object explicitely
if not isinstance(events, Events):
events = Events(events)
eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6,
buffer_time=1.0, eoffset='eegoffset', keep_buffer=True,
eoffset_in_time=False, verbose=True)
# NEW READERS
base_events = self.read_base_events()
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events, start_time=0.0,
end_time=1.6, buffer_time=1.0, keep_buffer=True)
time_series_reader.read(channels=['002', '003'])
base_eegs = time_series_reader.get_output()
# testing
assert_array_equal(eegs, base_eegs.data)
def test_eeg_read_keep_buffer_butterworth_filtered(self):
# old readers
events = self.read_ptsa_events()
# in case fancy indexing looses Eventness of events we need to create Events object explicitely
if not isinstance(events, Events):
events = Events(events)
base_events = self.read_base_events()
eegs = events.get_data(channels=['002', '003'],
start_time=0.0,
end_time=1.6,
buffer_time=1.0,
eoffset='eegoffset',
keep_buffer=True,
eoffset_in_time=False,
verbose=True)
# filtering
eegs_filtered = eegs.filtered([58, 62], filt_type='stop', order=4)
# New style reading
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events,
start_time=0.0,
end_time=1.6,
buffer_time=1.0,
keep_buffer=True)
time_series_reader.read(channels=['002', '003'])
base_eegs = time_series_reader.get_output()
from ptsa.data.filters.ButterworthFilter import ButterworthFilter
b_filter = ButterworthFilter(time_series=base_eegs,
samplerate=base_eegs.attrs['samplerate'],
freq_range=[58, 62],
filt_type='stop',
order=4)
base_eegs_filtered = b_filter.filter()
# testing
assert_array_equal(eegs_filtered, base_eegs_filtered.data)
assert_array_equal(eegs, base_eegs.data)
def test_2_old():
import time
start = time.time()
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(event_file=e_path, eliminate_events_with_no_eeg=True, use_ptsa_events_class=False)
base_e_reader.read()
base_events = base_e_reader.get_output()
base_events = base_events[base_events.type == 'WORD']
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
tal_reader = TalReader(tal_filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
print 'bipolar_pairs=', bipolar_pairs
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events, start_time=0.0,
end_time=1.6, buffer_time=1.0, keep_buffer=True)
base_eegs = time_series_reader.read(channels=monopolar_channels)
# base_eegs = base_eegs[:, 0:10, :]
# bipolar_pairs = bipolar_pairs[0:10]
wf = MorletWaveletFilter(time_series=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 2),
# freqs=np.array([3.]),
output='power',
# resamplerate=50.0
)
pow_wavelet, phase_wavelet = wf.filter()
print 'total time = ', time.time() - start
res_start = time.time()
# from ptsa.data.filters.ResampleFilter import ResampleFilter
# rsf = ResampleFilter (resamplerate=50.0)
# rsf.set_input(pow_wavelet)
# pow_wavelet = rsf.filter()
print 'resample_time=', time.time() - res_start
return pow_wavelet
def test_2():
import time
start = time.time()
e_path = '/Users/m/data/events/RAM_FR1/R1060M_events.mat'
from ptsa.data.readers import BaseEventReader
base_e_reader = BaseEventReader(filename=e_path)
base_events = base_e_reader.read()
base_events = base_events[base_events.type == 'WORD']
# selecting only one session
base_events = base_events[base_events.eegfile == base_events[0].eegfile]
from ptsa.data.readers.TalReader import TalReader
tal_path = '/Users/m/data/eeg/R1060M/tal/R1060M_talLocs_database_bipol.mat'
tal_reader = TalReader(filename=tal_path)
monopolar_channels = tal_reader.get_monopolar_channels()
bipolar_pairs = tal_reader.get_bipolar_pairs()
print 'bipolar_pairs=', bipolar_pairs
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events,
start_time=0.0,
end_time=1.6,
buffer_time=1.0,
keep_buffer=True)
base_eegs = time_series_reader.read(channels=monopolar_channels)
# base_eegs = base_eegs[:, 0:10, :]
# bipolar_pairs = bipolar_pairs[0:10]
wf = MorletWaveletFilter(
time_series=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 2),
# freqs=np.array([3.]),
output='power',
)
pow_wavelet, phase_wavelet = wf.filter()
print 'total time = ', time.time() - start
res_start = time.time()
# from ptsa.data.filters.ResampleFilter import ResampleFilter
# rsf = ResampleFilter (resamplerate=50.0)
# rsf.set_input(pow_wavelet)
# pow_wavelet = rsf.filter()
print 'resample_time=', time.time() - res_start
return pow_wavelet
def test_eeg_resample(self):
# old readers
events = self.read_ptsa_events()
# in case fancy indexing looses Eventness of events we need to create Events object explicitely
if not isinstance(events, Events):
events = Events(events)
base_events = self.read_base_events()
eegs = events.get_data(channels=['002', '003'],
start_time=0.0,
end_time=1.6,
buffer_time=1.0,
eoffset='eegoffset',
keep_buffer=True,
eoffset_in_time=False,
verbose=True)
# filtering
eegs_resampled = eegs.resampled(50.0)
# New style reading
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events,
start_time=0.0,
end_time=1.6,
buffer_time=1.0,
keep_buffer=True)
time_series_reader.read(channels=['002', '003'])
base_eegs = time_series_reader.get_output()
from ptsa.data.filters.ResampleFilter import ResampleFilter
resample_filter = ResampleFilter(time_series=base_eegs,
resamplerate=50.0)
base_eegs_resampled = resample_filter.filter()
# testing
assert_array_equal(eegs_resampled, base_eegs_resampled.data)
def test_eeg_read_keep_buffer_butterworth_filtered(self):
# old readers
events = self.read_ptsa_events()
# in case fancy indexing looses Eventness of events we need to create Events object explicitely
if not isinstance(events, Events):
events = Events(events)
base_events = self.read_base_events()
eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6,
buffer_time=1.0, eoffset='eegoffset', keep_buffer=True,
eoffset_in_time=False, verbose=True)
# filtering
eegs_filtered = eegs.filtered([58, 62], filt_type='stop', order=4)
# New style reading
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events, start_time=0.0,
end_time=1.6, buffer_time=1.0, keep_buffer=True)
time_series_reader.read(channels=['002', '003'])
base_eegs = time_series_reader.get_output()
from ptsa.data.filters.ButterworthFilter import ButterworthFilter
b_filter = ButterworthFilter(time_series=base_eegs, samplerate=base_eegs.attrs['samplerate'],
freq_range=[58, 62], filt_type='stop',
order=4)
base_eegs_filtered = b_filter.filter()
# testing
assert_array_equal(eegs_filtered, base_eegs_filtered.data)
assert_array_equal(eegs, base_eegs.data)
def test_eeg_resample(self):
# old readers
events = self.read_ptsa_events()
# in case fancy indexing looses Eventness of events we need to create Events object explicitely
if not isinstance(events, Events):
events = Events(events)
base_events = self.read_base_events()
eegs = events.get_data(channels=['002', '003'], start_time=0.0, end_time=1.6,
buffer_time=1.0, eoffset='eegoffset', keep_buffer=True,
eoffset_in_time=False, verbose=True)
# filtering
eegs_resampled = eegs.resampled(50.0)
# New style reading
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events, start_time=0.0,
end_time=1.6, buffer_time=1.0, keep_buffer=True)
time_series_reader.read(channels=['002', '003'])
base_eegs = time_series_reader.get_output()
from ptsa.data.filters.ResampleFilter import ResampleFilter
resample_filter = ResampleFilter(time_series=base_eegs, resamplerate=50.0)
base_eegs_resampled = resample_filter.filter()
# testing
assert_array_equal(eegs_resampled, base_eegs_resampled.data)
ts_dict = time_series_session_reader.read()
print ts_dict
ts=ts_dict.items()[0][1]
resample_filter_rounded = ResampleFilter(time_series=ts, resamplerate=50.0,round_to_original_timepoints=True)
# resample_filter_rounded = ResampleFilter(time_series=ts, resamplerate=50.0)
base_eegs_resampled_rounded = resample_filter_rounded.filter()
######################################
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events, start_time=0.0,
end_time=1.6, buffer_time=1.0, keep_buffer=True)
base_eegs = time_series_reader.read(channels=['003', '004'])
resample_filter = ResampleFilter(time_series=base_eegs, resamplerate=50.0)
base_eegs_resampled = resample_filter.filter()
resample_filter_rounded = ResampleFilter(time_series=base_eegs, resamplerate=50.0, round_to_original_timepoints=True)
base_eegs_resampled_rounded = resample_filter_rounded.filter()
print
resample_filter_rounded = ResampleFilter(time_series=ts,
resamplerate=50.0,
round_to_original_timepoints=True)
# resample_filter_rounded = ResampleFilter(time_series=ts, resamplerate=50.0)
base_eegs_resampled_rounded = resample_filter_rounded.filter()
######################################
from ptsa.data.experimental.TimeSeriesEEGReader import TimeSeriesEEGReader
time_series_reader = TimeSeriesEEGReader(events=base_events,
start_time=0.0,
end_time=1.6,
buffer_time=1.0,
keep_buffer=True)
base_eegs = time_series_reader.read(channels=['003', '004'])
resample_filter = ResampleFilter(time_series=base_eegs, resamplerate=50.0)
base_eegs_resampled = resample_filter.filter()
resample_filter_rounded = ResampleFilter(time_series=base_eegs,
resamplerate=50.0,
round_to_original_timepoints=True)
base_eegs_resampled_rounded = resample_filter_rounded.filter()
print
