def test_highpass(self): filtered = bandPassFilter(self.signal, sampleRate=self.sampleRate, highpass=self.highpass) self.assertGreater(np.corrcoef(filtered, self.signalHigh)[0, 1], 0.9) self.assertAlmostEqual(energy(filtered) / energy(self.signalHigh), 1, delta=0.1)
def getSignalAtBands(self, i=None, bands=defaultBands): """ Rebuilds the signal from a component i but only in the specified frequency bands. Parameters ---------- i: Variable type, optional * int: the index of the channel. * str: the name of the channel. * list of strings and integers: a list of channels that will be used. * slice: a slice selecting the range of channels that will be used. * None: all the channels will be used. bands: dict, optional This parameter is used to indicate the bands that are going to be used. It is a dict with the name of each band as key and a tuple with the lower and upper bounds as value. Returns ------- dict of numpy.ndarray (1D or 2D) The keys are the same keys the bands dictionary is using. The values are the signal filtered in every band at the given index of the window. If more than one channel is selected the return object will be a dict containing 2D arrays in which each row is a signal filtered at the corresponding channel. """ bandsSignals = {} for key, band in bands.items(): bounds = self.getBoundsForBand(band) bandsSignals[key] = self._applyFunctionTo( lambda x: bandPassFilter(x, self.sampleRate, bounds[0], bounds[ 1]), i) return bandsSignals
def test_nopass(self): filtered = bandPassFilter(self.signal) np.testing.assert_array_equal(self.signal, filtered)
def __init__(self, data, sampleRate=None, windowSize=None, names=None, highpass=None, lowpass=None, normalize=False, ICA=False, selectedSignals=None): """ Parameters ---------- data: 2D matrix The signals data in the shape (nChannels, nSamples). sampleRate: numeric, optional The frequency at which the data was recorded. By default its value is the lenght of the data. windowSize: int, optional The size of the window in which the calculations will be done. By default its value is the lenght of one second of the data. names: list of strings A list containing the names of each channel in the same positions than data channels. highpass: numeric, optional The signal will be filtered above this value. lowpass: numeric, optional The signal will be filtered bellow this value. normalize: boolean, optional If True, the data will be normalizing using z-scores. Default = False. ICA: boolean, optional If True, Independent Component Analysis will be applied to the data . It is applied always after normalization if normalize = True. Default: False. selectedSignals: list of strings or ints If the data file has names asociated to each columns, those columns can be selected through the name or the index of the column. If the data file hasn't names in the columns, they can be selected just by the index. """ self.data = data #Names check if names: self.names = names else: self.names = [str(i) for i in range(data.shape[0])] #Check selected signals if selectedSignals: self.selectSignals(selectedSignals) #SampleRate check if not sampleRate: self.sampleRate=len(self.data[0]) else: self.sampleRate=sampleRate #windowSize check if not windowSize: self.windowSize = self.sampleRate else: self.windowSize = windowSize #Attributes inicialization self.nChannels = len(self.data) self.nSamples = len(self.data[0]) self.startPoint = 0 self.endPoint = self.nSamples self.step=None self.iterator = None self.duration = self.nSamples/self.sampleRate #Preparing inner EEG ovject self.prepareEEG(self.windowSize) #Lowpass and highpass check if lowpass or highpass: for i,channel in enumerate(self.data): self.data[i]=bandPassFilter(channel, self.sampleRate, highpass, lowpass) #ICA check if ICA: ica=FastICA() self.data=ica.fit_transform(self.data.transpose()).transpose() self.names = [str(i) for i in range(self.nChannels)] #normilze check if normalize: self.data=zscore(self.data,axis=1) #Setting an initial value for the EEG window self.moveEEGWindow(self.startPoint)