def __init__(self):
self.su = SignalUtil()
self.windowSeconds = ConfigProvider().getCollectorConfig().get(
"windowSeconds")
config = ConfigProvider().getProcessingConfig()
self.xMax = config.get("xMax")
self.yMax = config.get("yMax")
def __init__(self):
config = ConfigProvider().getProcessingConfig()
self.lowerFreq = config.get("lowerFreq")
self.upperFreq = config.get("upperFreq")
self.samplingRate = ConfigProvider().getEmotivConfig().get(
"samplingRate")
self.sigUtil = SignalUtil()
def __init__(self):
self.config = ConfigProvider().getProcessingConfig()
self.upperBound = self.config.get("upperBound")
self.lowerBound = self.config.get("lowerBound")
self.minQuality = self.config.get("minQual")
self.maxSeqLength = self.config.get("maxSeqLength")
self.maxNaNValues = self.config.get("maxNaNValues")
self.windowSeconds = ConfigProvider().getCollectorConfig().get(
"windowSeconds")
def __init__(self, verbose=False):
config = ConfigProvider().getProcessingConfig()
self.maxNaNValues = config.get("maxNaNValues")
self.lowerBound = config.get("lowerBound")
self.upperBound = config.get("upperBound")
self.normalize = config.get("normalize")
self.samplingRate = ConfigProvider().getEmotivConfig().get("samplingRate")
self.qualUtil = QualityUtil()
self.sigUtil = SignalUtil()
self.verbose = verbose
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 normGyroData(self):
config = ConfigProvider().getProcessingConfig()
for gyroField in self.getGyroHeader():
gyroCol = self.getColumn(gyroField) - config.get(
gyroField.lower() + "Ground")
self.setColumn(gyroField, gyroCol)
def __init__(self, verbose=False):
self.samplingRate = ConfigProvider().getEmotivConfig().get(
"samplingRate")
self.qualUtil = QualityUtil()
self.fftUtil = FFTUtil()
self.eegUtil = EEGUtil()
self.verbose = verbose
def writeFeature(self, data, filePath):
header = []
start = 4
end = start + len(data[0]) / 6
for field in ConfigProvider().getCollectorConfig().get("eegFields"):
header.extend([str(x) + "Hz" + field for x in range(start, end)])
self.fileUtil.saveCSV(filePath, data, header)
def createEmotivDataCollector(collectedQueue):
collectorConfig = ConfigProvider().getCollectorConfig()
fields = collectorConfig.get("eegFields") + collectorConfig.get(
"gyroFields")
windowSize = collectorConfig.get("windowSeconds")
windowCount = collectorConfig.get("windowCount")
return EEGDataCollector(EmotivConnector(), collectedQueue, fields,
windowSize, windowCount)
def setUp(self):
self.chain = SignalProcessor()
self.qualUtil = QualityUtil()
config = ConfigProvider().getProcessingConfig()
self.upperBound = config.get("upperBound")
self.lowerBound = config.get("lowerBound")
self.minQuality = config.get("minQual")
self.maxNaNValues = config.get("maxNaNValues")
def createDemoEEGDataCollector(demoFile, collectedQueue):
collectorConfig = ConfigProvider().getCollectorConfig()
fields = collectorConfig.get("eegFields") + collectorConfig.get(
"gyroFields")
windowSeconds = collectorConfig.get("windowSeconds")
windowCount = collectorConfig.get("windowCount")
datasource = Factory.createDummyPacketSource(demoFile)
return EEGDataCollector(datasource, collectedQueue, fields,
windowSeconds, windowCount, 128)
def plot(proband, filename):
experiments = ConfigProvider().getExperimentConfig()
experimentDir = experiments["filePath"]
#filePath = "%s/test/%s" % (experimentDir, "awake_full.csv")
filePath = "%s/%s/%s" % (experimentDir, proband, filename)
dto = FileUtil().getDto(filePath)
fp = FeaturePlotter(dto.getData(), dto.getHeader(), filePath)
fp.doPlot()
def __init__(self, nInputs=None, nHiddenLayers=None, bias=True, new=True, fileName=""):
self.params = {}
self.config = ConfigProvider().getNNTrainConfig()
if new:
self.params["nInputs"] = nInputs
self.params["nHiddenLayers"] = nHiddenLayers
self.params["bias"] = bias
self.nn = NeuralNetwork().createNew(nInputs, nHiddenLayers, N_OUTPUT, bias)
else:
self.nn = NeuralNetwork().load(fileName)
def loadSingle(fileName):
#files = [scriptPath + "/../../../data/awake_full.csv", scriptPath + "/../../../data/drowsy_full.csv"]
experimentDir = ConfigProvider().getExperimentConfig().get("filePath")
files = [experimentDir + "test/awakes_proc_new4.csv", experimentDir + "test/drowsies_proc_new4.csv"]
ndu = NetworkDataUtil(files)
data = ndu.get(False)
nu = NetworkUtil(new=False, fileName=fileName)
writeResults(nu, data, fileName, files)
def _calcSamplingRate(self):
'''
calcs the samplerate for the whole dataset based on the timestamp column
:return: samplerate
:rtype: float
'''
try:
duration = self.getDuration()
return self.len / duration
except:
return ConfigProvider().getEmotivConfig().get("samplingRate")
def __init__(self, collectedQueue, extractedQueue, eegProcessor,
gyroProcessor):
config = ConfigProvider()
self.eegFields = config.getEmotivConfig()["eegFields"]
self.gyroFields = config.getEmotivConfig()["gyroFields"]
self.samplingRate = config.getEmotivConfig()["samplingRate"]
self.processingConfig = config.getProcessingConfig()
self.eegProcessor = eegProcessor
self.gyroProcessor = gyroProcessor
self.collectedQueue = collectedQueue
self.extractedQueue = extractedQueue
self.runProcess = True
def _initPoSDBoS(demo):
posdbos = PoSDBoS()
posdbos.demo = demo
posdbos.running = True
posdbosConfig = ConfigProvider().getPoSDBoSConfig()
posdbos.drowsyMinCount = posdbosConfig.get("drowsyMinCount")
posdbos.awakeMinCount = posdbosConfig.get("awakeMinCount")
posdbos.classified = [0, 0]
posdbos.curClass = 0
posdbos.classCount = 0
posdbos.found = 0
return posdbos
def trainSingle(h, name, convergence):
experimentDir = ConfigProvider().getExperimentConfig().get("filePath")
files = [experimentDir + "test/awakes_proc_new8.csv", experimentDir + "test/drowsies_proc_new8.csv"]
#files = [experimentDir + "mp/awakes_full_norm_proc_4.csv", experimentDir + "mp/drowsies_full_norm_proc_4.csv"]
ndu = NetworkDataUtil(files)
train, test = ndu.get()
nu = NetworkUtil(ndu.getNInput(), 1)
nu.train(train, convergence)
nu.test()
fileName = name + "_" + str(h)
nu.save(fileName)
data = ndu.get(False, False)
writeResults(nu, data, fileName, files, convergence, test)
def getForTesting():
self = TestFactory
app = self._get()
app.nn = self.loadNeuralNetwork(scriptPath + "/test_data/test", False)
app.dm = DrowsinessMonitor()
collectorConfig = ConfigProvider().getCollectorConfig()
fields = collectorConfig.get("eegFields") + collectorConfig.get(
"gyroFields")
windowSeconds = collectorConfig.get("windowSeconds")
windowCount = collectorConfig.get("windowCount")
samplingRate = 128
filePath = scriptPath + "/test_data/example_1024.csv"
app.dc = self.createTestDataCollector(app.collectedQueue, fields,
windowSeconds, samplingRate,
windowCount, filePath)
app.dp = self.createDataProcessor(app.collectedQueue,
app.extractedQueue)
return app
:author: Paul Pasler
:organization: Reutlingen University
'''
from posdbos.util.signal_util import SignalUtil
from config.config import ConfigProvider
from numpy import ceil
# TODO should be from 0.5 to 4
DELTA_RANGE = (1, 4)
THETA_RANGE = (4, 8)
ALPHA_RANGE = (8, 13)
BETA_RANGE = (13, 30)
samplingRate = ConfigProvider().getEmotivConfig().get("samplingRate")
gammaMax = min(samplingRate / 2, 99)
GAMMA_RANGE = (30, gammaMax)
class EEGUtil(object):
'''
This class does useful things with EEG signals
Like splitting by channel
DELTA = 0.5 - 4hz
THETA = 4 - 8hz
ALPHA = 8 - 13hz
BETA = 13 - 30hz
GAMMA = 30 - 99hz
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()
:author: Paul Pasler
:organization: Reutlingen University
'''
import logging
logging.basicConfig(
level=logging.INFO,
format=
'%(asctime)s.%(msecs)03d %(levelname)-8s %(module)s.%(funcName)s:%(lineno)d %(message)s',
datefmt='%H:%M:%S')
from posdbos.util.file_util import FileUtil
import threading
from config.config import ConfigProvider
from posdbos.factory import Factory
exConfig = ConfigProvider().getExperimentConfig()
probands = exConfig.get("probands")
experimentDir = exConfig.get("filePath")
fileUtil = FileUtil()
def getFilePaths(fileName):
filePaths = []
for proband in probands:
filePath = "%s%s/" % (experimentDir, proband)
filePaths.append(filePath + fileName)
return filePaths
def splitDtos(filePaths):
def getGyroHeader(self):
gyroFields = ConfigProvider().getEmotivConfig().get("gyroFields")
return [head for head in self.header if head in gyroFields]
def getEEGHeader(self):
eegFields = ConfigProvider().getEmotivConfig().get("eegFields")
return [head for head in self.header if head in eegFields]
def test_normalize_value(self):
norm = ConfigProvider().getProcessingConfig().get("normalize")
testList = np.array([0, -5, 1, 10])
normList = self.util.normalize(testList, norm)
self.assertEqual(len(testList), len(normList))
self.assertItemsEqual(normList, testList / norm)
merge = self.splitAndMerge(df)
self.showDifference(merge, "%s %s" % (self.name, proband))
return merge
class EEGAnalyzer(EmotivAnalyzer):
def __init__(self, fileName="EEG", hasTime=True):
super(EEGAnalyzer, self).__init__(fileName, hasTime)
self.name = "EEG"
self.fields = self.config.getCollectorConfig().get("eegFields")
#self.fields = self.config.getEmotivConfig().get("eegFields")
self.dataField = self.fields
def analyse(self, proband):
df = self.buildDf(proband)
merge = self.splitAndMerge(df)
self.showDifference(merge, "%s %s" % (self.name, proband))
return merge
probands = ConfigProvider().getExperimentConfig().get("probands")
nProbands = ["1", "2"]
oProbands = ["a", "b", "c", "e"]
ea = GyroAnalyzer("EEGNormed", False)
#for proband in probands:
# ea.analyse(proband)
ea.analyseMerge(probands)
#ea.analyseMerge(nProbands)
#ea.analyseMerge(oProbands)
#CANAnalyzer().analyse("3")
plt.show()
def setUp(self):
self.config = ConfigProvider()
def createNeuralNetwork():
nnCreate = ConfigProvider().getNNInitConfig()
return NeuralNetwork().createNew(**nnCreate)
def __init__(self):
self.config = ConfigProvider()
exConfig = self.config.getExperimentConfig()
self.experimentPath = exConfig.get("filePath")
self.probands = exConfig.get("probands")
self.lengths = []
def setUp(self):
self.dm = DrowsinessMonitor()
self.classes = ConfigProvider().getConfig("class")
