def logo_text_line(text): blank = stimuli.Canvas(size=(600, 400)) stimuli.TextLine(text="Version " + forceDAQVersion, position=(0, 80), text_size=14, text_colour=constants.C_EXPYRIMENT_ORANGE).plot(blank) stimuli.TextLine(text=text).plot(blank) return blank
def _make_graph(x, y, colour): """Make the graph.""" graph = stimuli.Canvas(size=(max(x) * 3 + 10, max(y) * 3 + 10)) for counter in range(len(x)): dot = stimuli.Dot(radius=1, colour=colour) dot.position = (x[counter] * 3 - graph.size[0] / 2 + 5, y[counter] * 3 - graph.size[1] / 2 + 5) dot.plot(graph) return graph
def create_3cards(card1, card2, card3): """ create a surface with the 3 cards """ surf = stimuli.Canvas((3 * W + 2 * GAP, H), (0, 0)) stim[card1].plot(C[0]) stim[card2].plot(C[1]) stim[card3].plot(C[2]) C[0].plot(surf) C[1].plot(surf) C[2].plot(surf) surf.preload() return surf
def prepare(self): if not self.prepared: self._canvas = stimuli.Canvas( self.experiment.expyriment.screen.size, colour=self.background_color.backend_color) for stim in self.stim_list: stim.plot(self._canvas) self._canvas.preload() self.prepared = True return self.experiment.time()
def logo_text_line(text): blank = stimuli.Canvas(size=(600, 400)) logo = stimuli.Picture(filename=os.path.join(os.path.dirname(__file__), "pytrak_logo.png"), position = (0, 150)) logo.scale(0.6) stimuli.TextLine(text="Version " + __version__, position=(0,80), text_size = 14, text_colour=misc.constants.C_EXPYRIMENT_ORANGE).plot(blank) logo.plot(blank) stimuli.TextLine(text=text).plot(blank) return blank
def prepare(self): """See openexp._canvas.legacy""" if not self.prepared: self._canvas = stimuli.Canvas( \ self.experiment.expyriment.screen.size, colour= \ self._canvas_color) for stim in self.stim_list: stim.plot(self._canvas) self._canvas.preload() self.prepared = True return self.experiment.time()
def __init__(self, screen_size, pos_y, clef_name="g", design="bw", text=None): self.background_colour = constants.C_WHITE self.foreground_colour = constants.C_BLACK self.clef_name = clef_name # Position of field self.pos_x = 0 self.pos_y = pos_y[self.clef_name] self.field_position = [self.pos_x, self.pos_y] # Size of field is 1 / factor of whole screen factor = 3.5 field_x = screen_size[0] / 2 field_y = screen_size[1] / factor self.field_size = [field_x, field_y] self.Field = stimuli.Canvas(size=self.field_size, position=self.field_position, colour=self.background_colour) # Text field for debugging if text is not None: self.text = text text = stimuli.TextBox(self.text, [100,100]) text.plot(self.Field) # Add lines self.distance = screen_size[0] / 60 line_radius = screen_size[0]/10 for i in range(-2, 3, 1): item = { 'start_point': [-line_radius, self.pos_x - (i * self.distance)], 'end_point': [line_radius, self.pos_x - (i * self.distance)], 'line_width': 2, 'colour': self.foreground_colour } line = stimuli.Line(item['start_point'], item['end_point'], item['line_width'], colour=item['colour']) line.plot(self.Field) # Add clef clef_pos_x = line_radius * 1.2 clef = stimuli.Picture('Stimuli/clef_' + design + '_' + clef_name + '.jpg', position=[-clef_pos_x, 0]) clef.scale(3.9 * screen_size[0] / 100000) clef.plot(self.Field)
def stimulus_question_presentation(Answer): canvas = stimuli.Canvas( size=screen_size ) #create canvas w/ size of the screen/screen surface. Must create new canvas every time or canvases will overwrite themselves trial.stimuli[0].plot(canvas) stimuli.TextScreen( heading='Is it a {}?'.format(trial.get_factor('Stimulus')), text=Answer).plot(canvas) # {} replaces by desired factor canvas.present( ) #canvas with trial and text stimuli above will be presented key, rt = exp.keyboard.wait(constants.K_ALL_DIGITS) exp.data.add( [ block_name, trial.get_factor('Stimulus'), trial.get_factor('Type'), trial.get_factor('Filenumber'), [chr(key)], key, rt ] ) #[chr(key)] dont get keyboard key number but number pressed by participant (useful for participants with different keyboards e.g. french/chinese)
def __init__(self, screen_size, position=[0, 0]): self.keys = list() self.index = int() self.Canvas = stimuli.Canvas([screen_size[0] - 100, 200], position, colour=[30, 30, 30]) self.MouseBool = False # fill list of piano keys according to order of appearance in key_info.py for iKey in key_mapping: k = PianoKey(iKey) self.keys.append(k) # plot the keys; first all whites and then black on top self.whities = [x for x in self.keys if x.white_key] self.blackies = [x for x in self.keys if x.white_key == False] for iKey in self.whities: iKey.Key.plot(self.Canvas) for iKey in self.blackies: iKey.Key.plot(self.Canvas)
def _test1(): info = """This will test the visual stimulus presentation timing specifics of your system. During the test, you will see two squares on the screen. After the test, you will be asked to indicate which (if any) of those two squares were flickering. [Press RETURN to continue]""" # TODO test very slow quit text = stimuli.TextScreen("Visual stimulus presentation test", info) #y = [] #for x in [16, 32, 48, 64]: # y.extend([x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, ]) #graph1 = _make_graph(range(60), y, [0, 255, 0]) #y = range(80) #graph2 = _make_graph(range(60), y, [255, 0, 0]) #graph1.position = (-200, -100) #graph2.position = (200, -100) text.present() #graph1.present(clear=False, update=False) #graph2.present(clear=False) exp.keyboard.wait([constants.K_RETURN]) message = stimuli.TextScreen("Running", "Please wait...") message.present() message.present() message.present() c1 = stimuli.Canvas((400, 400)) c2 = stimuli.Canvas((400, 400)) c3 = stimuli.Canvas((400, 400)) frame1 = stimuli.Rectangle((100, 100), position=(-100, 0)) frame2 = stimuli.Rectangle((100, 100), position=(100, 0)) bg = stimuli.Rectangle((90, 90), colour=exp.background_colour) bg.plot(frame1) bg.plot(frame2) frame1.plot(c1) frame2.plot(c2) frame1.plot(c3) frame2.plot(c3) c1.preload() c2.preload() c3.preload() c1.present(clear=False) c2.present(clear=False) c3.present(clear=False) s1 = stimuli.Circle(1, colour=exp.background_colour) s2 = stimuli.Circle(1, colour=exp.background_colour) s1.preload() s2.preload() todo_time = range(0, 60) * 3 randomize.shuffle_list(todo_time) actual_time = [] for x in todo_time: s1.present(clear=False) start = get_time() exp.clock.wait(x) s2.present(clear=False) actual_time.append((get_time() - start) * 1000) exp.clock.wait(expyriment.design.randomize.rand_int(30, 60)) # determine refresh_rate tmp = [] for _x in range(100): start = get_time() s1.present(clear=False) tmp.append(get_time() - start) start = get_time() s2.present(clear=False) tmp.append(get_time() - start) refresh_rate = 1000 / (statistics.mean(tmp) * 1000) #text = stimuli.TextScreen("Results", "[Press RETURN to continue]") #graph = _make_graph(todo_time, actual_time, [150, 150, 150]) #graph.position = (0, -100) #text.present(update=False) #graph.present(clear=False) #exp.keyboard.wait([constants.K_RETURN]) #text = stimuli.TextScreen( # "Which picture looks most similar to the results?", # "[Press LEFT or RIGHT arrow key]") #y = [] #for x in [16, 32, 48, 64]: # y.extend([x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, ]) #graph1 = _make_graph(range(60), y, [0, 255, 0]) #y = range(80) #graph2 = _make_graph(range(60), y, [255, 0, 0]) #graph1.position = (-200, -100) #graph2.position = (200, -100) #text.present(update=False) #graph1.present(clear=False, update=False) #graph2.present(clear=False) #key, _rt = exp.keyboard.wait([constants.K_LEFT, # constants.K_RIGHT]) #if key == constants.K_LEFT: # response1 = "Steps" #elif key == constants.K_RIGHT: # response1 = "Line" #else: # response1 = None # show histogram of presentation delays def expected_delay(presentation_time, refresh_rate): refresh_time = 1000.0 / refresh_rate return refresh_time - (presentation_time % refresh_time) # delay = map(lambda x: x[1]- x[0], zip(todo_time, actual_time)) unexplained_delay = map( lambda x: x[1] - x[0] - expected_delay(x[0], refresh_rate), zip(todo_time, actual_time)) hist, hist_str = _histogram(unexplained_delay) inaccuracies = [] delayed_presentations = 0 for key in hist.keys(): inaccuracies.extend([key % (1000 / refresh_rate)] * hist[key]) if key != 0: delayed_presentations += hist[key] inaccuracy = int(round(sum(inaccuracies) / float(len(inaccuracies)))) delayed = round(100 * delayed_presentations / 180.0, 2) text = stimuli.TextScreen( "How many of the two squares were flickering?", "[Press 0, 1 or 2]") text.present() key, _rt = exp.keyboard.wait( [constants.K_0, constants.K_1, constants.K_2]) if key == constants.K_0: response = 0 elif key == constants.K_1: response = 1 elif key == constants.K_2: response = 2 info = stimuli.TextScreen("Results", "") results1 = stimuli.TextScreen( "", "Estimated Screen Refresh Rate: {0} Hz (~ every {1} ms)\n\n". format(int(round(refresh_rate)), int(1000.0 / refresh_rate)), text_font="freemono", text_size=16, text_bold=True, text_justification=0, position=(0, 40)) results2 = stimuli.TextScreen( "", "Detected Framebuffer Pages: {0}\n\n".format(response + 1), text_font="freemono", text_size=16, text_bold=True, text_justification=0, position=(0, 20)) if inaccuracy != 0: results3_colour = [255, 0, 0] else: results3_colour = [0, 255, 0] results3 = stimuli.TextScreen( "", "Average Reporting Inaccuracy: {0} ms\n\n".format(inaccuracy), text_font="freemono", text_size=16, text_bold=True, text_justification=0, text_colour=results3_colour, position=(0, -20)) if delayed > 10: results4_colour = [255, 0, 0] elif 10 > delayed > 1: results4_colour = [255, 255, 0] else: results4_colour = [0, 255, 0] results4 = stimuli.TextScreen( "", "Unexplained Presentation Delays: {0} %\n\n\n".format(delayed), text_font="freemono", text_size=16, text_bold=True, text_justification=0, text_colour=results4_colour, position=(0, -40)) results5 = stimuli.TextScreen("", hist_str, text_font="freemono", text_size=16, text_bold=True, text_justification=0, position=(0, -100)) results1.plot(info) results2.plot(info) results3.plot(info) results4.plot(info) results5.plot(info) info2 = stimuli.TextLine("[Press RETURN to continue]", position=(0, -160)) info2.plot(info) info.present() exp.keyboard.wait([constants.K_RETURN]) return todo_time, actual_time, refresh_rate, inaccuracy, delayed, response
def run_test_suite(): """Run the Expyriment test suite.""" import expyriment.design.extras import expyriment.stimuli.extras import expyriment.io.extras import expyriment.misc.extras quit_experiment = False if not expyriment._active_exp.is_initialized: defaults.initialize_delay = 0 defaults.event_logging = 0 exp = expyriment.design.Experiment() exp.testsuite = True expyriment.control.initialize(exp) quit_experiment = True else: exp = expyriment._active_exp # make menu and code for test functions test_functions = ['', '', ''] menu = [ "1) Visual stimulus presentation", "2) Auditory stimulus presentation", "3) Font Viewer" ] for mod, cl in _find_self_tests(): test_functions.append("rtn = {0}.{1}._self_test(exp)".format(mod, cl)) menu.append("{0}) {1} test".format(len(test_functions), cl)) menu.append("{0}) Write protocol".format(len(test_functions) + 1)) menu.append("{0}) Quit".format(len(test_functions) + 2)) test_functions.extend( ['rtn = _write_protocol(exp, results)', 'go_on=False;rtn=[];']) background = stimuli.Canvas(size=[400, 600]) pict = stimuli.Picture(constants.EXPYRIMENT_LOGO_FILE, position=(0, 200)) pict.scale(0.5) pict.plot(background) results = expyriment.get_system_info() try: import android mouse = expyriment.io.Mouse(show_cursor=False) except ImportError: android = None mouse = None preselected_item = 0 go_on = True while go_on: select = expyriment.io.TextMenu("Test suite", menu, width=350, justification=0, background_stimulus=background, mouse=mouse).get(preselected_item) if select == 0: rtn = _stimulus_timing(exp) results["testsuite_visual_timing_todo"] = rtn[0] results["testsuite_visual_timing_actual"] = rtn[1] results["testsuite_visual_sync_refresh_rate"] = str(rtn[2]) + " Hz" results["testsuite_visual_timing_inaccuracy"] = str(rtn[3]) + " ms" results["testsuite_visual_timing_delayed"] = str(rtn[4]) + " %" results["testsuite_visual_flipping_user"] = rtn[5] delay = map( lambda x: x[1] - x[0], zip(results["testsuite_visual_timing_todo"], results["testsuite_visual_timing_actual"])) results["testsuite_visual_timing_delay_histogram"], _ = _histogram( delay) if ogl is not None and exp.screen.open_gl: results["testsuite_visual_opengl_vendor"] = ogl.glGetString( ogl.GL_VENDOR) results["testsuite_visual_opengl_renderer"] = ogl.glGetString( ogl.GL_RENDERER) results["testsuite_visual_opengl_version"] = ogl.glGetString( ogl.GL_VERSION) extensions = ogl.glGetString(ogl.GL_EXTENSIONS).split(" ") if extensions[-1] == "": extensions = extensions[:-1] results["testsuite_visual_opengl_extensions"] = extensions else: results["testsuite_visual_opengl_vendor"] = "" results["testsuite_visual_opengl_renderer"] = "" results["testsuite_visual_opengl_version"] = "" results["testsuite_visual_pygame_driver"] = "" results["testsuite_visual_opengl_extensions"] = "" results[ "testsuite_visual_pygame_driver"] = pygame.display.get_driver( ) results["testsuite_visual_pygame_screensize"] = exp.screen.size preselected_item = select + 1 elif select == 1: results["testsuite_audio_user"] = _audio_playback(exp) try: results["testsuite_audio_frequency"] = str( pygame.mixer.get_init()[0]) + " Hz" results["testsuite_audio_bitdepth"] = str( abs(pygame.mixer.get_init()[1])) + " bit" results["testsuite_audio_channels"] = pygame.mixer.get_init( )[2] except: results["testsuite_audio_frequency"] = "" results["testsuite_audio_bitdepth"] = "" results["testsuite_audio_channels"] = "" preselected_item = select + 1 elif select == 2: _font_viewer(exp) preselected_item = select + 1 else: exec(test_functions[select]) results.update(rtn) preselected_item = select + 1 if quit_experiment: expyriment.control.end(goodbye_delay=0, goodbye_text="Quitting test suite")
control.initialize(exp) ####################### Stimuli Preparation ################################## # load all card images in a dictionary mapping card name to Picture stimuli cards_directory = "cards_pics_small" stim = { op.splitext(f)[0]: stimuli.Picture(op.join(cards_directory, f)) for f in os.listdir(cards_directory) } # canvas mapped onto left, middle and right rectangles C = [ stimuli.Canvas((W, H), (-SHIFT, 0)), stimuli.Canvas((W, H), (0, 0)), stimuli.Canvas((W, H), (+SHIFT, 0)) ] # Create mapping 3 cards triplets -> surfaces three_cards_surfaces = dict() def create_3cards(card1, card2, card3): """ create a surface with the 3 cards """ surf = stimuli.Canvas((3 * W + 2 * GAP, H), (0, 0)) stim[card1].plot(C[0]) stim[card2].plot(C[1]) stim[card3].plot(C[2]) C[0].plot(surf)
def main_loop(exp, recorder, remote_control=False): """udp command: "start", "pause", "stop" "thresholds = [x,...]" : start level detection for Fz parameter and set threshold "thresholds stop" : stop level detection """ indicator_grid = 70 # distance between indicator center plotter_width = 900 plotter_position = (0, -30) s = GUIStatus( screen_refresh_interval_indicator=config. screen_refresh_interval_indicator, screen_refresh_interval_plotter=config. gui_screen_refresh_interval_plotter, recorder=recorder, remote_control=remote_control, level_detection_parameter=ForceData.forces_names.index( config.level_detection_parameter), # only one dimension screen_size=exp.screen.size, data_min_max=config.data_min_max, plotter_pixel_min_max=config.plotter_pixel_min_max, indicator_pixel_min_max=config.indicator_pixel_min_max, plot_axis=config.plot_axis) # plotter plotter_thread = None exp.keyboard.clear() while not s.quit_recording: ######## process loop if s.pause_recording: sleep(0.01) ################################ process keyboard s.process_key(exp.keyboard.check(check_for_control_keys=False)) ############################## process udp udp = recorder.process_and_write_udp_events() while len(udp) > 0: s.process_udp_event(udp.pop(0)) ########################### process new samples for x in s.check_new_samples(): s.update_history(sensor=x) if s.thresholds is not None: # level change detection level_change, tmp = s.thresholds.get_level_change( s.history[x].moving_average[s.level_detection_parameter], channel=x) if level_change: if x == 1: recorder.udp.send_queue.put(RcCmd.CHANGED_LEVEL2 + dumps(tmp)) else: recorder.udp.send_queue.put(RcCmd.CHANGED_LEVEL + dumps(tmp)) # minmax detection tmp = s.thresholds.get_response_minmax( s.history[x].moving_average[s.level_detection_parameter], channel=x) if tmp is not None: if x == 1: recorder.udp.send_queue.put(RcCmd.RESPONSE_MINMAX2 + dumps(tmp)) else: recorder.udp.send_queue.put(RcCmd.RESPONSE_MINMAX + dumps(tmp)) ######################## show pause or recording screen if s.check_recording_status_change(): if s.pause_recording: s.background.stimulus("writing data...").present() recorder.pause_recording() s.background.stimulus("Paused ('b' for baseline)").present() if remote_control: recorder.udp.send_queue.put(RcCmd.FEEDBACK_PAUSED) else: recorder.start_recording() s.set_start_recording_time() s.background.stimulus().present() if remote_control: recorder.udp.send_queue.put(RcCmd.FEEDBACK_STARTED) ########################### ########################### plotting ########################### if s.check_refresh_required(): #do not give priority to visual output update_rects = [] if s.check_thresholds_changed(): draw_plotter_thread_thresholds(plotter_thread, s.thresholds, s.scaling_plotter) if s.plot_indicator: ############################################ plot_indicator if plotter_thread is not None: plotter_thread.stop() plotter_thread = None ## indicator force_data_array = map( lambda x: s.sensor_processes[x[0]].get_force(x[1]), s.plot_data_indicator) for cnt in range(6): x_pos = (-3 * indicator_grid) + ( cnt * indicator_grid) + 0.5 * indicator_grid if cnt == s.level_detection_parameter: thr = s.thresholds else: thr = None li = level_indicator(value=force_data_array[cnt], text=s.plot_data_indicator_names[cnt], scaling=s.scaling_indicator, width=50, position=(x_pos, 0), thresholds=thr) li.present(update=False, clear=False) update_rects.append(get_pygame_rect(li, exp.screen.size)) #line zero = s.scaling_indicator.data2pixel( s.scaling_indicator.trim(0)) rect = stimuli.Line(start_point=(-200, zero), end_point=(200, zero), line_width=1, colour=misc.constants.C_YELLOW) rect.present(update=False, clear=False) update_rects.append(get_pygame_rect(rect, exp.screen.size)) # axis labels pos = (-220, -145) stimuli.Canvas(position=pos, size=(30, 20), colour=misc.constants.C_BLACK).present( update=False, clear=False) txt = stimuli.TextLine(position=pos, text=str(s.scaling_indicator.min), text_size=15, text_colour=misc.constants.C_YELLOW) txt.present(update=False, clear=False) update_rects.append(get_pygame_rect(txt, exp.screen.size)) pos = (-220, 145) stimuli.Canvas(position=pos, size=(30, 20), colour=misc.constants.C_BLACK).present( update=False, clear=False) txt = stimuli.TextLine(position=pos, text=str(s.scaling_indicator.max), text_size=15, text_colour=misc.constants.C_YELLOW) txt.present(update=False, clear=False) update_rects.append(get_pygame_rect(txt, exp.screen.size)) # end indicator stimuli.Canvas(position=(-250, 200), size=(200, 50), colour=misc.constants.C_BLACK).present( update=False, clear=False) txt = stimuli.TextBox( text=str(s.sensor_info_str), #background_colour=(30,30,30), size=(200, 50), text_size=15, position=(-250, 200), text_colour=misc.constants.C_YELLOW, text_justification=0) txt.present(update=False, clear=False) update_rects.append(get_pygame_rect(txt, exp.screen.size)) else: ############################################ plotter if plotter_thread is None: plotter_thread = PlotterThread( n_data_rows=len(s.plot_data_plotter), data_row_colours=colours[:len(s.plot_data_plotter)], y_range=[ s.scaling_plotter.pixel_min, s.scaling_plotter.pixel_max ], width=plotter_width, position=plotter_position, background_colour=[10, 10, 10], axis_colour=misc.constants.C_YELLOW) plotter_thread.start() if s.plot_axis: plotter_thread.set_horizontal_lines( y_values=[s.scaling_plotter.data2pixel(0)]) if s.thresholds is not None: plotter_thread.set_horizontal_lines( y_values=s.scaling_plotter.data2pixel( np.array(s.thresholds.thresholds))) if s.clear_screen: plotter_thread.clear_area() s.clear_screen = False if s.plot_filtered: tmp = np.array(map( lambda x: s.history[x[0]].moving_average[x[1]], s.plot_data_plotter), dtype=float) else: tmp = np.array(map( lambda x: s.sensor_processes[x[0]].get_force(x[1]), s.plot_data_plotter), dtype=float) if s.thresholds is not None: point_marker = s.thresholds.is_detecting_anything() else: point_marker = False plotter_thread.add_values( values=s.scaling_plotter.data2pixel(tmp), set_marker=s.set_marker, set_point_marker=point_marker) s.set_marker = False update_rects.append( plotter_thread.get_plotter_rect(exp.screen.size)) # axis labels axis_labels = (int(s.scaling_plotter.min), int(s.scaling_plotter.max), 0) xpos = plotter_position[0] - (plotter_width / 2) - 20 for cnt, ypos in enumerate( (plotter_position[1] + s.scaling_plotter.pixel_min + 10, plotter_position[1] + s.scaling_plotter.pixel_max - 10, plotter_position[1] + s.scaling_plotter.data2pixel(0))): stimuli.Canvas(position=(xpos, ypos), size=(50, 30), colour=misc.constants.C_BLACK).present( update=False, clear=False) txt = stimuli.TextLine(position=(xpos, ypos), text=str(axis_labels[cnt]), text_size=15, text_colour=misc.constants.C_YELLOW) txt.present(update=False, clear=False) update_rects.append(get_pygame_rect(txt, exp.screen.size)) # counter pos = (-230, 250) stimuli.Canvas(position=pos, size=(400, 50), colour=misc.constants.C_BLACK).present(update=False, clear=False) txt = stimuli.TextBox( position=pos, size=(400, 50), #background_colour=(30,30,30), text_size=15, text="n samples (total): {0}\nn samples: {1} ({2} sec.)". format( str(map(SensorProcess.get_sample_cnt, s.sensor_processes))[1:-1], str(map(SensorProcess.get_buffer_size, s.sensor_processes))[1:-1], s.recording_duration_in_sec), text_colour=misc.constants.C_YELLOW, text_justification=0) txt.present(update=False, clear=False) update_rects.append(get_pygame_rect(txt, exp.screen.size)) # Infos pos = (200, 250) tmp = stimuli.Canvas(position=pos, size=(400, 50), colour=misc.constants.C_BLACK) tmp.present(update=False, clear=False) update_rects.append(get_pygame_rect(tmp, exp.screen.size)) if s.thresholds is not None: if s.n_sensors > 1: tmp = [ s.thresholds.get_level( s.level_detection_parameter_average(0)), s.thresholds.get_level( s.level_detection_parameter_average(1)) ] else: tmp = s.thresholds.get_level( s.level_detection_parameter_average(0)) txt = stimuli.TextBox(position=pos, size=(400, 50), text_size=15, text="T: {0} L: {1}".format( s.thresholds, tmp), text_colour=misc.constants.C_YELLOW, text_justification=0) txt.present(update=False, clear=False) pos = (400, 250) tmp = stimuli.Canvas(position=pos, size=(400, 50), colour=misc.constants.C_BLACK) tmp.present(update=False, clear=False) update_rects.append(get_pygame_rect(tmp, exp.screen.size)) if s.plot_filtered: txt = stimuli.TextBox(position=pos, size=(400, 50), text_size=15, text="Filtered data!", text_colour=misc.constants.C_YELLOW, text_justification=0) txt.present(update=False, clear=False) # last_udp input if s.last_udp_data is not None: pos = (420, 250) stimuli.Canvas(position=pos, size=(200, 30), colour=misc.constants.C_BLACK).present( update=False, clear=False) txt = stimuli.TextBox( position=pos, size=(200, 30), #background_colour=(30,30,30), text_size=15, text="UDP:" + str(s.last_udp_data), text_colour=misc.constants.C_YELLOW, text_justification=0) txt.present(update=False, clear=False) update_rects.append(get_pygame_rect(txt, exp.screen.size)) pygame.display.update(update_rects) # end plotting screen ##### end main loop s.background.stimulus("Quitting").present() if plotter_thread is not None: plotter_thread.stop() recorder.pause_recording(s.background)
tone.preload() ## control.start(skip_ready_screen=True) clock = misc.Clock() exp.screen.clear() bs.present(update=True) nframe = 0 t1 = clock.time while clock.time - t1 <= 1000: bs.present(update=True) nframe += 1 FPS = nframe frame = stimuli.Canvas((800, 800)) msg = stimuli.TextScreen("", f"""This script displays a white rectangle, plays a tone and clears the screen, in a loop. This permits to check the timing with some external equipment (an oscilloscope, the Blackbox toolkit, etc.). The current parameters are: Tone duration = {TONE_DURATION} ms Display duration = {SQUARE_DURATION} ms Period = {PERIOD} ms FPS = {FPS} Hz Press any key for next screen (Later, to exit the program, just press 'Esc').""",
def initialize(experiment=None): """Initialize an experiment. This initializes an experiment defined by 'experiment' as well as the underlying expyriment system. If 'experiment' is None, a new Experiment object will be created and returned. Furthermore, a screen, a clock, a keyboard and a event file are created and added to the experiment. The initialization screen is shown for a short delay to ensure that Python is fully initialized and time accurate. Afterwards, "Preparing experiment..." is presented on the screen. After experiment initialize the following additional properties are available: - experiment.screen -- the current screen - experiment.clock -- the main clock - experiment.keyboard -- the main keyboard - experiment.mouse -- the main mouse - experiment.event -- the main event file Parameters ---------- experiment : design.Experiment, optional the experiment to initialize Returns ------- exp : design.Experiment initialized experiment """ if experiment is None: experiment = design.Experiment() if experiment.log_level is None: experiment.set_log_level(defaults.event_logging) if is_interactive_mode() and not expyriment.control.defaults.window_mode \ and not hasattr(experiment, "testsuite"): print """ Python is running in an interactive shell but Expyriment wants to initialize a fullscreen.""" quest = "Do you want to switch to windows mode?" ans = raw_input(quest + " (Y/n) ").strip().lower() if ans == "" or ans == "y" or ans == "yes": print "Switched to windows mode" expyriment.control.defaults.window_mode = True stdout_logging = defaults.stdout_logging expyriment._active_exp = experiment old_logging = experiment.log_level experiment.set_log_level(0) # switch off for the first screens _keyboard.quit_key = defaults.quit_key _keyboard.pause_key = defaults.pause_key _keyboard.refresh_key = defaults.refresh_key _keyboard.end_function = end _keyboard.pause_function = pause mixer.pre_init(defaults.audiosystem_sample_rate, defaults.audiosystem_bit_depth, defaults.audiosystem_channels, defaults.audiosystem_buffer_size) if defaults.audiosystem_autostart: mixer.init() mixer.init() # Needed on some systems experiment._clock = misc.Clock() experiment._screen = Screen(colour=(0, 0, 0), open_gl=defaults.open_gl, window_mode=defaults.window_mode, window_size=defaults.window_size) # Hack for IDLE: quit pygame and call atexit functions when crashing if is_idle_running() and sys.argv[0] != "": try: import idlelib.run def wrap(orig_func): def newfunc(*a, **kw): pygame.quit() import atexit atexit._run_exitfuncs() idlelib.run.flush_stdout = orig_func return orig_func(*a, **kw) return newfunc idlelib.run.flush_stdout = wrap(idlelib.run.flush_stdout) except ImportError: pass experiment._data = None experiment._subject = None experiment._is_initialized = True # required before EventFile if old_logging > 0: experiment._events = EventFile( additional_suffix=experiment.filename_suffix, time_stamp=True) if stdout_logging: _set_stdout_logging(experiment._events) else: experiment._events = None experiment._keyboard = Keyboard() experiment._mouse = Mouse(show_cursor=False) logo = stimuli.Picture(misc.constants.EXPYRIMENT_LOGO_FILE, position=(0, 100)) logo.scale((0.7, 0.7)) text = stimuli.TextLine("Version {0}".format(expyriment.get_version()), text_size=14, text_colour=misc.constants.C_EXPYRIMENT_ORANGE, background_colour=(0, 0, 0), position=(0, 40)) canvas = stimuli.Canvas((600, 300), colour=(0, 0, 0)) canvas2 = stimuli.Canvas((600, 300), colour=(0, 0, 0)) logo.plot(canvas) text.plot(canvas) hash_ = expyriment.get_experiment_secure_hash() if hash_ is not None: txt = "{0} ({1})".format(os.path.split(sys.argv[0])[1], hash_) if len(expyriment._secure_hash.module_hashes_as_string()) > 0: txt += ", {0}".format( expyriment._secure_hash.module_hashes_as_string()) text2 = stimuli.TextLine( txt, text_size=14, text_colour=misc.constants.C_EXPYRIMENT_ORANGE, background_colour=(0, 0, 0), position=(0, 10)) text2.plot(canvas) canvas.preload(True) canvas._set_surface(canvas._get_surface().convert()) start = experiment.clock.time r = [x for x in range(256) if x % 5 == 0] stopped = False if defaults.initialize_delay > 0: for x in r: canvas._get_surface().set_alpha(x) canvas2.clear_surface() canvas.plot(canvas2) canvas2.present() experiment.clock.wait(1) key = experiment.keyboard.check(pygame.K_ESCAPE, check_for_control_keys=False) if key is not None: stopped = True break duration = experiment.clock.time - start if duration < 2000 and not stopped: start = experiment.clock.time while experiment.clock.time - start < 2000: key = experiment.keyboard.check(pygame.K_ESCAPE, check_for_control_keys=False) if key is not None: stopped = True break r = [x for x in range(256)[::-1] if x % 5 == 0] if not stopped: for x in r: canvas._get_surface().set_alpha(x) canvas2.clear_surface() canvas.plot(canvas2) canvas2.present() experiment.clock.wait(1) key = experiment.keyboard.check(pygame.K_ESCAPE, check_for_control_keys=False) if key is not None: break stimuli.TextLine("Preparing experiment...", text_size=24, text_colour=misc.constants.C_EXPYRIMENT_PURPLE).present() experiment._screen.colour = experiment.background_colour experiment.set_log_level(old_logging) stimuli._stimulus.Stimulus._id_counter = 0 return experiment