def __init__(self):
self.mneUtil = MNEUtil()
config = ConfigProvider().getProcessingConfig()
self.lowerFreq = config.get("lowerFreq")
self.upperFreq = config.get("upperFreq")
self.windowSeconds = ConfigProvider().getCollectorConfig().get(
"windowSeconds")
self.resampleFreq = config.get("resamplingRate")
self.eegFields = ConfigProvider().getEmotivConfig().get("eegFields")
self.si = SignalUtil()
self.qu = QualityUtil()
self.eog = EOGExtractor()
class FreqProcessor(object):
def __init__(self, verbose=False):
config = ConfigProvider().getProcessingConfig()
self.eegFields = config.get("eegFields")
self.fmin = config.get("fmin")
self.fmax = config.get("fmax")
self.mneUtil = MNEUtil()
def process(self, mneRaw):
header = mneRaw.ch_names
picks = [header.index(ch_name) for ch_name in self.eegFields]
psd, freqs = self.mneUtil.calcPSD(mneRaw,
self.fmin,
self.fmax,
picks=picks)
return psd
class SignalPreProcessor(object):
def __init__(self):
self.mneUtil = MNEUtil()
config = ConfigProvider().getProcessingConfig()
self.lowerFreq = config.get("lowerFreq")
self.upperFreq = config.get("upperFreq")
self.windowSeconds = ConfigProvider().getCollectorConfig().get(
"windowSeconds")
self.resampleFreq = config.get("resamplingRate")
self.eegFields = ConfigProvider().getEmotivConfig().get("eegFields")
self.si = SignalUtil()
self.qu = QualityUtil()
self.eog = EOGExtractor()
def _calcSamplingRate(self, data):
return len(data) / self.windowSeconds
def process(self, raw):
header = self.eegFields
data = [raw[head]["value"] for head in header]
samplingRate = self._calcSamplingRate(data[0])
mneRaw = self.mneUtil.createMNEObject(data, header, "", samplingRate)
mneProc = self._process(mneRaw)
return mneProc
def _process(self, mneRaw):
self.mneUtil.filterData(mneRaw, self.lowerFreq, self.upperFreq)
mneRaw.resample(self.resampleFreq, npad='auto', n_jobs=2, verbose=True)
ica = self.mneUtil.ICA(mneRaw, icCount=14)
#self._plot(mneRaw, ica)
self.eog.labelEOGChannel([ica])
self.eog.removeEOGChannel(mneRaw, ica)
return mneRaw
def _plot(self, mneRaw, ica):
ica.plot_components(show=False)
ica.plot_sources(mneRaw, show=False)
self.mneUtil.plotRaw(mneRaw, show=False)
plt_show()
def __init__(self, verbose=False):
config = ConfigProvider().getProcessingConfig()
self.eegFields = config.get("eegFields")
self.fmin = config.get("fmin")
self.fmax = config.get("fmax")
self.mneUtil = MNEUtil()
def __init__(self):
self.mneUtil = MNEUtil()
self.fileUtil = FileUtil()
self.eogChans = [2]
self.templateICA = self.fileUtil.loadICA(TEMPLATE_ICA_PATH +
"blink_.ica.fif")
class EOGExtractor(object):
'''
Class to extract EOG signal from EEG
'''
def __init__(self):
self.mneUtil = MNEUtil()
self.fileUtil = FileUtil()
self.eogChans = [2]
self.templateICA = self.fileUtil.loadICA(TEMPLATE_ICA_PATH +
"blink_.ica.fif")
#self._plot()#logging.info("load ICA ", "template", self.templateICA.get_components().shape)
def _plot(self):
self.templateRaw = self.fileUtil.load(TEMPLATE_ICA_PATH +
"blink_.raw.fif")
self.templateICA.plot_components(show=False)
self.templateICA.plot_sources(self.templateRaw, show=False)
plt_show()
def labelEOGChannel(self, icas):
for eogChan in self.eogChans:
self.mneUtil.labelArtefact(self.templateICA, eogChan, icas,
BLINK_LABEL)
def getEOGChannel(self, raw, ica, eogInds=None):
eogInds = self._getEOGIndex(ica, eogInds)
eog = raw.copy()
eog = ica.get_sources(eog)
eogChan = mean(raw._data[eogInds], axis=0)
dropNames = self._createDropNames(ica, [0])
eog.drop_channels(dropNames)
raw._data[0] = eogChan
nameDict = {self._getICAName(0): "EOG"}
eog.rename_channels(nameDict)
typeDict = {"EOG": "eog"}
eog.set_channel_types(typeDict)
return eog
def _getEOGIndex(self, ica, eogInds):
if eogInds is None:
logging.info("has EOG channel %s" % str(ica.labels_))
eogInds = ica.labels_[BLINK_LABEL]
return eogInds
def _createDropNames(self, ica, eogInds):
ind = range(ica.n_components_)
return [self._getICAName(i) for i in ind if i not in eogInds]
def _getICAName(self, number):
# TODO remove '+ 1' after #3889
return 'ICA %03d' % (number + 1)
def removeEOGChannel(self, raw, ica, eogInd=None):
eogInd = self._getEOGIndex(ica, eogInd)
return ica.apply(raw, exclude=eogInd)
def _getMNEObject(self, dto):
return MNEUtil().createMNEObjectFromEEGDto(dto)
import time
import warnings
from mne.viz.utils import plt_show
from config.config import ConfigProvider
from posdbos.util.eog_extractor import EOGExtractor
from posdbos.util.file_util import FileUtil
from posdbos.util.mne_util import MNEUtil, MNEPlotter
from posdbos.processor.mne_processor import MNEProcessor, SignalPreProcessor, FreqProcessor
from numpy import count_nonzero, mean
warnings.filterwarnings(action='ignore')
mneUtil = MNEUtil()
mnePlotter = MNEPlotter()
fileUtil = FileUtil()
#eogExtractor = EOGExtractor()
procConfig = ConfigProvider().getProcessingConfig()
FILE_PATH = "E:/thesis/experiment/%s/"
sFreq = procConfig.get("resamplingRate")
icCount = procConfig.get("icCount")
probands = ConfigProvider().getExperimentConfig().get("probands")
eegFields = ConfigProvider().getEmotivConfig().get("eegFields")
def _filter(raw):
start = time.time()
mneUtil.bandpassFilterData(raw)
dur = time.time() - start
def setUp(self):
self.mne = MNEUtil()
self.config = ConfigProvider().getEmotivConfig()
self.eegData = self._readData()
class MNEUtilTest(BaseTest):
def setUp(self):
self.mne = MNEUtil()
self.config = ConfigProvider().getEmotivConfig()
self.eegData = self._readData()
def _readData(self):
return FileUtil().getDto(self.getData1024CSV())
def _createTestData(self):
header = ["F3", "F4", "AF3", "AF4"]
data = np.random.rand(4,512)
filePath = "test"
return self.mne.createMNEObject(data, header, None, [], filePath, 128)
def test__mergeData(self):
eegData = np.array([
[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3],
[4, 4, 4, 4]
])
gyroData = np.array([
[5, 5, 5, 5],
[6, 6, 6, 6]
])
mergedData = self.mne._mergeData(eegData, gyroData)
self.assertEquals(mergedData.shape, (6, 4))
def test_createMNEObjectFromDto_creation(self):
self.mne.createMNEObjectFromEEGDto(self.eegData)
def test_createMNEObject_creation(self):
self.mne.createMNEObject(self.eegData.getEEGData(), self.eegData.getEEGHeader(), self.eegData.getGyroData(), self.eegData.getGyroHeader(), self.eegData.filePath, self.eegData.getSamplingRate())
def test_createMNEObjectFromDto_getChannels(self):
channels = ["AF3", "F3"]
raw = self.mne.createMNEObjectFromEEGDto(self.eegData)
chanObj = self.mne.getChannels(raw, channels)
self.assertEqual(chanObj.info["nchan"], len(channels))
def test__createInfo_creation(self):
eegChannels = self.config.get("eegFields")
gyroChannels = self.config.get("gyroFields")
channels = eegChannels + gyroChannels
samplingRate = self.config.get("samplingRate")
info = self.mne._createEEGInfo(eegChannels, gyroChannels, "testFile", 128)
self.assertEquals(info["sfreq"], samplingRate)
self.assertEquals(info["nchan"], len(channels))
self.assertItemsEqual(info["ch_names"], channels)
@unittest.skip("work in progress")
def test_createMNEEpochsObject(self):
epochs = self.mne.createMNEEpochsObject(self.eegData, 1)
self.assertEqual(len(epochs.get_data()), 15)
def test__createEventsArray_overlapping(self):
raw = self._createTestData()
event_id = dict(drowsy=1)
events1 = self.mne._createEventsArray(raw, 1, False)
epochs1 = mne.Epochs(raw, events=events1, event_id=event_id, tmin=0.0, tmax=0.99, add_eeg_ref=True)
events2 = self.mne._createEventsArray(raw, 1)
epochs2 = mne.Epochs(raw, events=events2, event_id=event_id, tmin=0.0, tmax=0.99, add_eeg_ref=True)
for i in range(0, len(events1)):
data1 = epochs1[i].get_data()
data2 = epochs2[i*2].get_data()
self.assertTrue((data1 == data2).all())
@unittest.skip("todo")
def test_ICA(self):
raw = self.mne.createMNEObjectFromEEGDto(self.eegData)
logging.info(self.mne.ICA(raw))