def filter(self):
"""Apply the constructed filter.
Returns
-------
A TimeSeries object.
"""
channel_axis = self.timeseries[self.channels_dim]
ch0 = self.bipolar_pairs[self.chan_names[0]]
ch1 = self.bipolar_pairs[self.chan_names[1]]
sel0 = channel_axis.loc[ch0]
sel1 = channel_axis.loc[ch1]
ts0 = self.timeseries.loc[{self.channels_dim: sel0}]
ts1 = self.timeseries.loc[{self.channels_dim: sel1}]
dims_bp = list(self.timeseries.dims)
coords_bp = {
coord_name: coord
for coord_name, coord in list(self.timeseries.coords.items())
}
coords_bp[self.channels_dim] = self.bipolar_pairs
ts = TimeSeries(data=ts0.values - ts1.values,
dims=dims_bp,
coords=coords_bp)
ts['samplerate'] = self.timeseries['samplerate']
ts.attrs = self.timeseries.attrs.copy()
ts.name = self.timeseries.name
return ts
def filter(self):
"""
Applies Butterwoth filter to input time series and returns filtered TimeSeriesX object
Returns
-------
filtered: TimeSeries
The filtered time series
"""
time_axis_index = get_axis_index(self.timeseries, axis_name='time')
filtered_array = buttfilt(self.timeseries,
self.freq_range,
float(self.timeseries['samplerate']),
self.filt_type,
self.order,
axis=time_axis_index)
coords_dict = {
coord_name: DataArray(coord.copy())
for coord_name, coord in list(self.timeseries.coords.items())
}
coords_dict['samplerate'] = self.timeseries['samplerate']
dims = [dim_name for dim_name in self.timeseries.dims]
filtered_timeseries = TimeSeries(filtered_array,
dims=dims,
coords=coords_dict)
# filtered_timeseries = TimeSeries(filtered_timeseries)
filtered_timeseries.attrs = self.timeseries.attrs.copy()
return filtered_timeseries
def read_session_data(self):
"""
Reads entire session worth of data
:return: TimeSeries object (channels x events x time) with data for entire session the events dimension has length 1
"""
brr = self.READER_FILETYPE_DICT[os.path.splitext(self.session_dataroot)[-1]](dataroot=self.session_dataroot, channels=self.channels)
session_array,read_ok_mask = brr.read()
self.channel_name = brr.channel_name
offsets_axis = session_array['offsets']
number_of_time_points = offsets_axis.shape[0]
samplerate = float(session_array['samplerate'])
physical_time_array = np.arange(number_of_time_points) * (1.0 / samplerate)
# session_array = session_array.rename({'start_offsets': 'events'})
session_time_series = TimeSeries(session_array.values,
dims=[self.channel_name, 'start_offsets', 'time'],
coords={
self.channel_name: session_array[self.channel_name],
'start_offsets': session_array['start_offsets'],
'time': physical_time_array,
'offsets': ('time', session_array['offsets']),
'samplerate': session_array['samplerate']
}
)
session_time_series.attrs = session_array.attrs.copy()
session_time_series.attrs['dataroot'] = self.session_dataroot
return session_time_series
def read_events_data(self):
"""
Reads eeg data for individual event
:return: TimeSeries object (channels x events x time) with data for individual events
"""
self.event_ok_mask_sorted = None # reset self.event_ok_mask_sorted
evs = self.events
raw_readers, original_dataroots = self.__create_base_raw_readers()
# used for restoring original order of the events
ordered_indices = np.arange(len(evs))
event_indices_list = []
events = []
ts_array_list = []
event_ok_mask_list = []
for s, (raw_reader, dataroot) in enumerate(zip(raw_readers, original_dataroots)):
ts_array, read_ok_mask = raw_reader.read()
event_ok_mask_list.append(np.all(read_ok_mask,axis=0))
ind = np.atleast_1d(evs.eegfile == dataroot)
event_indices_list.append(ordered_indices[ind])
events.append(evs[ind])
ts_array_list.append(ts_array)
if not all([r.channel_name==raw_readers[0].channel_name for r in raw_readers]):
raise IncompatibleDataError('cannot read monopolar and bipolar data together')
self.channel_name = raw_readers[0].channel_name
event_indices_array = np.hstack(event_indices_list)
event_indices_restore_sort_order_array = event_indices_array.argsort()
eventdata = xr.concat(ts_array_list, dim='start_offsets')
samplerate = float(eventdata['samplerate'])
tdim = np.arange(eventdata.shape[-1]) * (1.0 / samplerate) + (self.start_time - self.buffer_time)
cdim = eventdata[self.channel_name]
edim = np.rec.array(np.concatenate(events))
attrs = eventdata.attrs.copy()
eventdata = TimeSeries(eventdata.data,
dims=[self.channel_name, 'events', 'time'],
coords={self.channel_name: cdim,
'events': edim,
'time': tdim,
'samplerate': samplerate
}
)
eventdata.attrs = attrs
# restoring original order of the events
eventdata = eventdata[:, event_indices_restore_sort_order_array, :]
event_ok_mask = np.hstack(event_ok_mask_list)
event_ok_mask_sorted = event_ok_mask[event_indices_restore_sort_order_array]
# removing bad events
if self.remove_bad_events:
if np.any(~event_ok_mask_sorted):
warnings.warn("Found some bad events. Removing!", UserWarning)
self.removed_corrupt_events = True
self.event_ok_mask_sorted = event_ok_mask_sorted
eventdata = eventdata[:, event_ok_mask_sorted, :]
return eventdata
