def build_output_arrays(self, wavelet_pow_array, wavelet_phase_array,
time_axis):
wavelet_pow_array_xray = None
wavelet_phase_array_xray = None
if isinstance(self.time_series, xr.DataArray):
dims = list(self.time_series.dims[:-1] + (
'frequency',
'time',
))
transposed_dims = []
# NOTE all computaitons up till this point assume that frequency position is -2 whereas
# the default setting for this filter sets frequency axis index to 0. To avoid unnecessary transpositions
# we need to adjust position of the frequency axis in the internal computations
# getting frequency dim position as positive integer
self.frequency_dim_pos = (len(dims) +
self.frequency_dim_pos) % len(dims)
orig_frequency_idx = dims.index('frequency')
if self.frequency_dim_pos != orig_frequency_idx:
transposed_dims = dims[:orig_frequency_idx] + dims[
orig_frequency_idx + 1:]
transposed_dims.insert(self.frequency_dim_pos, 'frequency')
coords = {
dim_name: self.time_series.coords[dim_name]
for dim_name in self.time_series.dims[:-1]
}
coords['frequency'] = self.freqs
coords['time'] = time_axis
if 'samplerate' not in coords:
coords['samplerate'] = self.time_series.coords['samplerate']
if 'offsets' in list(self.time_series.coords.keys()):
coords['offsets'] = ('time', self.time_series['offsets'])
if wavelet_pow_array is not None:
wavelet_pow_array_xray = TimeSeriesX(wavelet_pow_array,
coords=coords,
dims=dims)
if len(transposed_dims):
wavelet_pow_array_xray = wavelet_pow_array_xray.transpose(
*transposed_dims)
wavelet_pow_array_xray.attrs = self.time_series.attrs.copy()
if wavelet_phase_array is not None:
wavelet_phase_array_xray = TimeSeriesX(wavelet_phase_array,
coords=coords,
dims=dims)
if len(transposed_dims):
wavelet_phase_array_xray = wavelet_phase_array_xray.transpose(
*transposed_dims)
wavelet_phase_array_xray.attrs = self.time_series.attrs.copy()
return wavelet_pow_array_xray, wavelet_phase_array_xray
def build_output_arrays(self, wavelet_pow_array, wavelet_phase_array,
time_axis):
wavelet_pow_array_xray = None
wavelet_phase_array_xray = None
if isinstance(self.time_series, xr.DataArray):
dims = list(self.time_series.dims[:-1] + (
'frequency',
'time',
))
transposed_dims = []
# getting frequency dim position as positive integer
self.frequency_dim_pos = (len(dims) +
self.frequency_dim_pos) % len(dims)
orig_frequency_idx = dims.index('frequency')
if self.frequency_dim_pos != orig_frequency_idx:
transposed_dims = dims[:orig_frequency_idx] + dims[
orig_frequency_idx + 1:]
transposed_dims.insert(self.frequency_dim_pos, 'frequency')
coords = {
dim_name: self.time_series.coords[dim_name]
for dim_name in self.time_series.dims[:-1]
}
coords['frequency'] = self.freqs
coords['time'] = time_axis
if wavelet_pow_array is not None:
wavelet_pow_array_xray = self.construct_output_array(
wavelet_pow_array, dims=dims, coords=coords)
if wavelet_phase_array is not None:
wavelet_phase_array_xray = self.construct_output_array(
wavelet_phase_array, dims=dims, coords=coords)
if wavelet_pow_array_xray is not None:
wavelet_pow_array_xray = TimeSeriesX(wavelet_pow_array_xray)
if len(transposed_dims):
wavelet_pow_array_xray = wavelet_pow_array_xray.transpose(
*transposed_dims)
wavelet_pow_array_xray.attrs = self.time_series.attrs.copy()
if wavelet_phase_array_xray is not None:
wavelet_phase_array_xray = TimeSeriesX(
wavelet_phase_array_xray)
if len(transposed_dims):
wavelet_phase_array_xray = wavelet_phase_array_xray.transpose(
*transposed_dims)
wavelet_phase_array_xray.attrs = self.time_series.attrs.copy()
return wavelet_pow_array_xray, wavelet_phase_array_xray
def build_output_arrays(self, wavelet_pow_array, wavelet_phase_array, time_axis):
wavelet_pow_array_xray = None
wavelet_phase_array_xray = None
if isinstance(self.time_series, xr.DataArray):
dims = list(self.time_series.dims[:-1] + ('frequency', 'time',))
transposed_dims = []
# NOTE all computaitons up till this point assume that frequency position is -2 whereas
# the default setting for this filter sets frequency axis index to 0. To avoid unnecessary transpositions
# we need to adjust position of the frequency axis in the internal computations
# getting frequency dim position as positive integer
self.frequency_dim_pos = (len(dims) + self.frequency_dim_pos) % len(dims)
orig_frequency_idx = dims.index('frequency')
if self.frequency_dim_pos != orig_frequency_idx:
transposed_dims = dims[:orig_frequency_idx] + dims[orig_frequency_idx + 1:]
transposed_dims.insert(self.frequency_dim_pos, 'frequency')
coords = {dim_name: self.time_series.coords[dim_name] for dim_name in self.time_series.dims[:-1]}
coords['frequency'] = self.freqs
coords['time'] = time_axis
if 'offsets' in self.time_series.coords.keys():
coords['offsets'] = ('time', self.time_series['offsets'])
if wavelet_pow_array is not None:
wavelet_pow_array_xray = self.construct_output_array(wavelet_pow_array, dims=dims, coords=coords)
if wavelet_phase_array is not None:
wavelet_phase_array_xray = self.construct_output_array(wavelet_phase_array, dims=dims, coords=coords)
if wavelet_pow_array_xray is not None:
wavelet_pow_array_xray = TimeSeriesX(wavelet_pow_array_xray)
if len(transposed_dims):
wavelet_pow_array_xray = wavelet_pow_array_xray.transpose(*transposed_dims)
wavelet_pow_array_xray.attrs = self.time_series.attrs.copy()
if wavelet_phase_array_xray is not None:
wavelet_phase_array_xray = TimeSeriesX(wavelet_phase_array_xray)
if len(transposed_dims):
wavelet_phase_array_xray = wavelet_phase_array_xray.transpose(*transposed_dims)
wavelet_phase_array_xray.attrs = self.time_series.attrs.copy()
return wavelet_pow_array_xray, wavelet_phase_array_xray
def read_session_data(self):
"""
Reads entire session worth of data
:return: TimeSeriesX object (channels x events x time) with data for entire session the events dimension has length 1
"""
brr = self.READER_FILETYPE_DICT[self.session_dataroot](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 = TimeSeriesX(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_session_data(self):
"""
Reads entire session worth of data
:return: TimeSeriesX object (channels x events x time) with data for entire session the events dimension has length 1
"""
brr = self.READER_FILETYPE_DICT[self.session_dataroot](
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 = TimeSeriesX(
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 filter(self):
"""
Applies Butterwoth filter to input time series and returns filtered TimeSeriesX object
Returns
-------
filtered: TimeSeriesX
The filtered time series
"""
time_axis_index = get_axis_index(self.time_series, axis_name='time')
filtered_array = buttfilt(self.time_series,
self.freq_range,
float(self.time_series['samplerate']),
self.filt_type,
self.order,
axis=time_axis_index)
coords_dict = {
coord_name: DataArray(coord.copy())
for coord_name, coord in list(self.time_series.coords.items())
}
coords_dict['samplerate'] = self.time_series['samplerate']
dims = [dim_name for dim_name in self.time_series.dims]
filtered_time_series = TimeSeriesX(filtered_array,
dims=dims,
coords=coords_dict)
# filtered_time_series = TimeSeriesX(filtered_time_series)
filtered_time_series.attrs = self.time_series.attrs.copy()
return filtered_time_series
def filter(self):
"""
Applies Butterwoth filter to input time series and returns filtered TimeSeriesX object
Returns
-------
filtered: TimeSeriesX
The filtered time series
"""
time_axis_index = get_axis_index(self.time_series, axis_name='time')
filtered_array = buttfilt(self.time_series,
self.freq_range, float(self.time_series['samplerate']), self.filt_type,
self.order, axis=time_axis_index)
coords_dict = {coord_name: DataArray(coord.copy()) for coord_name, coord in list(self.time_series.coords.items())}
coords_dict['samplerate'] = self.time_series['samplerate']
dims = [dim_name for dim_name in self.time_series.dims]
filtered_time_series = TimeSeriesX(
filtered_array,
dims=dims,
coords=coords_dict
)
# filtered_time_series = TimeSeriesX(filtered_time_series)
filtered_time_series.attrs = self.time_series.attrs.copy()
return filtered_time_series
def build_output_arrays(self, wavelet_pow_array, wavelet_phase_array, time_axis):
wavelet_pow_array_xray = None
wavelet_phase_array_xray = None
if isinstance(self.time_series, xray.DataArray):
dims = list(self.time_series.dims[:-1] + ("frequency", "time"))
transposed_dims = []
# getting frequency dim position as positive integer
self.frequency_dim_pos = (len(dims) + self.frequency_dim_pos) % len(dims)
orig_frequency_idx = dims.index("frequency")
if self.frequency_dim_pos != orig_frequency_idx:
transposed_dims = dims[:orig_frequency_idx] + dims[orig_frequency_idx + 1 :]
transposed_dims.insert(self.frequency_dim_pos, "frequency")
coords = {dim_name: self.time_series.coords[dim_name] for dim_name in self.time_series.dims[:-1]}
coords["frequency"] = self.freqs
coords["time"] = time_axis
if wavelet_pow_array is not None:
wavelet_pow_array_xray = self.construct_output_array(wavelet_pow_array, dims=dims, coords=coords)
if wavelet_phase_array is not None:
wavelet_phase_array_xray = self.construct_output_array(wavelet_phase_array, dims=dims, coords=coords)
if wavelet_pow_array_xray is not None:
wavelet_pow_array_xray = TimeSeriesX(wavelet_pow_array_xray)
if len(transposed_dims):
wavelet_pow_array_xray = wavelet_pow_array_xray.transpose(*transposed_dims)
wavelet_pow_array_xray.attrs = self.time_series.attrs.copy()
if wavelet_phase_array_xray is not None:
wavelet_phase_array_xray = TimeSeriesX(wavelet_phase_array_xray)
if len(transposed_dims):
wavelet_phase_array_xray = wavelet_phase_array_xray.transpose(*transposed_dims)
wavelet_phase_array_xray.attrs = self.time_series.attrs.copy()
return wavelet_pow_array_xray, wavelet_phase_array_xray
def filter(self):
"""
Turns time series for monopolar electrodes into time series where where 'channels' axis is replaced by
'bipolar_pairs' axis and the time series data is a difference
between time series corresponding to different electrodes as specified by bipolar pairs
:return: TimeSeriesX object
"""
# a = np.arange(20)*2
#
# template = [2,4,6,6,8,2,4]
#
# sorter = np.argsort(a)
# idx = sorter[np.searchsorted(a, template, sorter=sorter)]
# idx = np.where(a == 6)
#
# print ch0
#
# print ch1
channel_axis = self.time_series['channels']
ch0 = self.bipolar_pairs['ch0']
ch1 = self.bipolar_pairs['ch1']
sel0 = channel_axis.loc[ch0]
sel1 = channel_axis.loc[ch1]
ts0 = self.time_series.loc[dict(channels=sel0)]
ts1 = self.time_series.loc[dict(channels=sel1)]
dims_bp = list(self.time_series.dims)
channels_idx = dims_bp.index('channels')
dims_bp[channels_idx] = 'bipolar_pairs'
# coords_bp = [self.time_series[dim_name].copy() for dim_name in self.time_series.dims]
# coords_bp[channels_idx] = self.bipolar_pairs
coords_bp = {
coord_name: coord
for coord_name, coord in self.time_series.coords.items()
}
del coords_bp['channels']
coords_bp['bipolar_pairs'] = self.bipolar_pairs
ts = TimeSeriesX(data=ts0.values - ts1.values,
dims=dims_bp,
coords=coords_bp)
ts['samplerate'] = self.time_series['samplerate']
ts.attrs = self.time_series.attrs.copy()
return ts
def filter(self):
"""
Turns time series for monopolar electrodes into time series where where 'channels' axis is replaced by
'bipolar_pairs' axis and the time series data is a difference
between time series corresponding to different electrodes as specified by bipolar pairs
:return: TimeSeriesX object
"""
# a = np.arange(20)*2
#
# template = [2,4,6,6,8,2,4]
#
# sorter = np.argsort(a)
# idx = sorter[np.searchsorted(a, template, sorter=sorter)]
# idx = np.where(a == 6)
#
# print ch0
#
# print ch1
channel_axis = self.time_series['channels']
ch0 = self.bipolar_pairs['ch0']
ch1 = self.bipolar_pairs['ch1']
sel0 = channel_axis.loc[ch0]
sel1 = channel_axis.loc[ch1]
ts0 = self.time_series.loc[dict(channels=sel0)]
ts1 = self.time_series.loc[dict(channels=sel1)]
dims_bp = list(self.time_series.dims)
channels_idx = dims_bp.index('channels')
dims_bp[channels_idx] = 'bipolar_pairs'
# coords_bp = [self.time_series[dim_name].copy() for dim_name in self.time_series.dims]
# coords_bp[channels_idx] = self.bipolar_pairs
coords_bp = {coord_name:coord for coord_name, coord in list(self.time_series.coords.items())}
del coords_bp['channels']
coords_bp['bipolar_pairs'] = self.bipolar_pairs
ts = TimeSeriesX(data=ts0.values - ts1.values, dims=dims_bp,coords=coords_bp)
ts['samplerate'] = self.time_series['samplerate']
ts.attrs = self.time_series.attrs.copy()
return ts
def read_events_data(self):
"""
Reads eeg data for individual event
:return: TimeSeriesX 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
# print('raw_reader_channel_names: \n%s'%[x.channel_name for x in raw_readers])
# print('self.channel_name: %s'%self.channel_name)
event_indices_array = np.hstack(event_indices_list)
event_indices_restore_sort_order_array = event_indices_array.argsort()
start_extend_time = time.time()
# new code
eventdata = xr.concat(ts_array_list, dim='start_offsets')
# tdim = np.linspace(self.start_time-self.buffer_time,self.end_time+self.buffer_time,num=eventdata['offsets'].shape[0])
# samplerate=eventdata.attrs['samplerate'].data
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.concatenate(events).view(np.recarray).copy()
attrs = eventdata.attrs.copy()
# constructing TimeSeries Object
# eventdata = TimeSeriesX(eventdata.data,dims=['channels','events','time'],coords=[cdim,edim,tdim])
eventdata = TimeSeriesX(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 np.any(~event_ok_mask_sorted):
self.removed_corrupt_events=True
self.event_ok_mask_sorted = event_ok_mask_sorted
eventdata = eventdata[:, event_ok_mask_sorted, :]
return eventdata
def read_events_data(self):
"""
Reads eeg data for individual event
:return: TimeSeriesX 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
# print('raw_reader_channel_names: \n%s'%[x.channel_name for x in raw_readers])
# print('self.channel_name: %s'%self.channel_name)
event_indices_array = np.hstack(event_indices_list)
event_indices_restore_sort_order_array = event_indices_array.argsort()
start_extend_time = time.time()
# new code
eventdata = xr.concat(ts_array_list, dim='start_offsets')
# tdim = np.linspace(self.start_time-self.buffer_time,self.end_time+self.buffer_time,num=eventdata['offsets'].shape[0])
# samplerate=eventdata.attrs['samplerate'].data
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.concatenate(events).view(np.recarray).copy()
attrs = eventdata.attrs.copy()
# constructing TimeSeries Object
# eventdata = TimeSeriesX(eventdata.data,dims=['channels','events','time'],coords=[cdim,edim,tdim])
eventdata = TimeSeriesX(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 np.any(~event_ok_mask_sorted):
self.removed_corrupt_events = True
self.event_ok_mask_sorted = event_ok_mask_sorted
eventdata = eventdata[:, event_ok_mask_sorted, :]
return eventdata