def run(self): p = pyaudio.PyAudio() time_stamped = False stream = p.open( format=self.format, channels=self.channels, rate=self.rate, input=self.input, frames_per_buffer=self.frames_per_buffer, ) print "* recording" all = [] start_time = VisionEgg.time_func() i = 0 while (i <= self.rate / self.chunk * self.time) and ( (not time_stamped) or (VisionEgg.time_func() < end_time + 2) ): # for i in range(0, self.rate / self.chunk * self.time): data = stream.read(self.chunk) samps = numpy.fromstring(data, dtype=numpy.int16) all.append(data) loud = loudness(samps) # print str(i) + " " + str(loud) if (not time_stamped) and loud > self.sound_threshold: end_time = VisionEgg.time_func() self.q.put(start_time) self.q.put(end_time) # self.f.write("%s\t%f\t%f\t%f\t" % (self.item, end_time-start_time, start_time, end_time)) # self.f.flush() print "Crossed Threshold!" time_stamped = True i = i + 1 if not time_stamped: self.q.put(start_time) self.q.put(10000000) # self.f.write("%s\t%f\t%f\t%f\t" % (self.item, 10000000, start_time, 10000000.0)) print "* done recording" stream.close() p.terminate() # write data to WAVE file data = "".join(all) wf = wave.open(self.file_name, "wb") wf.setnchannels(self.channels) wf.setsampwidth(p.get_sample_size(self.format)) wf.setframerate(self.rate) wf.writeframes(data) wf.close()
def run(self, ID=0): self.ID = ID self.sound_fired = 0 super(RMLTrial, self).run() while not self.stopped: self.run_time = VisionEgg.time_func() - self.start_time if self.phase == 0: self.pre_experiment_time = VisionEgg.time_func() # this trial phase is ended with a enter press or TR pulse if self.ID != 0: self.phase_forward() if self.phase == 1: self.pre_stimulus_time = VisionEgg.time_func() if (self.pre_stimulus_time - self.pre_experiment_time) > self.phase_durations[1]: self.phase_forward() if self.phase == 2: self.stimulus_time = VisionEgg.time_func() if (self.stimulus_time - self.pre_stimulus_time) > self.phase_durations[2]: self.phase_forward() if self.phase == 3: self.tone_time = VisionEgg.time_func() if self.sound_fired == 0: if self.tracker != None: self.tracker.sendMessage( "trial " + str(self.ID) + " sound " + str(self.parameters["sound"]) + " at " + str(self.tone_time) ) if self.parameters["sound"] == 0: self.session.play_np_sound(self.noise_tone_array) elif self.parameters["sound"] == 1: self.session.play_sound(sound_index="reward") self.sound_fired = 1 # this trial phase is timed if (self.tone_time - self.stimulus_time) > self.phase_durations[3]: self.stopped = True # events and draw self.event() self.draw() self.stop()
def __init__(self, **kw): VisionEgg.Core.Stimulus.__init__(self,**kw) # store positions normalized around 0 so that re-sizing is ok num_dots = self.constant_parameters.num_dots # shorthand self.centers = np.random.standard_normal((3,num_dots)) self.colors = np.ones((num_dots,4)) self.colors[:self.constant_parameters.num_dark,:3] = 0 self.last_time_sec = VisionEgg.time_func() self.start_times_sec = None # setup variable, assign later
def __init__(self, **kw): VisionEgg.Core.Stimulus.__init__(self,**kw) # store positions normalized between 0 and 1 so that re-sizing is ok num_dots = self.constant_parameters.num_dots # shorthand self.x_positions = RandomArray.uniform(0.0,1.0,(num_dots,)) self.y_positions = RandomArray.uniform(0.0,1.0,(num_dots,)) self.random_directions_radians = RandomArray.uniform(0.0,2*math.pi,(num_dots,)) self.last_time_sec = VisionEgg.time_func() self.start_times_sec = None # setup variable, assign later self._gave_alpha_warning = 0
def run(self, ID = 0): self.ID = ID super(DetectTrial, self).run() while not self.stopped: self.run_time = VisionEgg.time_func() - self.start_time if self.phase == 0: self.prestimulation_time = VisionEgg.time_func() # this trial phase is ended with a space press on the first trial of a run, but timed on all other trials of a run. if ( self.prestimulation_time - self.start_time ) > self.phase_durations[1] and self.ID != 0: self.phase_forward() elif self.phase == 1: self.adaptation_time = VisionEgg.time_func() # this trial phase is timed if ( self.adaptation_time - self.prestimulation_time ) > self.phase_durations[1]: self.phase_forward() elif self.phase == 2: # this trial phase is timed self.post_adaptation_time = VisionEgg.time_func() if ( self.post_adaptation_time - self.adaptation_time ) > self.phase_durations[2]: self.session.play_sound( sound_index = 1 ) self.phase_forward() elif self.phase == 3: # this trial phase is timed self.first_test_time = VisionEgg.time_func() if ( self.first_test_time - self.post_adaptation_time ) > self.phase_durations[3]: self.phase_forward() elif self.phase == 4: # this trial phase is timed self.inter_test_time = VisionEgg.time_func() if ( self.inter_test_time - self.first_test_time ) > self.phase_durations[4]: self.session.play_sound( sound_index = 1 ) self.phase_forward() elif self.phase == 5: # this trial phase is timed self.last_test_time = VisionEgg.time_func() if ( self.last_test_time - self.inter_test_time ) > self.phase_durations[5]: self.phase_forward() elif self.phase == 6: self.answer_time = VisionEgg.time_func() - self.last_test_time elif self.phase == 7: self.post_answer_time = VisionEgg.time_func() - self.answer_time # events and draw self.event() self.draw() # we have stopped. self.stop()
def event(self): for event in pygame.event.get(): super(RMLTrial, self).key_event(event) if event.type == KEYDOWN: if event.key == pygame.locals.K_ESCAPE: self.events.append([-99, VisionEgg.time_func() - self.start_time]) self.stopped = True self.session.stopped = True # it handles both numeric and lettering modes elif ( event.key == pygame.locals.K_RETURN or event.key == pygame.locals.K_t ): # press enter (or TR pulse) to start experiment self.events.append([0, VisionEgg.time_func() - self.start_time]) if self.phase == 0: self.phase_forward() elif event.key == pygame.locals.K_SPACE: if self.phase != 0: # only register space bar presses after experiment has started self.events.append( [1, VisionEgg.time_func() - self.start_time] ) # register space bar presses with '1' and save timestamp self.session.reversal_keypresses += ( 1 ) # save self.reversal_keypresses to be able to print it in the terminal later
def draw(self): # XXX This method is not speed-optimized. I just wrote it to # get the job done. (Nonetheless, it seems faster than the C # version commented out above.) p = self.parameters # shorthand now_sec = VisionEgg.time_func() if self.start_times_sec is not None: # compute extinct dots and generate new positions replace_indices = Numeric.nonzero( Numeric.greater( now_sec - self.start_times_sec, p.dot_lifespan_sec) ) Numeric.put( self.start_times_sec, replace_indices, now_sec ) new_centers = np.random.standard_normal((3,len(replace_indices))) for i in range(3): Numeric.put( self.centers[i,:], replace_indices, new_centers[i,:] ) else: # initialize dot extinction values to random (uniform) distribution self.start_times_sec = RandomArray.uniform( now_sec - p.dot_lifespan_sec, now_sec, (self.constant_parameters.num_dots,)) time_delta_sec = now_sec - self.last_time_sec self.last_time_sec = now_sec # reset for next loop self.centers = self.centers + np.array(p.signal_vec)[:,np.newaxis]*time_delta_sec xyz = self.centers*p.start_position_variance + np.array(p.start_position_mean)[:,np.newaxis] xs = xyz[0,:] ys = xyz[1,:] zs = xyz[2,:] if p.on: gl.glEnable( gl.GL_POINT_SMOOTH ) # allow max_alpha value to control blending gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) gl.glPointSize(p.dot_size) # Clear the modeview matrix gl.glMatrixMode(gl.GL_MODELVIEW) gl.glPushMatrix() gl.glDisable(gl.GL_TEXTURE_2D) draw_dots(xs,ys,zs,self.colors) gl.glDisable( gl.GL_POINT_SMOOTH ) # turn off gl.glPopMatrix()
def __init__(self, **kw): VisionEgg.Core.Stimulus.__init__(self,**kw) # store positions normalized between 0 and 1 so that re-sizing is ok num_dots = self.constant_parameters.num_dots # shorthand self.x_positions = RandomArray.uniform(0.0,1.0,(num_dots,)) self.y_positions = RandomArray.uniform(0.0,1.0,(num_dots,)) if self.parameters.mode == "wind": self.random_directions_radians = RandomArray.uniform(0.0,2*math.pi,(num_dots,)) self.velocities = RandomArray.uniform(self.parameters.velocity_max-1, self.parameters.velocity_max,(num_dots,)) elif self.parameters.mode == "Gaussian": self.random_directions_radians = numpy.random.normal(self.parameters.signal_direction_deg/180.0*math.pi, self.parameters.signal_fraction,(num_dots,)) self.velocities = RandomArray.uniform(self.parameters.velocity_min, self.parameters.velocity_max,(num_dots,)) self.last_time_sec = VisionEgg.time_func() self.start_times_sec = None # setup variable, assign later self._gave_alpha_warning = 0
def event(self): for event in pygame.event.get(): if event.type == KEYDOWN: if event.key == pygame.locals.K_ESCAPE: self.events.append([-99,VisionEgg.time_func()-self.start_time]) self.parameters.update({'correct': 0}) self.stopped = True self.session.stopped = True # it handles both numeric and lettering modes elif event.key == pygame.locals.K_SPACE: self.events.append([0,VisionEgg.time_func()-self.start_time]) if self.phase in (0, 4): self.phase_forward() # else: # self.stopped = True elif event.key == pygame.locals.K_LEFT: self.events.append([1,VisionEgg.time_func()-self.start_time]) if self.version == 1: if self.phase == 2: self.parameters.update({'answer':1}) if self.parameters['target_present_in_stimulus'] == 0: self.parameters['correct']= 1 else: self.parameters['correct']= 0 if self.phase == 2: self.phase_forward() if self.version == 2: if self.phase == 2: self.parameters.update({'answer':1}) if self.parameters['target_present_in_stimulus'] == 1: self.parameters['correct']= 1 else: self.parameters['correct']= 0 if self.phase == 2: self.phase_forward() elif event.key == pygame.locals.K_RIGHT: self.events.append([-1,VisionEgg.time_func()-self.start_time]) if self.version == 1: if self.phase == 2: self.parameters.update({'answer':-1}) if self.parameters['target_present_in_stimulus'] == 1: self.parameters['correct']= 1 else: self.parameters['correct']= 0 if self.phase == 2: self.phase_forward() if self.version == 2: if self.phase == 2: self.parameters.update({'answer':-1}) if self.parameters['target_present_in_stimulus'] == 0: self.parameters['correct']= 1 else: self.parameters['correct']= 0 if self.phase == 2: self.phase_forward() elif event.key == pygame.locals.K_a: if self.phase > 3: self.parameters['confidence'] = 0 if self.phase == 4: self.phase_forward() elif event.key == pygame.locals.K_s: if self.phase > 3: self.parameters['confidence'] = 1 if self.phase == 4: self.phase_forward() elif event.key == pygame.locals.K_d: if self.phase > 3: self.parameters['confidence'] = 2 if self.phase == 4: self.phase_forward() elif event.key == pygame.locals.K_f: if self.phase > 3: self.parameters['confidence'] = 3 if self.phase == 4: self.phase_forward() super(DetectTrial, self).key_event( event )
def draw(self): # XXX This method is not speed-optimized. I just wrote it to # get the job done. (Nonetheless, it seems faster than the C # version commented out above.) p = self.parameters # shorthand if p.center is not None: if not hasattr(VisionEgg.config, "_GAVE_CENTER_DEPRECATION"): logger = logging.getLogger('VisionEgg.Dots') logger.warning("Specifying DotArea2D by deprecated " "'center' parameter deprecated. Use " "'position' parameter instead. (Allows " "use of 'anchor' parameter to set to " "other values.)") VisionEgg.config._GAVE_CENTER_DEPRECATION = 1 p.anchor = 'center' p.position = p.center[0], p.center[ 1] # copy values (don't copy ref to tuple) if p.on: # calculate center center = VisionEgg._get_center(p.position, p.anchor, p.size) if p.anti_aliasing: if len(p.color) == 4 and not self._gave_alpha_warning: if p.color[3] != 1.0: logger = logging.getLogger('VisionEgg.Dots') logger.warning("The parameter anti_aliasing is " "set to true in the DotArea2D " "stimulus class, but the color " "parameter specifies an alpha " "value other than 1.0. To " "acheive the best anti-aliasing, " "ensure that the alpha value for " "the color parameter is 1.0.") self._gave_alpha_warning = 1 gl.glEnable(gl.GL_POINT_SMOOTH) # allow max_alpha value to control blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) else: gl.glDisable(gl.GL_BLEND) now_sec = VisionEgg.time_func() if self.start_times_sec is not None: # compute extinct dots and generate new positions replace_indices = Numeric.nonzero( Numeric.greater(now_sec - self.start_times_sec, p.dot_lifespan_sec)) Numeric.put(self.start_times_sec, replace_indices, now_sec) new_x_positions = RandomArray.uniform(0.0, 1.0, (len(replace_indices), )) Numeric.put(self.x_positions, replace_indices, new_x_positions) new_y_positions = RandomArray.uniform(0.0, 1.0, (len(replace_indices), )) Numeric.put(self.y_positions, replace_indices, new_y_positions) new_random_directions_radians = RandomArray.uniform( 0.0, 2 * math.pi, (len(replace_indices), )) Numeric.put(self.random_directions_radians, replace_indices, new_random_directions_radians) else: # initialize dot extinction values to random (uniform) distribution self.start_times_sec = RandomArray.uniform( now_sec - p.dot_lifespan_sec, now_sec, (self.constant_parameters.num_dots, )) signal_num_dots = int( round(p.signal_fraction * self.constant_parameters.num_dots)) time_delta_sec = now_sec - self.last_time_sec self.last_time_sec = now_sec # reset for next loop x_increment_normalized = math.cos( p.signal_direction_deg / 180.0 * math.pi ) * p.velocity_pixels_per_sec / p.size[0] * time_delta_sec y_increment_normalized = -math.sin( p.signal_direction_deg / 180.0 * math.pi ) * p.velocity_pixels_per_sec / p.size[1] * time_delta_sec self.x_positions[:signal_num_dots] += x_increment_normalized self.y_positions[:signal_num_dots] += y_increment_normalized num_random_dots = self.constant_parameters.num_dots - signal_num_dots random_x_increment_normalized = Numeric.cos( self.random_directions_radians[signal_num_dots:] ) * p.velocity_pixels_per_sec / p.size[0] * time_delta_sec random_y_increment_normalized = -Numeric.sin( self.random_directions_radians[signal_num_dots:] ) * p.velocity_pixels_per_sec / p.size[1] * time_delta_sec self.x_positions[signal_num_dots:] += random_x_increment_normalized self.y_positions[signal_num_dots:] += random_y_increment_normalized self.x_positions = Numeric.fmod(self.x_positions, 1.0) # wrap self.y_positions = Numeric.fmod(self.y_positions, 1.0) self.x_positions = Numeric.fmod(self.x_positions + 1, 1.0) # wrap again for values < 1 self.y_positions = Numeric.fmod(self.y_positions + 1, 1.0) xs = (self.x_positions - 0.5) * p.size[0] + center[0] ys = (self.y_positions - 0.5) * p.size[1] + center[1] if len(p.color) == 3: gl.glColor3f(*p.color) elif len(p.color) == 4: gl.glColor4f(*p.color) gl.glPointSize(p.dot_size) # Clear the modeview matrix gl.glMatrixMode(gl.GL_MODELVIEW) gl.glPushMatrix() gl.glDisable(gl.GL_TEXTURE_2D) if p.depth is None: depth = 0.0 else: gl.glEnable(gl.GL_DEPTH_TEST) depth = p.depth zs = (depth, ) * len(xs) # make N tuple with repeat value of depth draw_dots(xs, ys, zs) if p.anti_aliasing: gl.glDisable(gl.GL_POINT_SMOOTH) # turn off gl.glPopMatrix()
def run(self, ID = 0): self.ID = ID super(DetectTrial, self).run() sound_played = False # self.start_time = VisionEgg.time_func() while not self.stopped: self.run_time = VisionEgg.time_func() - self.start_time if self.phase == 0: self.prestimulation_time = VisionEgg.time_func() if self.ID % 15 != 0: if ( self.prestimulation_time - self.start_time ) > self.phase_durations[0]: self.phase_forward() # this trial phase is ended with a space press on the first trial of a run, but timed on all other trials of a run. elif self.phase == 1: # first delay self.delay_1_time = VisionEgg.time_func() # this trial phase is timed if ( self.delay_1_time - self.prestimulation_time ) > self.phase_durations[1] - 0.1 and sound_played == False: self.session.play_sound( sound_index = 1 ) sound_played = True if ( self.delay_1_time - self.prestimulation_time ) > self.phase_durations[1]: self.phase_forward() elif self.phase == 2: # stimulus presentation # this trial phase is timed self.test_time = VisionEgg.time_func() if ( self.test_time - self.delay_1_time ) > self.phase_durations[2]: self.phase_forward() elif self.phase == 3: # second delay # this trial phase is timed self.delay_2_time = VisionEgg.time_func() if ( self.delay_2_time - self.test_time ) > self.phase_durations[3]: this_prob = np.random.rand() # print this_prob, self.ID if (this_prob < 0.1 or self.parameters['correct'] == -1) and not hasattr(self, 'has_been_extended'): self.phase_durations[3] = self.phase_durations[3] + 2.0 self.has_been_extended = True else: self.stopped = True return if this_prob < 0.1: if self.version == 1: if self.parameters['correct'] == 1: self.session.play_sound( sound_index = 2 ) elif self.parameters['correct'] == 0: self.session.play_sound( sound_index = 0 ) if self.version == 2: if self.parameters['correct'] == 1: self.session.play_sound( sound_index = 0 ) elif self.parameters['correct'] == 0: self.session.play_sound( sound_index = 2 ) if self.parameters['correct'] == -1: self.session.play_sound( sound_index = 3 ) # elif self.phase == 4: # confidence # self.confidence_time = VisionEgg.time_func() # elif self.phase == 5: # third delay # self.delay_3_time = VisionEgg.time_func() # if ( self.delay_3_time - self.confidence_time ) > self.phase_durations[5]: # self.feedback_given = False # self.phase_forward() # elif self.phase == 6: # feedback # self.feedback_time = VisionEgg.time_func() # if self.feedback_given == False and ( self.feedback_time - self.delay_3_time ) > 0.1: # if self.version == 1: # if self.parameters['correct'] == 1: # self.session.play_sound( sound_index = 2 ) # elif self.parameters['correct'] == 0: # self.session.play_sound( sound_index = 0 ) # if self.version == 2: # if self.parameters['correct'] == 1: # self.session.play_sound( sound_index = 0 ) # elif self.parameters['correct'] == 0: # self.session.play_sound( sound_index = 2 ) # elif self.parameters['correct'] == -1: # self.session.play_sound( sound_index = 3 ) # self.feedback_given = True # if ( self.feedback_time - self.delay_3_time ) > self.phase_durations[6]: # self.phase_forward() # elif self.phase == 7: # fourth delay # self.delay_4_time = VisionEgg.time_func() # if ( self.delay_4_time - self.feedback_time ) > self.phase_durations[7]: # self.stopped = True # events and draw self.event() self.draw() # we have stopped. self.stop()
def event(self): for event in pygame.event.get(): if event.type == KEYDOWN: if event.key == pygame.locals.K_ESCAPE: self.events.append([-99,VisionEgg.time_func()-self.start_time]) self.parameters.update({'correct': 0}) self.stopped = True self.session.stopped = True # it handles both numeric and lettering modes elif event.key == pygame.locals.K_SPACE: self.events.append([0,VisionEgg.time_func()-self.start_time]) if self.phase in (0, 4): self.phase_forward() # else: # self.stopped = True elif event.key == pygame.locals.K_LEFT: self.events.append([1,VisionEgg.time_func()-self.start_time]) if self.version == 1: if self.phase == 2: self.parameters.update({'answer':1}) if self.parameters['target_present_in_stimulus'] == 0: self.parameters['correct']= 1 else: self.parameters['correct']= 0 if self.phase == 2: self.phase_forward() if self.version == 2: if self.phase == 2: self.parameters.update({'answer':1}) if self.parameters['target_present_in_stimulus'] == 1: self.parameters['correct']= 1 else: self.parameters['correct']= 0 if self.phase == 2: self.phase_forward() if self.phase == 0: self.nr_buttons_pressed = self.nr_buttons_pressed + 1 self.tracker.sendCommand('record_status_message "Trial %d, Buttonpress %d"'%(self.ID, self.nr_buttons_pressed)) elif event.key == pygame.locals.K_RIGHT: self.events.append([-1,VisionEgg.time_func()-self.start_time]) if self.version == 1: if self.phase == 2: self.parameters.update({'answer':-1}) if self.parameters['target_present_in_stimulus'] == 1: self.parameters['correct']= 1 else: self.parameters['correct']= 0 if self.phase == 2: self.phase_forward() if self.version == 2: if self.phase == 2: self.parameters.update({'answer':-1}) if self.parameters['target_present_in_stimulus'] == 0: self.parameters['correct']= 1 else: self.parameters['correct']= 0 if self.phase == 2: self.phase_forward() if self.phase == 0: self.nr_buttons_pressed = self.nr_buttons_pressed + 1 self.tracker.sendCommand('record_status_message "Trial %d, Buttonpress %d"'%(self.ID, self.nr_buttons_pressed)) if event.key == pygame.locals.K_c: if self.ID % 15 == 0: self.session.tracker_setup(auto_trigger_calibration = True, calibration_type = 'HV5', sample_rate = 1000) elif event.key == pygame.locals.K_a: if self.phase > 3: self.parameters['confidence'] = 0 if self.phase == 4: self.phase_forward() elif event.key == pygame.locals.K_s: if self.phase > 3: self.parameters['confidence'] = 1 if self.phase == 4: self.phase_forward() elif event.key == pygame.locals.K_d: if self.phase > 3: self.parameters['confidence'] = 2 if self.phase == 4: self.phase_forward() elif event.key == pygame.locals.K_f: if self.phase > 3: self.parameters['confidence'] = 3 if self.phase == 4: self.phase_forward() super(DetectTrial, self).key_event( event )
screen = get_default_screen() screen.parameters.bgcolor = (0.0,0.0,0.2) # background blue (RGB) text=VisionEgg.Text.PangoText( color=(1.0,1.0,1.0), # alpha is ignored (set with max_alpha_param) position=(0,screen.size[1]/2), size = (screen.size[0],max(screen.size[0]/10,10)), anchor='left') viewport = Viewport(screen=screen, size=screen.size, stimuli=[text]) # The main loop below is an alternative to using the # VisionEgg.FlowControl.Presentation class. frame_timer = FrameTimer() quit_now = 0 while not quit_now: for event in pygame.event.get(): if event.type in (QUIT,KEYDOWN,MOUSEBUTTONDOWN): quit_now = 1 idx = int(VisionEgg.time_func()%len(language)) text.parameters.text = "%s: %s"%(language[idx],phrase[idx]) screen.clear() viewport.draw() swap_buffers() frame_timer.tick() frame_timer.log_histogram()
def draw(self): p = self.parameters # shorthand if p.on: # calculate center center = VisionEgg._get_center(p.position,p.anchor,p.size) if p.mask: gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB) gl.glBindTexture(gl.GL_TEXTURE_1D,self._texture_object_id) gl.glEnable(gl.GL_TEXTURE_1D) gl.glDisable(gl.GL_TEXTURE_2D) if p.bit_depth != self.cached_bit_depth: self.calculate_bit_depth_dependencies() # Clear the modeview matrix gl.glMatrixMode(gl.GL_MODELVIEW) gl.glPushMatrix() # Rotate about the center of the texture gl.glTranslate(center[0], center[1], 0) gl.glRotate(p.orientation,0,0,1) if p.depth is None: gl.glDisable(gl.GL_DEPTH_TEST) depth = 0.0 else: gl.glEnable(gl.GL_DEPTH_TEST) depth = p.depth # allow max_alpha value to control blending gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) if p.color2: gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_BLEND) gl.glTexEnvfv(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_COLOR, p.color2) ## alpha is ignored because the texture base internal format is luminance else: gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE) if p.t0_time_sec_absolute is None and not p.ignore_time: p.t0_time_sec_absolute = VisionEgg.time_func() w = p.size[0] inc = w/float(p.num_samples) if p.ignore_time: phase = p.phase_at_t0 else: t_var = VisionEgg.time_func() - p.t0_time_sec_absolute phase = t_var*p.temporal_freq_hz*-360.0 + p.phase_at_t0 if p.recalculate_phase_tolerance is None or abs(self._last_phase - phase) > p.recalculate_phase_tolerance: self._last_phase = phase # we're re-drawing the phase at this angle floating_point_sin = numpy.sin(2.0*math.pi*p.spatial_freq*numpy.arange(0.0,w,inc,dtype=numpy.float)+(phase/180.0*math.pi))*0.5*p.contrast+p.pedestal floating_point_sin = numpy.clip(floating_point_sin,0.0,1.0) # allow square wave generation if contrast > 1 texel_data = (floating_point_sin*self.max_int_val).astype(self.numpy_dtype) # PyOpenGL 2.0.1.09 has a bug, so use our own wrapper _vegl.veglTexSubImage1D(gl.GL_TEXTURE_1D, # target 0, # level 0, # x offset p.num_samples, # width self.format, # format of new texel data self.gl_type, # type of new texel data texel_data) # new texel data if 0: compare_array = numpy.empty(texel_data.shape,dtype=texel_data.dtype) pixels = _vegl.veglGetTexImage(gl.GL_TEXTURE_1D, # target 0, # level self.format, # format self.gl_type, # type compare_array) assert numpy.allclose( compare_array, texel_data ) h_w = p.size[0]/2.0 h_h = p.size[1]/2.0 l = -h_w r = h_w b = -h_h t = h_h # in the case of only color1, # the texel data multiplies color1 to produce a color # with color2, # the texel data linearly interpolates between color1 and color2 gl.glColor4f(p.color1[0],p.color1[1],p.color1[2],p.max_alpha) if p.mask: p.mask.draw_masked_quad(0.0,1.0,0.0,1.0, # l,r,b,t for texture coordinates l,r,b,t, # l,r,b,t in eye coordinates depth ) # also in eye coordinates else: # draw unmasked quad gl.glBegin(gl.GL_QUADS) gl.glTexCoord2f(0.0,0.0) gl.glVertex3f(l,b,depth) gl.glTexCoord2f(1.0,0.0) gl.glVertex3f(r,b,depth) gl.glTexCoord2f(1.0,1.0) gl.glVertex3f(r,t,depth) gl.glTexCoord2f(0.0,1.0) gl.glVertex3f(l,t,depth) gl.glEnd() # GL_QUADS gl.glDisable(gl.GL_TEXTURE_1D) gl.glPopMatrix()
def getState(t): global ISI, next_stim_time, direction, last_direction, arrow_scale, score global first_loop, start_time, StimCount, stimVis, fbVis, stimText global score_factor, arrowColor, leftText, rightText global left_strings, right_strings, stimulus_strings, show_array global currentTime, currentShow, currentSign, currentTR # CC added for TCPIP and detrends global tcp_dist, dist_detrend, dist_array, time_array, dist global startDetrend, detrendLag global ALPHA_MAX, ALPHA_SCALE global lumina_dev currentTime = t if (first_loop == 1) and (p.parameters.trigger_go_if_armed): first_loop = 0 start_time = VisionEgg.time_func() if TCPIP: tcp_listener.buffer="" # reset buffer if t > next_stim_time: StimCount = StimCount + 1 currentShow = int(np.abs(show_array[StimCount])) currentSign = int(np.sign(show_array[StimCount])) stimText = stimulus_strings[StimCount] leftText = left_strings[StimCount] rightText = right_strings[StimCount] next_stim_time = next_stim_time + ISI if StimCount > detrendLag: startDetrend=True #### # note: When run with SVR testing, the input values #### # will range from (-inf,inf), most likely (-5,5) if TCPIP: tcp_buffer=str(tcp_listener.buffer) #print "%s (%s)" %('tcp_data', tcp_buffer) tcp_data=tcp_buffer.replace('\000', ''); # remove null byte #print "%s (%s) (%s)" %('tcp_data', tcp_data, tcp_buffer) if tcp_data != '\000' and tcp_data != "" and \ "nan" not in tcp_data.lower(): vals=tcp_data.split(",") if len(vals) > 1: tcp_dist=float(vals[1]) else: tcp_dist=float(tcp_data) tcp_listener.buffer="" # reset buffer dist_array = dist_array + [tcp_dist] time_array = time_array + [t] if DETREND == 1: if startDetrend: dist_detrend = detrendDist(time_array, dist_array) else: dist_detrend = tcp_dist arrow_scale=dist_detrend else: arrow_scale=tcp_dist if currentShow == 9999 or FEEDBACK == 0: fbVis = 0 score = 90.0 arrowColor = 0 else: fbVis = 1 arrowColor = 1 # increment the score score = score - currentSign*arrow_scale*score_factor if score < 0: score = 0 elif score > 180: score = 180 log.write("%5.3f; STIM; %s; %s; %s; %d; %d; %5.3f; %5.3f; %5.3f\n" \ %(t, leftText, rightText, stimText, currentShow, \ currentSign, tcp_dist, arrow_scale, score)) # handle anything that comes in on the button boxes #print "About to test LUMINA", #print lumina_dev if LUMINA == 1: lumina_dev.poll_for_response() while lumina_dev.response_queue_size() > 0: response = lumina_dev.get_next_response() if response["pressed"]: print "Lumina received: %s, %d"%(response["key"],response["key"]) if response["key"] == 4: log.write("%5.3f; TR; %s\n"%(currentTime,currentTR)) currentTR=currentTR+1 else: log.write("%5.3f; LUMINA; %d\n"%(currentTime,response["key"])) #print "TESTED LUMINA" return 1
def draw(self): p = self.parameters # shorthand if p.on: if p.mask: gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB) if p.depth_test: gl.glEnable(gl.GL_DEPTH_TEST) else: gl.glDisable(gl.GL_DEPTH_TEST) if p.polygon_offset_enabled: gl.glEnable(gl.GL_POLYGON_OFFSET_EXT) gl.glPolygonOffset(p.polygon_offset_factor, p.polygon_offset_units) gl.glBindTexture(gl.GL_TEXTURE_1D, self._texture_object_id) gl.glEnable(gl.GL_TEXTURE_1D) gl.glDisable(gl.GL_TEXTURE_2D) if p.bit_depth != self.cached_bit_depth: self.calculate_bit_depth_dependencies() # allow max_alpha value to control blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) if p.color2: gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_BLEND) gl.glTexEnvfv(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_COLOR, p.color2) ## alpha is ignored because the texture base internal format is luminance else: gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE) if p.t0_time_sec_absolute is None and not p.ignore_time: p.t0_time_sec_absolute = VisionEgg.time_func() w = p.size[0] inc = w / float(p.num_samples) if p.ignore_time: phase = p.phase_at_t0 else: t_var = VisionEgg.time_func() - p.t0_time_sec_absolute phase = t_var * p.temporal_freq_hz * -360.0 + p.phase_at_t0 if p.recalculate_phase_tolerance is None or abs(self._last_phase - phase) > p.recalculate_phase_tolerance: self._last_phase = phase # we're re-drawing the phase at this angle floating_point_sin = ( numpy.sin( 2.0 * math.pi * p.spatial_freq * numpy.arange(0.0, w, inc, dtype=numpy.float) + (phase / 180.0 * math.pi) ) * 0.5 * p.contrast + p.pedestal ) floating_point_sin = numpy.clip( floating_point_sin, 0.0, 1.0 ) # allow square wave generation if contrast > 1 texel_data = (floating_point_sin * self.max_int_val).astype(self.numpy_dtype).tostring() gl.glTexSubImage1D( gl.GL_TEXTURE_1D, # target 0, # level 0, # x offset p.num_samples, # width self.format, # format of new texel data self.gl_type, # type of new texel data texel_data, ) # new texel data # in the case of only color1, # the texel data multiplies color1 to produce a color # with color2, # the texel data linearly interpolates between color1 and color2 gl.glColor4f(p.color1[0], p.color1[1], p.color1[2], p.max_alpha) if p.mask: p.mask.draw_masked_quad_3d( 0.0, 1.0, 0.0, 1.0, p.lowerleft, p.lowerright, p.upperright, p.upperleft # for texture coordinates ) else: # draw unmasked quad gl.glBegin(gl.GL_QUADS) gl.glTexCoord2f(0.0, 0.0) gl.glVertex(*p.lowerleft) gl.glTexCoord2f(1.0, 0.0) gl.glVertex(*p.lowerright) gl.glTexCoord2f(1.0, 1.0) gl.glVertex(*p.upperright) gl.glTexCoord2f(0.0, 1.0) gl.glVertex(*p.upperleft) gl.glEnd() # GL_QUADS gl.glDisable(gl.GL_TEXTURE_1D) if p.polygon_offset_enabled: gl.glDisable(gl.GL_POLYGON_OFFSET_EXT)
def draw(self): p = self.parameters # shorthand if p.on: # calculate center center = VisionEgg._get_center(p.position, p.anchor, p.size) if p.mask: gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB) gl.glBindTexture(gl.GL_TEXTURE_1D, self._texture_object_id) gl.glEnable(gl.GL_TEXTURE_1D) gl.glDisable(gl.GL_TEXTURE_2D) if p.bit_depth != self.cached_bit_depth: self.calculate_bit_depth_dependencies() # Clear the modeview matrix gl.glMatrixMode(gl.GL_MODELVIEW) gl.glPushMatrix() # Rotate about the center of the texture gl.glTranslate(center[0], center[1], 0) gl.glRotate(p.orientation, 0, 0, 1) if p.depth is None: gl.glDisable(gl.GL_DEPTH_TEST) depth = 0.0 else: gl.glEnable(gl.GL_DEPTH_TEST) depth = p.depth # allow max_alpha value to control blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) if p.color2: gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_BLEND) gl.glTexEnvfv(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_COLOR, p.color2) ## alpha is ignored because the texture base internal format is luminance else: gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE) if p.t0_time_sec_absolute is None and not p.ignore_time: p.t0_time_sec_absolute = VisionEgg.time_func() w = p.size[0] inc = w / float(p.num_samples) if p.ignore_time: phase = p.phase_at_t0 else: t_var = VisionEgg.time_func() - p.t0_time_sec_absolute phase = t_var * p.temporal_freq_hz * -360.0 + p.phase_at_t0 if p.recalculate_phase_tolerance is None or abs(self._last_phase - phase) > p.recalculate_phase_tolerance: self._last_phase = phase # we're re-drawing the phase at this angle floating_point_sin = ( numpy.sin( 2.0 * math.pi * p.spatial_freq * numpy.arange(0.0, w, inc, dtype=numpy.float) + (phase / 180.0 * math.pi) ) * 0.5 * p.contrast + p.pedestal ) floating_point_sin = numpy.clip( floating_point_sin, 0.0, 1.0 ) # allow square wave generation if contrast > 1 texel_data = (floating_point_sin * self.max_int_val).astype(self.numpy_dtype) # PyOpenGL 2.0.1.09 has a bug, so use our own wrapper _vegl.veglTexSubImage1D( gl.GL_TEXTURE_1D, # target 0, # level 0, # x offset p.num_samples, # width self.format, # format of new texel data self.gl_type, # type of new texel data texel_data, ) # new texel data if 0: compare_array = numpy.empty(texel_data.shape, dtype=texel_data.dtype) pixels = _vegl.veglGetTexImage( gl.GL_TEXTURE_1D, # target 0, # level self.format, # format self.gl_type, # type compare_array, ) assert numpy.allclose(compare_array, texel_data) h_w = p.size[0] / 2.0 h_h = p.size[1] / 2.0 l = -h_w r = h_w b = -h_h t = h_h # in the case of only color1, # the texel data multiplies color1 to produce a color # with color2, # the texel data linearly interpolates between color1 and color2 gl.glColor4f(p.color1[0], p.color1[1], p.color1[2], p.max_alpha) if p.mask: p.mask.draw_masked_quad( 0.0, 1.0, 0.0, 1.0, # l,r,b,t for texture coordinates l, r, b, t, # l,r,b,t in eye coordinates depth, ) # also in eye coordinates else: # draw unmasked quad gl.glBegin(gl.GL_QUADS) gl.glTexCoord2f(0.0, 0.0) gl.glVertex3f(l, b, depth) gl.glTexCoord2f(1.0, 0.0) gl.glVertex3f(r, b, depth) gl.glTexCoord2f(1.0, 1.0) gl.glVertex3f(r, t, depth) gl.glTexCoord2f(0.0, 1.0) gl.glVertex3f(l, t, depth) gl.glEnd() # GL_QUADS gl.glDisable(gl.GL_TEXTURE_1D) gl.glPopMatrix()
shrink_texture_ok=True, internal_format=gl.GL_RGBA, ) viewport = Viewport(screen=screen, stimuli=[stimulus]) frame_timer = FrameTimer() quit_now = False spinning = True while not quit_now and spinning: for event in pygame.event.get(): if event.type == QUIT: quit_now = True elif event.type in (KEYDOWN,MOUSEBUTTONDOWN): spinning = False screen.clear() stimulus.parameters.angle = (VisionEgg.time_func()*-180.0)%360.0 # rotate viewport.draw() swap_buffers() frame_timer.tick() while not quit_now: for event in pygame.event.get(): if event.type in (QUIT,KEYDOWN,MOUSEBUTTONDOWN): quit_now = True screen.clear() viewport.draw() swap_buffers() frame_timer.tick() frame_timer.log_histogram()
def go(mode, time=2): global x global escape_code quit_now = False response = None other_responses = [] rt = -1000 frame_timer = FrameTimer() if mode == "isi": time = stimulus.isi_time elif mode == "ippi": time = stimulus.ippi_time elif mode == "prime": time = stimulus.prime_time elif mode == "probe": time = stimulus.probe_time if(mode == "prime"): x = x + 1 print "collecting " + str(x) ac = Audio_collection(FORMAT, CHANNELS, RATE, SOUND_THRESHOLD, stimulus.itemNumber, True, \ chunk, outputdir + "audio"+ str(subjectID) +"/" + EXPERIMENT_CODE + str(subjectID)+stimulus.itemNumber+".wav", prime_time, chunk, q) ac.start() start_time = VisionEgg.time_func() while not quit_now: # Process keyboard inputs for event in pygame.event.get(): if event.type == pygame.locals.QUIT: quit_now = True elif event.type == pygame.locals.KEYDOWN: if event.key == pygame.locals.K_BACKQUOTE : quit_now = True escape_code = True f.close() screen.close() #screen2.close() sys.exit() elif event.key == response_key_1 : if response==None: rt = VisionEgg.time_func() - start_time response = "LeftResponse" if click_through_stimuli: quit_now = True else : other_responses.append(str(event.key) + " " + str(VisionEgg.time_func() - start_time)) elif event.key == response_key_2 : if response==None: rt = VisionEgg.time_func() - start_time response = "RightResponse" if click_through_stimuli: quit_now = True else : other_responses.append(str(event.key) + " " + str(VisionEgg.time_func() - start_time)) elif event.key == pygame.locals.K_BACKQUOTE: quit_now = True else : other_responses.append(str(event.key) + " " + str(VisionEgg.time_func() - start_time)) #text.parameters.text+=event.unicode screen.clear() viewport.draw() swap_buffers() frame_timer.tick() time_since_start = VisionEgg.time_func() if((time_since_start - start_time > time) ): quit_now = True if (mode == "prime") and not (ac.is_alive()): quit_now = True if(mode=="prime"): ac.join() #while threading.activeCount() > 2: # This is sheer magic. I'm not sure why there are two threads active at this point, so it could break at any moment. # print threading.activeCount() audio_start_time = q.get() audio_end_time = q.get() if not (audio_end_time == 10000000): f.write("%s\t%f\t%f\t%f\t%s\t%d\t%s\t%f\t%f\t%s\n" % (stimulus.itemNumber, audio_end_time-audio_start_time, audio_start_time, \ audio_end_time, \ stimulus.pretty_name(timings=False), \ subjectID, mode, start_time, time_since_start-start_time, \ " . ".join(other_responses))) else: f.write("%s\t%f\t%f\t%f\t%s\t%d\t%s\t%f\t%f\t%s\n" % (stimulus.itemNumber, audio_end_time, audio_start_time, \ audio_end_time, \ stimulus.pretty_name(timings=False), \ subjectID, mode, start_time, time_since_start-start_time, \ " . ".join(other_responses))) f.flush()
camera_matrix=drum_camera_matrix, stimuli=[drum]) ############################################################## # Main loop (not using VisionEgg.FlowControl.Presentation) # ############################################################## # save time frame_timer = VisionEgg.Core.FrameTimer() quit_now = 0 while not quit_now: for event in pygame.event.get(): if event.type in (QUIT, KEYDOWN, MOUSEBUTTONDOWN): quit_now = 1 t = VisionEgg.time_func() # update parameters (could also be done with VisionEgg.FlowControl.Controllers) color_grating.parameters.pedestal = pedestal_func(t) drum.parameters.angular_position = angle_as_function_of_time(t) drum_camera_matrix.parameters.matrix = cam_matrix_f(t) # do drawing, etc. (can be done with Presentation.go() method) screen.clear() # clear the back buffer drum_viewport.draw() # draw spinning drum viewport_2d.draw() # draw 2D stimuli pixels = numpy.random.randint(0, 256, size=(20, 20, 3)).astype(numpy.uint8) screen.put_pixels( pixels, scale_x=5.0,
def getState(t): global ISI, next_stim_time, direction, last_direction, arrow_scale, score global first_loop, start_time, StimCount, stimVis, fbVis, stimText global score_factor, arrowColor, leftText, rightText global left_strings, right_strings, stimulus_strings, show_array global currentTime, currentShow, currentSign, currentTR # CC added for TCPIP and detrends global tcp_dist, dist_detrend, dist_array, time_array, dist global startDetrend, detrendLag global ALPHA_MAX, ALPHA_SCALE global lumina_dev currentTime = t if (first_loop == 1) and (p.parameters.trigger_go_if_armed): first_loop = 0 start_time = VisionEgg.time_func() if TCPIP: tcp_listener.buffer = "" # reset buffer if t > next_stim_time: StimCount = StimCount + 1 currentShow = int(np.abs(show_array[StimCount])) currentSign = int(np.sign(show_array[StimCount])) stimText = stimulus_strings[StimCount] leftText = left_strings[StimCount] rightText = right_strings[StimCount] next_stim_time = next_stim_time + ISI if StimCount > detrendLag: startDetrend = True #### # note: When run with SVR testing, the input values #### # will range from (-inf,inf), most likely (-5,5) if TCPIP: tcp_buffer = str(tcp_listener.buffer) #print "%s (%s)" %('tcp_data', tcp_buffer) tcp_data = tcp_buffer.replace('\000', '') # remove null byte #print "%s (%s) (%s)" %('tcp_data', tcp_data, tcp_buffer) if tcp_data != '\000' and tcp_data != "" and \ "nan" not in tcp_data.lower(): vals = tcp_data.split(",") if len(vals) > 1: tcp_dist = float(vals[1]) else: tcp_dist = float(tcp_data) tcp_listener.buffer = "" # reset buffer dist_array = dist_array + [tcp_dist] time_array = time_array + [t] if DETREND == 1: if startDetrend: dist_detrend = detrendDist(time_array, dist_array) else: dist_detrend = tcp_dist arrow_scale = dist_detrend else: arrow_scale = tcp_dist if currentShow == 9999 or FEEDBACK == 0: fbVis = 0 score = 90.0 arrowColor = 0 else: fbVis = 1 arrowColor = 1 # increment the score score = score - currentSign * arrow_scale * score_factor if score < 0: score = 0 elif score > 180: score = 180 log.write("%5.3f; STIM; %s; %s; %s; %d; %d; %5.3f; %5.3f; %5.3f\n" \ %(t, leftText, rightText, stimText, currentShow, \ currentSign, tcp_dist, arrow_scale, score)) # handle anything that comes in on the button boxes #print "About to test LUMINA", #print lumina_dev if LUMINA == 1: lumina_dev.poll_for_response() while lumina_dev.response_queue_size() > 0: response = lumina_dev.get_next_response() if response["pressed"]: print "Lumina received: %s, %d" % (response["key"], response["key"]) if response["key"] == 4: log.write("%5.3f; TR; %s\n" % (currentTime, currentTR)) currentTR = currentTR + 1 else: log.write("%5.3f; LUMINA; %d\n" % (currentTime, response["key"])) #print "TESTED LUMINA" return 1
def run(self, ID = 0): self.ID = ID super(DetectTrial, self).run() sound_played = False while not self.stopped: self.run_time = VisionEgg.time_func() - self.start_time if self.phase == 0: self.prestimulation_time = VisionEgg.time_func() # this trial phase is ended with a space press on the first trial of a run, but timed on all other trials of a run. self.start_time = VisionEgg.time_func() elif self.phase == 1: # first delay self.delay_1_time = VisionEgg.time_func() # this trial phase is timed if ( self.delay_1_time - self.prestimulation_time ) > self.phase_durations[1] - 0.1 and sound_played == False: self.session.play_sound( sound_index = 1 ) sound_played = True if ( self.delay_1_time - self.prestimulation_time ) > self.phase_durations[1]: self.phase_forward() elif self.phase == 2: # stimulus presentation # this trial phase is timed self.test_time = VisionEgg.time_func() if ( self.test_time - self.delay_1_time ) > self.phase_durations[2]: self.phase_forward() elif self.phase == 3: # second delay # this trial phase is timed self.delay_2_time = VisionEgg.time_func() if ( self.delay_2_time - self.test_time ) > self.phase_durations[3]: self.phase_forward() elif self.phase == 4: # confidence self.confidence_time = VisionEgg.time_func() elif self.phase == 5: # third delay self.delay_3_time = VisionEgg.time_func() if ( self.delay_3_time - self.confidence_time ) > self.phase_durations[5]: self.feedback_given = False self.phase_forward() elif self.phase == 6: # feedback self.feedback_time = VisionEgg.time_func() if self.feedback_given == False and ( self.feedback_time - self.delay_3_time ) > 0.1: if self.version == 1: if self.parameters['correct'] == 1: self.session.play_sound( sound_index = 2 ) elif self.parameters['correct'] == 0: self.session.play_sound( sound_index = 0 ) if self.version == 2: if self.parameters['correct'] == 1: self.session.play_sound( sound_index = 0 ) elif self.parameters['correct'] == 0: self.session.play_sound( sound_index = 2 ) elif self.parameters['correct'] == -1: self.session.play_sound( sound_index = 3 ) self.feedback_given = True if ( self.feedback_time - self.delay_3_time ) > self.phase_durations[6]: self.phase_forward() elif self.phase == 7: # fourth delay self.delay_4_time = VisionEgg.time_func() if ( self.delay_4_time - self.feedback_time ) > self.phase_durations[7]: self.stopped = True # events and draw self.event() self.draw() # we have stopped. self.stop()
shrink_texture_ok=True, internal_format=gl.GL_RGBA, ) viewport = Viewport(screen=screen, stimuli=[stimulus]) frame_timer = FrameTimer() quit_now = False spinning = True while not quit_now and spinning: for event in pygame.event.get(): if event.type == QUIT: quit_now = True elif event.type in (KEYDOWN, MOUSEBUTTONDOWN): spinning = False screen.clear() stimulus.parameters.angle = (VisionEgg.time_func() * -180.0) % 360.0 # rotate viewport.draw() swap_buffers() frame_timer.tick() while not quit_now: for event in pygame.event.get(): if event.type in (QUIT, KEYDOWN, MOUSEBUTTONDOWN): quit_now = True screen.clear() viewport.draw() swap_buffers() frame_timer.tick() frame_timer.log_histogram()
def draw(self): # XXX This method is not speed-optimized. I just wrote it to # get the job done. (Nonetheless, it seems faster than the C # version commented out above.) p = self.parameters # shorthand if p.center is not None: if not hasattr(VisionEgg.config,"_GAVE_CENTER_DEPRECATION"): logger = logging.getLogger('VisionEgg.Dots') logger.warning("Specifying DotArea2D by deprecated " "'center' parameter deprecated. Use " "'position' parameter instead. (Allows " "use of 'anchor' parameter to set to " "other values.)") VisionEgg.config._GAVE_CENTER_DEPRECATION = 1 p.anchor = 'center' p.position = p.center[0], p.center[1] # copy values (don't copy ref to tuple) if p.on: # calculate center center = VisionEgg._get_center(p.position,p.anchor,p.size) if p.anti_aliasing: if len(p.color) == 4 and not self._gave_alpha_warning: if p.color[3] != 1.0: logger = logging.getLogger('VisionEgg.Dots') logger.warning("The parameter anti_aliasing is " "set to true in the DotArea2D " "stimulus class, but the color " "parameter specifies an alpha " "value other than 1.0. To " "acheive the best anti-aliasing, " "ensure that the alpha value for " "the color parameter is 1.0.") self._gave_alpha_warning = 1 gl.glEnable( gl.GL_POINT_SMOOTH ) # allow max_alpha value to control blending gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) else: gl.glDisable( gl.GL_BLEND ) now_sec = VisionEgg.time_func() if self.start_times_sec is not None: # compute extinct dots and generate new positions replace_indices = Numeric.nonzero( Numeric.greater( now_sec - self.start_times_sec, p.dot_lifespan_sec) ) Numeric.put( self.start_times_sec, replace_indices, now_sec ) new_x_positions = RandomArray.uniform(0.0,1.0, (len(replace_indices),)) Numeric.put( self.x_positions, replace_indices, new_x_positions ) new_y_positions = RandomArray.uniform(0.0,1.0, (len(replace_indices),)) Numeric.put( self.y_positions, replace_indices, new_y_positions ) new_random_directions_radians = RandomArray.uniform(0.0,2*math.pi, (len(replace_indices),)) Numeric.put( self.random_directions_radians, replace_indices, new_random_directions_radians ) else: # initialize dot extinction values to random (uniform) distribution self.start_times_sec = RandomArray.uniform( now_sec - p.dot_lifespan_sec, now_sec, (self.constant_parameters.num_dots,)) signal_num_dots = int(round(p.signal_fraction * self.constant_parameters.num_dots)) time_delta_sec = now_sec - self.last_time_sec self.last_time_sec = now_sec # reset for next loop x_increment_normalized = math.cos(p.signal_direction_deg/180.0*math.pi) * p.velocity_pixels_per_sec / p.size[0] * time_delta_sec y_increment_normalized = -math.sin(p.signal_direction_deg/180.0*math.pi) * p.velocity_pixels_per_sec / p.size[1] * time_delta_sec self.x_positions[:signal_num_dots] += x_increment_normalized self.y_positions[:signal_num_dots] += y_increment_normalized num_random_dots = self.constant_parameters.num_dots - signal_num_dots random_x_increment_normalized = Numeric.cos(self.random_directions_radians[signal_num_dots:]) * p.velocity_pixels_per_sec / p.size[0] * time_delta_sec random_y_increment_normalized = -Numeric.sin(self.random_directions_radians[signal_num_dots:]) * p.velocity_pixels_per_sec / p.size[1] * time_delta_sec self.x_positions[signal_num_dots:] += random_x_increment_normalized self.y_positions[signal_num_dots:] += random_y_increment_normalized self.x_positions = Numeric.fmod( self.x_positions, 1.0 ) # wrap self.y_positions = Numeric.fmod( self.y_positions, 1.0 ) self.x_positions = Numeric.fmod( self.x_positions+1, 1.0 ) # wrap again for values < 1 self.y_positions = Numeric.fmod( self.y_positions+1, 1.0 ) xs = (self.x_positions - 0.5) * p.size[0] + center[0] ys = (self.y_positions - 0.5) * p.size[1] + center[1] if len(p.color)==3: gl.glColor3f(*p.color) elif len(p.color)==4: gl.glColor4f(*p.color) gl.glPointSize(p.dot_size) # Clear the modeview matrix gl.glMatrixMode(gl.GL_MODELVIEW) gl.glPushMatrix() gl.glDisable(gl.GL_TEXTURE_2D) if p.depth is None: depth = 0.0 else: gl.glEnable(gl.GL_DEPTH_TEST) depth = p.depth zs = (depth,)*len(xs) # make N tuple with repeat value of depth draw_dots(xs,ys,zs) if p.anti_aliasing: gl.glDisable( gl.GL_POINT_SMOOTH ) # turn off gl.glPopMatrix()
def draw(self): p = self.parameters # shorthand if p.on: if p.mask: gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB) if p.depth_test: gl.glEnable(gl.GL_DEPTH_TEST) else: gl.glDisable(gl.GL_DEPTH_TEST) if p.polygon_offset_enabled: gl.glEnable(gl.GL_POLYGON_OFFSET_EXT) gl.glPolygonOffset(p.polygon_offset_factor, p.polygon_offset_units) gl.glBindTexture(gl.GL_TEXTURE_1D,self._texture_object_id) gl.glEnable(gl.GL_TEXTURE_1D) gl.glDisable(gl.GL_TEXTURE_2D) if p.bit_depth != self.cached_bit_depth: self.calculate_bit_depth_dependencies() # allow max_alpha value to control blending gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) if p.color2: gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_BLEND) gl.glTexEnvfv(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_COLOR, p.color2) ## alpha is ignored because the texture base internal format is luminance else: gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE) if p.t0_time_sec_absolute is None and not p.ignore_time: p.t0_time_sec_absolute = VisionEgg.time_func() w = p.size[0] inc = w/float(p.num_samples) if p.ignore_time: phase = p.phase_at_t0 else: t_var = VisionEgg.time_func() - p.t0_time_sec_absolute phase = t_var*p.temporal_freq_hz*-360.0 + p.phase_at_t0 if p.recalculate_phase_tolerance is None or abs(self._last_phase - phase) > p.recalculate_phase_tolerance: self._last_phase = phase # we're re-drawing the phase at this angle floating_point_sin = numpy.sin(2.0*math.pi*p.spatial_freq*numpy.arange(0.0,w,inc,dtype=numpy.float)+(phase/180.0*math.pi))*0.5*p.contrast+p.pedestal floating_point_sin = numpy.clip(floating_point_sin,0.0,1.0) # allow square wave generation if contrast > 1 texel_data = (floating_point_sin*self.max_int_val).astype(self.numpy_dtype).tostring() gl.glTexSubImage1D(gl.GL_TEXTURE_1D, # target 0, # level 0, # x offset p.num_samples, # width self.format, # format of new texel data self.gl_type, # type of new texel data texel_data) # new texel data # in the case of only color1, # the texel data multiplies color1 to produce a color # with color2, # the texel data linearly interpolates between color1 and color2 gl.glColor4f(p.color1[0],p.color1[1],p.color1[2],p.max_alpha) if p.mask: p.mask.draw_masked_quad_3d(0.0,1.0,0.0,1.0, # for texture coordinates p.lowerleft,p.lowerright,p.upperright,p.upperleft) else: # draw unmasked quad gl.glBegin(gl.GL_QUADS) gl.glTexCoord2f(0.0,0.0) gl.glVertex(*p.lowerleft) gl.glTexCoord2f(1.0,0.0) gl.glVertex(*p.lowerright) gl.glTexCoord2f(1.0,1.0) gl.glVertex(*p.upperright) gl.glTexCoord2f(0.0,1.0) gl.glVertex(*p.upperleft) gl.glEnd() # GL_QUADS gl.glDisable(gl.GL_TEXTURE_1D) if p.polygon_offset_enabled: gl.glDisable(gl.GL_POLYGON_OFFSET_EXT)
def event(self): for event in pygame.event.get(): if event.type == KEYDOWN: if event.key == pygame.locals.K_ESCAPE: self.events.append([-99,VisionEgg.time_func()-self.start_time]) self.parameters.update({'correct': 0}) self.stopped = True self.session.stopped = True # it handles both numeric and lettering modes elif event.key == pygame.locals.K_SPACE: self.events.append([0,VisionEgg.time_func()-self.start_time]) if self.ID == 0 and self.phase == 0: self.phase_forward() elif event.key == pygame.locals.K_LEFT: self.events.append([1,VisionEgg.time_func()-self.start_time]) self.parameters.update({'answer':1}) if self.parameters['which_signal_test'] == 0: self.parameters.update({'correct': 1}) else: self.parameters.update({'correct': 0}) if self.phase == 6: # if self.session.index_number == 0: # feedback when we're practicing # self.feedback(self.parameters['answer'], self.parameters['which_signal_test']) if self.version == 1: if self.parameters['correct'] == 0: self.session.play_sound( sound_index = 0 ) else: self.session.play_sound( sound_index = 2 ) if self.version == 2: if self.parameters['correct'] == 0: self.session.play_sound( sound_index = 2 ) else: self.session.play_sound( sound_index = 0 ) self.stopped = True # else: # self.phase_forward() elif event.key == pygame.locals.K_RIGHT: self.events.append([-1,VisionEgg.time_func()-self.start_time]) self.parameters.update({'answer':-1}) if self.parameters['which_signal_test'] == 1: self.parameters.update({'correct': 1}) else: self.parameters.update({'correct': 0}) if self.phase == 6: # if self.session.index_number == 0: # feedback when we're practicing # self.feedback(self.parameters['answer'], self.parameters['which_signal_test']) if self.version == 1: if self.parameters['correct'] == 0: self.session.play_sound( sound_index = 0 ) else: self.session.play_sound( sound_index = 2 ) if self.version == 2: if self.parameters['correct'] == 0: self.session.play_sound( sound_index = 2 ) else: self.session.play_sound( sound_index = 0 ) self.stopped = True # else: # self.phase_forward() # elif event.key == pygame.locals.K_a: # if self.phase == 7: # self.parameters.update({'confidence':0}) # self.stopped = True # elif event.key == pygame.locals.K_s: # if self.phase == 7: # self.parameters.update({'confidence':1}) # self.stopped = True # elif event.key == pygame.locals.K_d: # if self.phase == 7: # self.parameters.update({'confidence':2}) # self.stopped = True # elif event.key == pygame.locals.K_f: # if self.phase == 7: # self.parameters.update({'confidence':3}) # self.stopped = True # elif event.key == pygame.locals.K_g: # if self.phase == 7: # self.parameters.update({'confidence':4}) # self.stopped = True super(DetectTrial, self).key_event( event )