Feature/integration

Manager/manager.py

@@ -0,0 +1,71 @@
+import random
+from datetime import datetime, timedelta
+from uuid import uuid4
+import os
+import threading
+
+from common.event import Event
+from common.settings import Settings
+from common.time_utils import check_total_elapsed, current_time_milli
+# TODO import correct fucntion
+from eeg.recorder import eeg_logic, Recorder
+from view.image_display import ImageDisplay
+from view.images_drawer import ImagesDrawer, window_closed, clock
+
+# IMAGES = ['january.png', 'february.png', 'march.png']
+IMAGES = ['nadav.jpg', 'hen.jpg', 'prof1.jpg']
+
+WAIT_INTERVAL = 1.5  # seconds
+SHOW_TIME = 0.2  # seconds
+
+uuid_to_image = {}
+
+random_ordered_images = IMAGES[:]
+random.shuffle(random_ordered_images)
+
+events = []
+absolute_start = datetime.now() + timedelta(seconds=WAIT_INTERVAL)
+next_start_time = absolute_start
+next_end_time = absolute_start + timedelta(seconds=SHOW_TIME)
+
+for image in random_ordered_images:
+    uuid = str(uuid4())
+    uuid_to_image[uuid] = image
+
+    events.append(
+        Event(start_time=next_start_time,
+              end_time=next_end_time,
+              image_path=os.path.join(Settings.images_path, image),
+              uuid=uuid
+              )
+    )
+
+    next_start_time = next_end_time + timedelta(seconds=WAIT_INTERVAL)
+    next_end_time = next_start_time + timedelta(seconds=SHOW_TIME)
+
+for event in events:
+    print event
+
+images_drawer = ImagesDrawer([ImageDisplay(event) for event in events])
+
+
+def main(draw_func, fps=40):
+    finish_time = events[-1].end_time + timedelta(seconds=WAIT_INTERVAL)
+
+    start_time = current_time_milli()
+
+    # TODO: start eeg
+    recorder = Recorder(finish_time)
+    recorder.start_recording_thread()
+
+    # while check_total_elapsed(start_time) and not window_closed():
+    while datetime.now() <= finish_time and not window_closed():
+        # draw_func(current_time_milli() - start_time)
+        draw_func(datetime.now())
+        clock.tick(fps)
+
+    # TODO: end eeg
+    # TODO: edit data(add cluster_id)
+
+
+main(images_drawer.draw)

common/event.py

@@ -0,0 +1,10 @@
+class Event(object):
+    def __init__(self, start_time, end_time, image_path, uuid):
+        self.start_time = start_time
+        self.end_time = end_time
+        self.image_path = image_path
+        self.uuid = uuid
+
+    def __repr__(self):
+        return "{image} from {start} to {end}, with uuid of: {uuid}".format(
+            image=self.image_path, start=self.start_time, end=self.end_time, uuid=self.uuid)

common/settings.py

@@ -1,7 +1,8 @@
-class Settings:
+class Settings(object):
     project_name = "proffesorX"
     screen_width = 800
     screen_height = 600
     background_color = (255, 255, 255) # white
     total_lifetime_seconds = 20
-    images_path = "resources/images/"
+    images_path = r"C:\Users\nadav\Documents\mahanet2018\programming\professorX\resources\images"
+    # images_path = "resources/images/"

eeg/plotter.py

@@ -0,0 +1,37 @@
+import matplotlib.pyplot as plt
+
+
+def plot(dataArray):
+    fig, ax = plt.subplots()
+    xar = []
+    lowGamma = []
+    highGamma = []
+    highAlpha = []
+    delta = []
+    highBeta = []
+    lowAlpha = []
+    lowBeta = []
+    theta = []
+    for eachLine in dataArray:
+        x = float(eachLine['time'])
+        xar.append(int(x))
+        lowGamma.append(int(eachLine['lowGamma']))
+        highGamma.append(int(eachLine['highGamma']) + 1000)
+        highAlpha.append(int(eachLine['highAlpha']) + 1000)
+        delta.append(int(eachLine['delta']) + 1000)
+        highBeta.append(int(eachLine['highBeta']) + 1000)
+        lowAlpha.append(int(eachLine['lowAlpha']) + 1000)
+        lowBeta.append(int(eachLine['lowBeta']) + 1000)
+        theta.append(int(eachLine['theta']) + 1000)
+
+    ax.plot(xar, lowGamma)
+    ax.plot(xar, highGamma)
+    ax.plot(xar, highAlpha)
+    ax.plot(xar, delta)
+    ax.plot(xar, highBeta)
+    ax.plot(xar, lowAlpha)
+    ax.plot(xar, lowBeta)
+    ax.plot(xar, theta)
+    ax.set_title("My EEG")
+
+    plt.show()

eeg/recorder.py

@@ -0,0 +1,88 @@
+import json
+import random
+import time
+import uuid
+
+from datetime import datetime
+from threading import Thread
+
+from mindcontrol.userbrain import Brain
+from time import sleep
+
+import matplotlib.pyplot as plt
+
+import plotter
+
+
+def eeg_logic():
+    pass
+
+
+class Recorder(object):
+    SLEEP_TIME = 5  # seconds
+    CONCENTRATE_TIME = 5  # seconds
+
+    def __init__(self, finish_time):
+        self.finish_time = finish_time
+        self.my_brain = Brain()
+        while not self.my_brain.isConnected():
+            print 'Not connected to brain yet. Will try again in %d seconds' % self.SLEEP_TIME
+            sleep(self.SLEEP_TIME)
+        self.conc_vals = []
+        plt.axis([0, 100, 0, 100])
+
+        self.total_values = {
+            "lowGamma": [100000, 0],
+            "highGamma": [100000, 0],
+            "highAlpha": [100000, 0],
+            "delta": [100000, 0],
+            "highBeta": [100000, 0],
+            "lowAlpha": [100000, 0],
+            "lowBeta": [100000, 0],
+            "theta": [100000, 0],
+        }
+
+    @staticmethod
+    def update_range_values(abs_values, given_data):
+        for wave_type in abs_values:
+            if abs_values[wave_type][0] >= given_data[wave_type]:
+                abs_values[wave_type][0] = given_data[wave_type]
+            if abs_values[wave_type][1] <= given_data[wave_type]:
+                abs_values[wave_type][1] = given_data[wave_type]
+        return abs_values
+
+    def start_recording_thread(self):
+        self.th = Thread(target=self.start_recording_thread, args=())
+        self.th.start()
+
+    def start_recording(self):
+        # random_clusters = [str(uuid.uuid4()), str(uuid.uuid4()), str(uuid.uuid4())]
+        # is_correct_answer_values = [1, 0, 0]
+        init_time = time.time()
+
+        total_data = []
+        while datetime.now() <= self.finish_time:
+            self.conc_vals.append(self.my_brain.getProperty('attention'))
+            current_data = self.my_brain.freshest_data
+
+            current_data["time"] = str(time.time() - init_time)
+
+            # current_data["cluster_id"] = random_clusters[fixed_values_index]
+            # current_data["is_correct"] = is_correct_answer_values[fixed_values_index]
+
+            total_data.append(current_data)
+
+            x = time.time() - init_time
+            plt.scatter(x, int(self.my_brain.freshest_data['attention']))
+
+            if int(time.time() - init_time) % 10 == 0:
+                print "recorder is running"
+
+            plt.pause(0.05)
+            sleep(0.1)
+
+        # plotter.plot(total_data)
+
+
+# recorder = Recorder()
+# recorder.start_recording()

main.py

@@ -1,13 +1,7 @@
-from view.view import ImagesDrawer, ImageDisplay, clock, window_closed, image
+from view.images_drawer import ImagesDrawer, clock, window_closed, image
+from view.image_display import ImageDisplay
 from common.time_utils import current_time_milli, check_total_elapsed
-from eeg.eeg import eeg_logic
-
-drawer = ImagesDrawer([
-    ImageDisplay(image("prof1.jpg"), 1000, 1500, -100),
-    ImageDisplay(image("nadav.jpg"), 3000, 200, 50),
-    ImageDisplay(image("hen.jpg"), 3700, 400, 50),
-    ImageDisplay(image("nadav.jpg"), 4600, 250, 50),
-    ImageDisplay(image("hen.jpg"), 5250, 50, 50)])
+from eeg.recorder import eeg_logic
 
 start_time = current_time_milli()
 

requirements.txt

@@ -0,0 +1,2 @@
+pygame
+mindcontrol>=0.7

view/image_display.py

@@ -0,0 +1,24 @@
+import pygame
+
+from images_drawer import game_display
+
+
+class ImageDisplay(object):
+    displayed = False
+
+    def __init__(self, event, pos_x=0, pos_y=0):
+        """
+        :param common.event.Event event: event object to use
+        :param int pos_x:
+        :param int pos_y:
+        """
+        self.image = pygame.image.load(event.image_path)
+        self.start_time = event.start_time
+        self.end_time = event.end_time
+        self.pos_x = pos_x
+        self.pos_y = pos_y
+
+    # Draw image if given time is inside duration window.
+    def draw(self, display_time):
+        if self.start_time <= display_time <= self.end_time:
+            game_display.blit(self.image, (self.pos_x, self.pos_y))

view/view.py → view/images_drawer.py

@@ -1,4 +1,5 @@
 import pygame
+
 from common.settings import Settings
 
 pygame.init()
@@ -8,7 +9,7 @@
 crashed = False
 
 
-class ImagesDrawer:
+class ImagesDrawer(object):
     def __init__(self, images):
         self.images = images
 
@@ -20,22 +21,6 @@ def draw(self, time):
         pygame.display.update()
 
 
-class ImageDisplay:
-    displayed = False
-
-    def __init__(self, image_path, time, duration, pos_x=0, pos_y=0):
-        self.image = pygame.image.load(image_path)
-        self.time = time
-        self.duration = duration
-        self.pos_x = pos_x
-        self.pos_y = pos_y
-
-    # Draw image if given time is inside duration window.
-    def draw(self, time):
-        if self.time <= time <= self.time + self.duration:
-            game_display.blit(self.image, (self.pos_x, self.pos_y))
-
-
 def window_closed():
     for event in pygame.event.get():
         if event.type == pygame.QUIT: