class Subcribe():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def sub(self, streams):
self.c.sub_request(streams)
class Record():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def create_record_then_export(self, record_name, record_description,
record_length_s, record_export_folder,
record_export_data_types,
record_export_format, record_export_version):
self.c.create_record(record_name, record_description)
self.wait(record_length_s)
self.c.stop_record()
self.c.disconnect_headset()
self.c.export_record(record_export_folder, record_export_data_types,
record_export_format, record_export_version,
[self.c.record_id])
def wait(self, record_length_s):
print('start recording -------------------------')
length = 0
while length < record_length_s:
print('recording at {0} s'.format(length))
time.sleep(1)
length += 1
print('end recording -------------------------')
def start_chart(data):
# print('received message: ' + str(data), flush=sys.stdout)
chart_cortex = Cortex(user)
PROFILE_NAME = "RealBCI"
STREAM = "pow"
chart_cortex.do_prepare_steps()
chart_cortex.setup_profile(PROFILE_NAME, 'load')
chart_cortex.sub_request(stream=[STREAM], emit=emit)
class Train():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def train(self, profile_name, training_action, number_of_train):
stream = ['sys']
self.c.sub_request(stream)
profiles = self.c.query_profile()
if profile_name not in profiles:
status = 'create'
self.c.setup_profile(profile_name, status)
status = 'load'
self.c.setup_profile(profile_name, status)
print('begin train -----------------------------------')
num_train = 0
while num_train < number_of_train:
num_train = num_train + 1
print('start training {0} time {1} ---------------'.format(
training_action, num_train))
print('\n')
status = 'start'
self.c.train_request(detection='mentalCommand',
action=training_action,
status=status)
print('accept {0} time {1} ---------------'.format(
training_action, num_train))
print('\n')
status = 'accept'
self.c.train_request(detection='mentalCommand',
action=training_action,
status=status)
print('save trained action')
status = "save"
self.c.setup_profile(profile_name, status)
status = 'unload'
self.c.setup_profile(profile_name, status)
def live(self, profile_name):
print('begin live mode ----------------------------------')
# load profile
status = 'load'
self.c.setup_profile(profile_name, status)
# sub 'com' stream and view live mode
stream = ['com']
self.c.sub_request(stream)
class TrainAdvance():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def get_active_action(self, profile_name):
self.c.get_mental_command_active_action(profile_name)
def get_command_brain_map(self, profile_name):
self.c.get_mental_command_brain_map(profile_name)
def get_training_threshold(self):
self.c.get_mental_command_training_threshold(profile_name)
class LiveAdvance():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def live(self, profile_name):
print('begin live mode ----------------------------------')
self.c.setup_profile(profile_name=profile_name, status='load')
self.c.sub_request(stream=['com'])
def get_sensitivity(self, profile_name):
self.c.get_mental_command_action_sensitivity(profile_name)
def set_sensitivity(self, profile_name, values):
self.c.set_mental_command_action_sensitivity(profile_name, values)
class Marker():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def add_markers(self, marker_numbers):
now = ptb.GetSecs()
for m in range(marker_numbers):
mySound = sound.Sound('1000')
marker_time = time.time() * 1000
print('add marker at : ', marker_time)
marker = {
"label": str(m),
"value": "sound-erp",
"port": "python-app",
"time": marker_time
}
mySound.play(when=now + 0.5) # play in EXACTLY 0.5s
self.c.inject_marker_request(marker)
# add marker each seconds
time.sleep(1.5)
def demo_add_marker(self, record_export_folder, marker_numbers):
# create record
record_name = 'demo marker'
record_description = 'demo marker'
self.c.create_record(record_name, record_description)
self.add_markers(marker_numbers)
self.c.stop_record()
self.c.disconnect_headset()
# export record
record_export_data_types = ['EEG', 'MOTION', 'PM', 'BP']
record_export_format = 'CSV'
record_export_version = 'V2'
self.c.export_record(record_export_folder, record_export_data_types,
record_export_format, record_export_version,
[self.c.record_id])
class Marker():
def __init__(self):
self.c = Cortex(user, debug_mode=True)
self.c.do_prepare_steps()
def add_markers(self, marker_numbers):
for m in range(marker_numbers):
marker_time = time.time() * 1000
print('add marker at : ', marker_time)
marker = {
"label": str(m),
"value": "test_marker",
"port": "python-app",
"time": marker_time
}
self.c.inject_marker_request(marker)
# add marker each seconds
time.sleep(3)
def demo_add_marker(self, record_export_folder, marker_numbers):
# create record
record_name = 'Marker video'
record_description = 'test'
self.c.create_record(record_name, record_description)
self.add_markers(marker_numbers)
self.c.stop_record()
self.c.disconnect_headset()
# export record
record_export_data_types = ['EEG', 'MOTION', 'PM', 'BP']
record_export_format = 'CSV'
record_export_version = 'V2'
self.c.export_record(record_export_folder, record_export_data_types,
record_export_format, record_export_version,
[self.c.record_id])
class Subcribe():
def __init__(self):
self.headers = {}
self.objects = None
self.count = 0
self.tick = time.time()
self.maxEventsInBuffer = 100
self.stream_types = {}
self.is_first_for_type = {
"met": True,
"eeg": True,
"fac": True,
"mot": True,
}
self.c = Cortex(user, debug_mode=False)
self.c.do_prepare_steps()
self.time_slice = 0
self.time_data = {
'engagement': {},
'excitement': {},
'stress': {},
'relaxation': {},
'interest': {},
'focus': {}
}
self.time_slice_averages = {}
def add_cognitive_data_to_time_aggregation(self, event):
right_now = time.time()
current_time = str(right_now * 1000)
td = self.time_data
for key in td.keys():
new_value = event.get(key, None)
if new_value:
td[key][current_time] = new_value
self.time_slice_averages = {}
for key in td.keys():
ds = td[key]
keepers = {}
for t in ds.keys():
last_time = float(t) / 1000
if (right_now - last_time) <= 30:
keepers[t] = ds[t]
td[key] = keepers
vals = keepers.values()
self.time_slice_averages[key] = sum(vals) / len(vals)
event["last_30s"] = self.time_slice_averages
def prepare_metadata(self):
metadata = self.c.session_context["result"]
del metadata["recordIds"]
del metadata["recording"]
del metadata["id"]
headset = metadata["headset"]
del headset["motionSensors"]
del headset["sensors"]
del metadata["license"]
del metadata["performanceMetrics"]
del metadata["stopped"]
del metadata["streams"]
if self.c.user_id is None:
self.c.user_id = metadata["owner"]
self.c.device_id = headset["id"]
self.c.component_id = headset[
"virtualHeadsetId"] or "00000000-0000-0000-0000-000000000000"
del metadata["owner"]
del headset["id"]
del headset["virtualHeadsetId"]
def create_records_structure(self):
o = {
"id": str(uuid.uuid4()),
"sessionId": self.c.session_id,
"userId": self.c.user_id,
"deviceId": self.c.device_id.lower(),
"componentId": self.c.component_id,
"ts": datetime.datetime.now().isoformat(),
"metadata": {},
"eeg": [],
"cognitive": [],
"facial": [],
"motion": [],
}
metadata = self.c.session_context["result"]
o["metadata"] = metadata
return o
def publish_records(self):
my_keys = [
'engagement', 'excitement', 'stress', 'relaxation', 'interest',
'focus'
]
if len(self.objects['cognitive']) > 0:
event_data = self.objects
rows = self.objects['cognitive']
for x in range(len(rows)):
row = rows[x]
vals = []
for y in range(len(my_keys)):
k = my_keys[y]
vals.append(str(row[k]))
print(','.join(vals))
# print(json.dumps(event_data, indent=4))
send_kinesis(kinesis_client, kinesis_stream_name,
kinesis_shard_count, event_data) # send it!
self.objects = self.create_records_structure()
self.count = 0
self.tick = time.time()
def has_all_keys(self, record, keys):
answer = True
for k in keys:
answer = (answer and (k in record)) or False
return answer
def add_event(self, event, stream_name, sid):
if stream_name == 'met':
self.objects['cognitive'].append(event)
elif stream_name == 'eeg':
self.objects['eeg'].append(event)
elif stream_name == 'fac':
self.objects['facial'].append(event)
elif stream_name == 'mot':
self.objects['motion'].append(event)
def map_met(self, event):
if not event['engagementEnabled']:
del event['engagement']
if not event['excitementEnabled']:
del event['excitement']
del event['excitementLast1Min']
if not event['stressEnabled']:
del event['stress']
if not event['relaxationEnabled']:
del event['relaxation']
if not event['interestEnabled']:
del event['interest']
if not event['focusEnabled']:
del event['focus']
del event['engagementEnabled']
del event['excitementEnabled']
del event['stressEnabled']
del event['relaxationEnabled']
del event['interestEnabled']
del event['focusEnabled']
self.add_cognitive_data_to_time_aggregation(event)
def map_eeg(self, event):
if not event['hasMarkers']:
del event['markers']
del event['hasMarkers']
else:
event['hasMarkers'] = True
if not event['wasInterpolated']:
del event['wasInterpolated']
else:
event['wasInterpolated'] = True
def map_mot(self, e):
if not e['wasInterpolated']:
del e['wasInterpolated']
else:
e['wasInterpolated'] = True
def is_facial_data_redundant(self, event):
recent_facial_records = self.objects['facial']
if len(recent_facial_records) <= 0:
return False
last_facial_record = recent_facial_records[len(recent_facial_records) -
1]
compare_fields = [
"eyes", "upperFace", "upperFacePower", "lowerFace",
"lowerFacePower"
]
is_identical = True
for field in compare_fields:
if not (event[field] == last_facial_record[field]):
is_identical = False
return is_identical
def is_data_sample_relevant(self, event):
n = event['n']
# Get every 10th record using mathematics modulo
return (n % 5) == 0
def map_event(self, record, stream_name):
event = {}
sid = record['sid']
time_value = record['time']
headers = self.headers[stream_name]
if stream_name in record:
metrics = record[stream_name]
for i in range(len(headers)):
key = headers[i]
mapped_key = field_name_mapping[key] or key
val = metrics[i]
event[mapped_key] = val
event['ts'] = time_value
if stream_name == 'met':
self.map_met(event)
elif stream_name == 'eeg':
if self.is_data_sample_relevant(event):
self.map_eeg(event)
else:
event = None
elif stream_name == 'mot':
if self.is_data_sample_relevant(event):
self.map_mot(event)
else:
event = None
elif stream_name == 'fac':
if self.is_facial_data_redundant(event):
event = None
return event, sid
def get_record_type(self, record):
record_type = None
if 'eeg' in record: record_type = 'eeg'
elif 'mot' in record: record_type = 'mot'
elif 'fac' in record: record_type = 'fac'
elif 'met' in record: record_type = 'met'
return record_type
def process_headers(self, record):
header_data = record and record['result'] and record['result'][
'success']
for i in range(len(header_data)):
header = header_data[i]
cols = header['cols']
stream_name = header['streamName']
self.headers[stream_name] = cols
def on_data_received(self, data):
try:
record = json.loads(data)
except e as Error:
print(e)
sid = None
stream_name = None
# if the data record has a 'sid' field at the top level, then it is a summary
record_type = self.get_record_type(record)
if record_type:
self.count = self.count + 1
event, sid = self.map_event(record, record_type)
if event:
self.add_event(event, record_type, sid)
current_time = time.time()
# if (self.count >= self.maxEventsInBuffer) or ((current_time - self.tick) >= 1):
if (current_time - self.tick) >= 1:
self.publish_records()
else:
# Otherwise this is a special header record with all of the columns defined
self.process_headers(record)
def start(self, user_id, streams):
if self.c.ready_to_use:
self.c.user_id = user_id
self.prepare_metadata()
self.c.add_callback(self.on_data_received)
self.count = 0
self.objects = self.create_records_structure()
print(','.join([
'engagement', 'excitement', 'stress', 'relaxation', 'interest',
'focus'
]))
self.c.sub_request(streams)
import ctypes
from time import sleep
import os
from command_handler import command_handler
from cca_handler import cca_handler
from pyboy_controller import pyboy_controller
import time
# Initialize our variables
use_csv = True
# TEMP: feel free to change how I do this. I say 'if not using csv then use emotiv' here and in #EACHFRAMEPOG - Matt
# NOTE: still will save a csv file even though I am reading from a csv file
if not use_csv:
cortex = Cortex(None)
cortex.do_prepare_steps()
generator = cortex.sub_request(['eeg'])
# generator = cortex.sub_request_pow(['pow'])
next(generator).queue
data_columns = ["P7", "O1", "O2", "P8", "TIME"]
# data_columns = ["O1/theta","O1/alpha","O1/betaL","O1/betaH","O1/gamma",
# "O2/theta","O2/alpha","O2/betaL","O2/betaH","O2/gamma", "TIME"]
# CSV CONTROL
if use_csv:
recording_data = pd.read_csv('old_bad_recordings/first_target_0.csv')
record_length = len(recording_data.index)
channels = ['P7', 'O1', 'O2', 'P8'] # only data channels
row_index = 0
num_seconds = 3 # changing this will affect the time taken for each command
def test():
cortex = Cortex(None)
cortex.do_prepare_steps()
