def calibrateHand(): if exp.optotrak: optoLink = viz.link(hand, m_hand) text_line1 = create_text2d( 'Please put finger on physical start position\n press -space- to start calibration' ) yield viztask.waitKeyDown(' ') text_line1.message("Calibration in progress") #collect samples samples = [] old_sample = m_hand.getPosition() samples.append(old_sample) while len(samples) < 100: new_sample = m_hand.getPosition() if not (new_sample == old_sample): samples.append(new_sample) old_sample = new_sample yield viz.waitTime(0.001) check_position = np.mean(samples, axis=0) position_offset = np.array(exp.start_pos) - np.array(check_position) print position_offset hand0 = optofilter.position(hand, offset=(position_offset[0], position_offset[1] + 0.006, position_offset[2])) if exp.optotrak: optoLink = viz.link(hand0, m_hand) text_line1.message("Calibration done") yield viz.waitTime(0.75) text_line1.visible(viz.OFF)
def run(self): while True: with self.lock: if self.shouldIRun: #for d in self.data: # print d #viz.waitTime(1) print "Hallo" else: print "Stopped" return viz.waitTime(1)
def run(self): """Loops through the trial sequence""" viz.MainScene.visible(viz.ON, viz.WORLD) #start with all turned off for scene in self.scenes: scene.turn_off() ### why is the ground plane not changing????!!!! ### for lab, trial in self.CONDITIONLIST.iterrows(): if trial['Day/Night'] > 0: trial_scene = self.scenes[0] #print(trial_scene) self.Straight.setAlpha(0.25) else: trial_scene = self.scenes[1] #print(trial_scene) self.Straight.setAlpha(0.025) #switch the particular scene on print(trial_scene.name) trial_scene.turn_on() yield viz.waitTime(1) #switch that particular scene off trial_scene.turn_off()
def perturbation(): global speed_S, speed_P, accel_max, belt, ptb, stp_counter, stp if (belt == 'L'): # increase left speed # labjack_impulse() out = serializepacket(speed_P[0], speed_S[1], accel_max, accel_max, 0) s.sendall(out) belt = '0' # next call: decelerate stp_counter = 0 stp = random.randint(step_range[0], step_range[1]) print "PTB", ptb, "- LEFT" #send impulse labjack_impulse() viz.waitTime( 0.6 ) #use this waitime function with viz.director to create another thread out = serializepacket(speed_S[0], speed_S[1], accel_max, accel_max, 0) s.sendall(out) labjack_impulse() elif (belt == 'R'): # increase right speed out = serializepacket(speed_S[0], speed_P[1], accel_max, accel_max, 0) s.sendall(out) belt = '0' # next call: decelerate stp_counter = 0 stp = random.randint(step_range[0], step_range[1]) print "PTB", ptb, "- RIGHT" #send impulse labjack_impulse() viz.waitTime( 0.6 ) #use this waitime function with viz.director to create another thread out = serializepacket(speed_S[0], speed_S[1], accel_max, accel_max, 0) s.sendall(out) labjack_impulse() else: # decrease speed out = serializepacket(speed_S[0], speed_S[1], accel_max, accel_max, 0) s.sendall(out) ptb += 1 # one more perturbation completed print ptb
def saveUpdateLoop(avatar, file): global isRecording, waittask while True: if isRecording: saveAvatar(avatar, file) waittask = viz.waitTime(RECORDING_FREQUENCY) #how often we should save data
def cross_trial(start_time, wait_time, rt_deadline, remove, message="",training=False): """ Implements a single trial Parameters ========== start_time:float IF start_time == 0, wait for the next trigger pulse. Else, wait until start_time to begin the trial. wait_time:float time to wait until the cross should remove one of its lines rt_deadline:float if the subject did not respond more quickly than the deadline, tell them they blew it remove:str The portion of the cross to remove. Either "hbar" or "vbar". """ descr = {"onset":start_time, "duration":wait_time, "crossbar":remove} new_texture = hbar if remove == "vbar" else vbar if start_time == 0: yield vizact.waitsignal(TRIGGER_EVENT) else: while viz.tick() < start_time: yield viz.waitTime(0.01) # ---- If there's a message, display it for MESSAGE_TIME #block_text.message(message) #vizact.ontimer2(rate=MESSAGE_TIME, repeats=0,func=clear_text) # ---- Flash the cue quad.texture(cue) yield viztask.waitTime(0.5) quad.texture(cross) # ---- Wait the required time yield viztask.waitTime(wait_time) # ---- Set the new texture quad.texture(new_texture) #Wait for next frame to be drawn to screen d = yield viztask.waitDraw() #Save display time displayTime = d.time #Wait for a reaction reaction = yield viztask.waitAny( [HBAR_RESPONSE, VBAR_RESPONSE] ) time_at_response, = reaction.data.data[0] # How did they do?? # -> Hbar remains if reaction.condition is HBAR_RESPONSE: descr["acc_success"] = remove == "vbar" response = "hbar" # -> vbar remains if reaction.condition is VBAR_RESPONSE: descr["acc_success"] = remove == "hbar" response = "vbar" # print "removed:", remove,"responded:",response # Calculate reaction time reactionTime = time_at_response - displayTime descr["speed_success"] = reactionTime < rt_deadline success = descr["speed_success"] and descr["acc_success"] # What sort of feedback to give? #if training: # In training blocks, show the rt #yield training_display(reactionTime,descr["acc_success"]) #else: if success: yield success_display(reactionTime) else: failtype = "WRONG" if descr["speed_success"] else "TIMEOUT" yield fail_display(failtype, reactionTime) quad.texture(cross) descr["response"] = response descr["success"] = success descr["rt"] = reactionTime descr["rt_deadline"]= rt_deadline descr["changetime"] = d.time viztask.returnValue(descr)
def die(self): if(True is self.flag): viz.waitTime(2) print "People of ZION: WE ARE DYIIIIIIIIIIING. :( " viz.waitTime(2) print "People of ZION: WE ALL FALL DOWN. :( :("
def tester2(self,name): print "*****Looking around*****" viz.waitTime(3) if None is self.first: self.first = "smith" print "\nAgent SMITH: I WILL KILL YOU ALLLLLL!!!\n" viz.waitTime(2) if(False == self.yo): self.flag = True viz.waitTime(2) viz.quit() else: viz.waitTime(2) print "Agent SMITH: Wait waaa!!" viz.waitTime(2) print "*****NEO beats up Agent SMITH and destroys him*****" viz.waitTime(2) print "Agent SMITH: Damn you NEOOOOO!!\nAgent SMITH: NOW Fall Agent SMITH"
def runanimation(): global posx, posy, posz, tail, alpha, yaw, pitch, roll global GAIN, SPHERESIZE print len(accx) [lpx, lpy, lpz] = [[],[],[]] # Assume the first time is equal to 1/Fs dt = t dt2 = dt*dt starttime = time.time() for i in range(0,len(accx)): curtime = float(ts[i]) timenow = time.time() if i > 0: dt = curtime-float(ts[i-1]) [ax, ay, az] = [(accx[i]), (accy[i]), (accz[i])] # Check for gaps in data, do not move if the threshold is reached if dt < 0.5: # Calculate the new positions. y-axis is the elevation! posx += g*ax*dt*dt posz += g*ay*dt*dt posy += g*az*dt*dt lpx.append(posx) lpy.append(posy) lpz.append(posz) while len(lpx)>Z_LOWPASS: lpx.pop(0); lpy.pop(0); lpz.pop(0) partic = sphere.copy() partic.setScale(SPHERESIZE,SPHERESIZE,SPHERESIZE) partic.setPosition(avg(lpx),avg(lpy)+1,avg(lpz)) # Direction cone ''' X = viz.Transform() X.makeIdent() X.preTrans(posx,posy+1,posz) X.setEuler([yaw[i], pitch[i], roll[i]]) X.preTrans(0,0.4,0) cone.setMatrix(X) ''' # Moving average for camera position cpx.append(posx); cpy.append(posy); cpz.append(posz) while len(cpx) > 15: cpx.pop(0); cpy.pop(0); cpz.pop(0) cx = 0; cy = 0; cz = 0 for j in range(0,len(cpx)): cx += cpx[j]; cy += cpy[j]; cz += cpz[j] cx/=len(cpx); cy/=len(cpy); cz/=len(cpz) # Calculate resulting camera position and theatrical movement camx = cx + dist * math.sin(curtime*animspeed) camz = cz + dist * math.cos(curtime*animspeed) camy = cy + 2 + 0.5* math.sin(curtime*animspeed*2) # Fixate view at the moving average viz.MainView.lookAt([cx,cy+1,cz]) vizcam.PivotNavigate([camx,camy,camz],dist,[1.0,1.0],viz.MainView) # Change color according to the magnitude #amplitude = math.sqrt(ax*ax+ay*ay+az*az) red = acc_M[i]/MAX_AMP green = 1-acc_M[i]/MAX_AMP partic.color(red,green,0) tail.append(partic.id) alpha.append(1) decaytail(dt) yield viz.waitTime(dt) while len(tail) >5: decaytail(dt) yield viz.waitTime(dt) print 'All done in: %f seconds.'%(time.time()-starttime)
def experiment(): text_line1 = create_text2d('Please Wait') # text_line2 = create_text2d('',[0,1.8,4]) text_line1.visible(viz.OFF) #GET PP INFO yield participantInfo() yield viz.waitTime(0.5) # recalibrate hand to physical start position yield calibrateHand() #INITIALIZE LOG FILES # file name incl pp nr and id + number based on time so to avoid accidental overwriting rd_vers = str(int(time.time())) # initialize and head data log file exp.data_log_file = '{0}/data_log_{1}{2}_{3}.csv'.format( exp.data_path, exp.pp_nr, exp.pp_id, rd_vers) pr.data_log_file = exp.data_log_file with open(exp.data_log_file, 'w') as f: f.write(exp.log_heading) # initialize data hand log file exp.data_hand_file = '{0}/data_hand_{1}{2}_{3}.csv'.format( exp.data_path, exp.pp_nr, exp.pp_id, rd_vers) pr.data_hand_file = exp.data_hand_file with open(exp.data_hand_file, 'w') as f: f.write('hand data file {0} {1} {2}\n'.format(exp.pp_nr, exp.pp_id, rd_vers)) # write exp settings. Seperator = ':' exp_settings_write = '' for attr, value in exp.__dict__.iteritems(): if not attr.startswith('__'): exp_settings_write += str(attr) + ':' + str(value) + '\n' with open( '{0}/exp_settings_{1}{2}_{3}.csv'.format(exp.data_path, exp.pp_nr, exp.pp_id, rd_vers), 'w') as f: f.write(exp_settings_write) del exp_settings_write # PRACTICE BLOCKs for bl in range(pr.nr_blocks): text_line1.message("To start training block " + str(bl + 1) + "\npress -0-") text_line1.visible(viz.ON) yield viztask.waitKeyDown(viz.KEY_KP_0) text_line1.message("3") yield viztask.waitTime(1) text_line1.message("2") yield viztask.waitTime(1) text_line1.message("1") yield viztask.waitTime(1) text_line1.visible(viz.OFF) for tr in range(pr.nr_trials / pr.nr_blocks): tr += bl * pr.nr_trials / pr.nr_blocks yield trial(bl, tr, pr, log_pr) text_line1.message("Training block " + str(bl + 1) + ' of ' + str(pr.nr_blocks) + ' finished\nCall the experimenter...') text_line1.visible(viz.ON) yield viztask.waitKeyDown('a') # EXPERIMENTAL BLOCKs exp.reach_end_cutoff_list = pr.reach_end_cutoff_list exp.reach_end_cutoff_t = pr.reach_end_cutoff_t for bl in range(exp.nr_blocks): text_line1.message("To start experiment block " + str(bl + 1) + "\npress -0-") text_line1.visible(viz.ON) yield viztask.waitTime(0.25) yield viztask.waitKeyDown(viz.KEY_KP_0) text_line1.message("3") yield viztask.waitTime(1) text_line1.message("2") yield viztask.waitTime(1) text_line1.message("1") yield viztask.waitTime(1) text_line1.visible(viz.OFF) for tr in range(exp.nr_trials / exp.nr_blocks): tr += bl * exp.nr_trials / exp.nr_blocks yield trial(bl, tr, exp, log) if bl == ((exp.nr_blocks / 2) - 1): text_line1.message("Experiment block " + str(bl + 1) + ' of ' + str(exp.nr_blocks) + ' finished\nPlease call the experimenter...') text_line1.visible(viz.ON) yield viztask.waitKeyDown('a') elif bl == (exp.nr_blocks - 1): text_line1.message( 'The end\nThank you!\nPlease call the experimenter...') text_line1.visible(viz.ON) yield viztask.waitKeyDown('a') else: text_line1.message( "Experiment block " + str(bl + 1) + ' of ' + str(exp.nr_blocks) + ' finished\nYou can take a break now\npress -0- to continue') text_line1.visible(viz.ON) yield viztask.waitKeyDown(viz.KEY_KP_0) viz.quit()
def trial(bl, tr, exp, log): print(str(tr + 1) + ' of ' + str(exp.nr_trials)) tr_vars = trial_vars_init(exp) ## prealocate space for hand_samples recording during task; not for hand_samples_check i.e. during check if at start position hand_samples_check = [] hand_times_check = [] hand_samples = [np.NaN] * 200 hand_times = [np.NaN] * 200 hand_samples_count = 0 tr_vars.t_trial_start = viz.tick() feedback = create_text2d(' ') feedback.visible(viz.OFF) tr_vars.interval_beforesearch = (random.randint(8, 10) / 10.0) ## retrieve shape settings ########################## #colors tr_vars.tar_col_name = exp.target_colors[log.tar_col[tr]] tr_vars.dis_condition = exp.distractor_colors[log.dis_col[tr]] if tr_vars.tar_col_name == 'red': tr_vars.tar_col = exp.red if exp.distractor_colors[log.dis_col[tr]] == 'same': tr_vars.dis_col = exp.red else: tr_vars.dis_col = exp.blue elif tr_vars.tar_col_name == 'blue': tr_vars.tar_col = exp.blue if exp.distractor_colors[log.dis_col[tr]] == 'same': tr_vars.dis_col = exp.blue else: tr_vars.dis_col = exp.red #shapes tr_vars.tar_shape = exp.target_shapes[log.tar_shape[tr]] tr_vars.tar_pos = log.tar_pos[tr] tr_vars.dis_pos = (tr_vars.tar_pos + log.dis_pos[tr]) % 4 # dis_pos_cont as continuous counting from tar_pos tr_vars.dis_pos_cont = log.dis_pos[tr] # dis_pos_rel as relative to tar_pos: negative is left from, positive is right from tr_vars.dis_pos_rel = tr_vars.dis_pos - tr_vars.tar_pos if tr_vars.tar_shape == 'diamond': shape1 = makeDiamond(tr_vars.tar_pos, tr_vars.tar_col) tr_vars.shapes_irrel.remove(tr_vars.tar_pos) shape2 = makeSphere(tr_vars.dis_pos, tr_vars.dis_col) tr_vars.shapes_irrel.remove(tr_vars.dis_pos) if len(tr_vars.shapes_irrel) != 2: raise Exception( 'length of shapes_irrel should be 2. length shapes_irrel: {}'. format(len(tr_vars.shapes_irrel))) shape3 = makeSphere(tr_vars.shapes_irrel[0], tr_vars.tar_col) shape4 = makeSphere(tr_vars.shapes_irrel[1], tr_vars.tar_col) elif tr_vars.tar_shape == 'sphere': shape1 = makeSphere(tr_vars.tar_pos, tr_vars.tar_col) tr_vars.shapes_irrel.remove(tr_vars.tar_pos) shape2 = makeDiamond(tr_vars.dis_pos, tr_vars.dis_col) tr_vars.shapes_irrel.remove(tr_vars.dis_pos) if len(tr_vars.shapes_irrel) != 2: raise Exception( 'length of shapes_irrel should be 2. length shapes_irrel: {}'. format(len(tr_vars.shapes_irrel))) shape3 = makeDiamond(tr_vars.shapes_irrel[0], tr_vars.tar_col) shape4 = makeDiamond(tr_vars.shapes_irrel[1], tr_vars.tar_col) shape1.visible(viz.OFF) shape2.visible(viz.OFF) shape3.visible(viz.OFF) shape4.visible(viz.OFF) #implement sound shape1_sound = shape1.playsound('./sounds/0737.wav') shape1_sound.pause() shape2_sound = shape2.playsound('./sounds/0739.wav') shape2_sound.pause() shape3_sound = shape3.playsound('./sounds/0739.wav') shape3_sound.pause() shape4_sound = shape4.playsound('./sounds/0739.wav') shape4_sound.pause() hand_samples_check.append('check_start') hand_times_check.append(viz.tick()) old_sample = m_hand.getPosition() hand_samples_check.append(old_sample) hand_times_check.append(viz.tick()) tr_vars.t_on_start = 0 pls_break = 0 while True: new_sample = m_hand.getPosition() if not (new_sample == old_sample): hand_samples_check.append(new_sample) hand_times_check.append(viz.tick()) old_sample = new_sample tr_vars.finger_on_start = checkTouch(exp.start_pos, new_sample, exp.min_dist_start) # option to recalibrate in trial if viz.key.isDown('a'): yield calibrateHand() feedback.message("Press -0- to continue") feedback.visible(viz.ON) yield viztask.waitKeyDown(viz.KEY_KP_0) feedback.visible(viz.OFF) # wait for time after pp touch start before presenting shapes # make sure they stay on start until shapes are presented # if they move time after start counter resets if tr_vars.finger_on_start and tr_vars.t_on_start == 0: tr_vars.t_on_start = viz.tick() elif not tr_vars.finger_on_start and not tr_vars.t_on_start == 0: tr_vars.t_on_start = 0 elif tr_vars.finger_on_start and ( viz.tick() - tr_vars.t_on_start) > tr_vars.interval_beforesearch: pls_break = 1 if pls_break: break if ((viz.tick() - tr_vars.t_trial_start) > 2.5) and (tr_vars.long_start == 0): feedback.message("Move finger to start position") feedback.visible(viz.ON) tr_vars.long_start = 1 elif ( (viz.tick() - tr_vars.t_trial_start) > 4) and (tr_vars.long_start): feedback.visible(viz.OFF) yield viz.waitTime(0.001) feedback.visible(viz.OFF) shape1.visible(viz.ON) shape2.visible(viz.ON) shape3.visible(viz.ON) shape4.visible(viz.ON) # t in seconds tr_vars.t_search_on = viz.tick() hand_samples[hand_samples_count] = 'start_task' hand_times[hand_samples_count] = tr_vars.t_search_on hand_samples_count += 1 pls_break = 0 while True: new_sample = m_hand.getPosition() if not (new_sample == old_sample): hand_samples[hand_samples_count] = new_sample hand_times[hand_samples_count] = viz.tick() hand_samples_count += 1 old_sample = new_sample if checkTouch(exp.shape_positions[tr_vars.tar_pos], new_sample, exp.min_dist_shape): tr_vars.finger_on_target = 1 tr_vars.finger_on_shape = tr_vars.tar_pos shape1_sound.play() shape1.visible(viz.OFF) pls_break = 1 elif checkTouch(exp.shape_positions[tr_vars.dis_pos], new_sample, exp.min_dist_shape): tr_vars.finger_on_distractor = 1 tr_vars.finger_on_shape = tr_vars.dis_pos shape2_sound.play() shape2.visible(viz.OFF) pls_break = 1 else: for idx, position_irrel in enumerate(tr_vars.shapes_irrel): if checkTouch(exp.shape_positions[position_irrel], new_sample, exp.min_dist_shape): if idx == 0: shape3_sound.play() shape3.visible(viz.OFF) elif idx == 1: shape4_sound.play() shape4.visible(viz.OFF) tr_vars.finger_on_filler = 1 tr_vars.finger_on_shape = position_irrel pls_break = 1 if pls_break: break # break after display has been presented for 1 second if (viz.tick() - tr_vars.t_search_on) >= exp.max_search_time: break yield viz.waitTime(0.001) t_search_off = viz.tick() tr_vars.search_time = t_search_off - tr_vars.t_search_on if not tr_vars.finger_on_shape == -1: hand_samples[hand_samples_count] = 'on_shape' hand_times[hand_samples_count] = viz.tick() hand_samples_count += 1 while (viz.tick() - t_search_off) < 0.25: new_sample = m_hand.getPosition() if not (new_sample == old_sample): hand_samples[hand_samples_count] = new_sample hand_times[hand_samples_count] = viz.tick() hand_samples_count += 1 old_sample = new_sample yield viz.waitTime(0.001) shape1.remove() shape2.remove() shape3.remove() shape4.remove() shape1_sound.remove() shape2_sound.remove() shape3_sound.remove() shape4_sound.remove() hand_samples[hand_samples_count] = 'end_task' hand_times[hand_samples_count] = viz.tick() # add time threshold if tr_vars.finger_on_target and (tr_vars.search_time <= exp.reach_end_cutoff_t): feedback_correct_sound.play() feedback.message("Correct") elif tr_vars.finger_on_distractor or tr_vars.finger_on_filler: feedback_wrongshape_sound.play() feedback.message("Wrong shape") else: feedback_tooslow_sound.play() feedback.message("Too slow") feedback.visible(viz.ON) feedback_on = viz.tick() ## LOG SHIZZLE ## ################# #don't log: del tr_vars.dis_col del tr_vars.tar_col # split filler pos tr_vars.filler1_pos, tr_vars.filler2_pos = tr_vars.shapes_irrel del tr_vars.shapes_irrel ## TRIAL & BEHAV DATA LOG ## # trial_attr = 'pp_nr,pp_id,session,block,trial' trial_string = str(exp.pp_nr) + ',' + str( exp.pp_id) + ',' + exp.name + ',' + str(bl) + ',' + str(tr) # add all attr from tr_vars for attr, value in tr_vars.__dict__.iteritems(): if not attr.startswith('__'): # trial_attr += ',' + str(attr) trial_string += ',' + str(value) # add relevant attr from exp for attr in exp.tolog_exp_vars: # trial_attr += ',' + str(attr) trial_string += ',' + str(getattr(exp, attr)) trial_string += '\n' with open(exp.data_log_file, 'a') as f: f.write(trial_string) # print(trial_attr) ## HAND DATA LOG ## if not len(hand_samples) == len(hand_times): raise ValueError('nr of hand_samples not same as nr of hand times') with open(exp.data_hand_file, 'a') as f: f.write('{0} start_trial {1}\n'.format(tr_vars.t_trial_start, tr)) f.write('COORD start {0}\n'.format(' '.join(map(str, exp.start_pos)))) f.write('COORD target {0}\n'.format(' '.join( map(str, exp.shape_positions[tr_vars.tar_pos])))) f.write('COORD distractor {0}\n'.format(' '.join( map(str, exp.shape_positions[tr_vars.dis_pos])))) f.write('COORD filler1 {0}\n'.format(' '.join( map(str, exp.shape_positions[tr_vars.filler1_pos])))) f.write('COORD filler2 {0}\n'.format(' '.join( map(str, exp.shape_positions[tr_vars.filler2_pos])))) f.write('VAR pp_nr {0}\n'.format(exp.pp_nr)) f.write('VAR pp_id {0}\n'.format(exp.pp_id)) f.write('VAR block_nr {0}\n'.format(bl)) f.write('VAR tar_pos {0}\n'.format(tr_vars.tar_pos)) f.write('VAR dis_pos {0}\n'.format(tr_vars.dis_pos)) f.write('VAR dis_pos_rel {0}\n'.format(tr_vars.dis_pos_rel)) f.write('VAR dis_pos_cont {0}\n'.format(tr_vars.dis_pos_cont)) f.write('VAR tar_col {0}\n'.format(tr_vars.tar_col_name)) f.write('VAR dis_condition {0}\n'.format(tr_vars.dis_condition)) f.write('VAR tar_shape {0}\n'.format(tr_vars.tar_shape)) f.write('VAR exp_type {0}\n'.format(exp.name)) for xd, sample in enumerate(hand_samples_check): if isinstance(sample, str): f.write('MSG {0} {1}\n'.format(hand_times_check[xd], sample)) else: f.write('{0} {1}\n'.format(hand_times_check[xd], ' '.join(map(str, sample)))) for xd, sample in enumerate(hand_samples): if isinstance(sample, float) and isnan(sample): # print('break on hand_sample nr {}'.format(xd)) break elif isinstance(sample, str): f.write('MSG {0} {1}\n'.format(hand_times[xd], sample)) else: f.write('{0} {1}\n'.format(hand_times[xd], ' '.join(map(str, sample)))) # update variable time cutoff exp.reach_end_cutoff_list = exp.reach_end_cutoff_list[1:] + [ tr_vars.search_time ] exp.reach_end_cutoff_t = np.percentile(exp.reach_end_cutoff_list, 80) yield viztask.waitTime(1 - (viz.tick() - feedback_on)) feedback.remove() feedback_correct_sound.stop() feedback_wrongshape_sound.stop() feedback_tooslow_sound.stop()
def runanimation(): global posx, posy, posz, tail, alpha, yaw, pitch, roll global GAIN, SPHERESIZE print len(accx) [lpx, lpy, lpz] = [[], [], []] # Assume the first time is equal to 1/Fs dt = t dt2 = dt * dt starttime = time.time() for i in range(0, len(accx)): curtime = float(ts[i]) timenow = time.time() if i > 0: dt = curtime - float(ts[i - 1]) [ax, ay, az] = [(accx[i]), (accy[i]), (accz[i])] # Check for gaps in data, do not move if the threshold is reached if dt < 0.5: # Calculate the new positions. y-axis is the elevation! posx += g * ax * dt * dt posz += g * ay * dt * dt posy += g * az * dt * dt lpx.append(posx) lpy.append(posy) lpz.append(posz) while len(lpx) > Z_LOWPASS: lpx.pop(0) lpy.pop(0) lpz.pop(0) partic = sphere.copy() partic.setScale(SPHERESIZE, SPHERESIZE, SPHERESIZE) partic.setPosition(avg(lpx), avg(lpy) + 1, avg(lpz)) # Direction cone ''' X = viz.Transform() X.makeIdent() X.preTrans(posx,posy+1,posz) X.setEuler([yaw[i], pitch[i], roll[i]]) X.preTrans(0,0.4,0) cone.setMatrix(X) ''' # Moving average for camera position cpx.append(posx) cpy.append(posy) cpz.append(posz) while len(cpx) > 15: cpx.pop(0) cpy.pop(0) cpz.pop(0) cx = 0 cy = 0 cz = 0 for j in range(0, len(cpx)): cx += cpx[j] cy += cpy[j] cz += cpz[j] cx /= len(cpx) cy /= len(cpy) cz /= len(cpz) # Calculate resulting camera position and theatrical movement camx = cx + dist * math.sin(curtime * animspeed) camz = cz + dist * math.cos(curtime * animspeed) camy = cy + 2 + 0.5 * math.sin(curtime * animspeed * 2) # Fixate view at the moving average viz.MainView.lookAt([cx, cy + 1, cz]) vizcam.PivotNavigate([camx, camy, camz], dist, [1.0, 1.0], viz.MainView) # Change color according to the magnitude #amplitude = math.sqrt(ax*ax+ay*ay+az*az) red = acc_M[i] / MAX_AMP green = 1 - acc_M[i] / MAX_AMP partic.color(red, green, 0) tail.append(partic.id) alpha.append(1) decaytail(dt) yield viz.waitTime(dt) while len(tail) > 5: decaytail(dt) yield viz.waitTime(dt) print 'All done in: %f seconds.' % (time.time() - starttime)
def manageThread(self,thread): lsAll =[["a","b","c"],[1,2,3],[4,5,6],[]] for ls in lsAll: thread.changeData(ls) viz.waitTime(5) thread.stop()
def stopThread(self,thread): viz.waitTime(10) thread.stop() return