Python viz.tick函数代码示例

	def checkStats():
		stats = viz.getRenderStats()
		if stats.frameTime > 0.012:
			print viz.tick()
			print stats

#	vizact.onupdate(viz.PRIORITY_DEFAULT, checkStats)

def timer3():
	viz.playSound('boing!.wav')
	global reaction_timer_initial
	a=viz.tick()
	print('in timer!')
	global timer2
	reaction_timer_initial=viz.tick()

    def run(self):
        exp = self.block.experiment

        lf = exp.left_finger
        rf = exp.right_finger

        # wait for the subject to touch the target sphere.
        yield self.block.experiment.wait_for_target()

        # target touched, now figure out which hand is doing the tracing.
        left_is_closer = distance(lf, exp.target) < distance(rf, exp.target)
        finger = lf if left_is_closer else rf
        self.trace_color = (1, 0, 0) if left_is_closer else (0, 1, 0)
        self.trace_name = 'left' if left_is_closer else 'right'

        # animate the target along the path, recording mocap data as we go.
        start = viz.tick()
        for i, v in enumerate(self.vertices):
            # ramp up the speed linearly from 0.
            s = min(1, 0.1 * (i+1)) * self.speed
            yield viztask.addAction(exp.target, vizact.moveTo(v, speed=s))

            # keep track of the position of the tracing finger.
            finger_position = finger.getPosition()
            self.trace.append(finger_position)

            # record values from the simulation and from the mocap.
            fields = [i, viz.tick() - start]
            fields.extend(exp.target.getPosition())
            fields.extend(finger_position)
            fields.extend(exp.head.get_pose().pos)
            for _, marker in sorted(exp.mocap.get_markers().iteritems()):
                fields.extend(marker.pos)
                fields.append(marker.cond)
            self.records.append(fields)

    def update(self):
        '''Update our knowledge of the current data from phasespace.'''
        if self._lock.acquire(False):
            return

        now = viz.tick()
        #if now - math.floor(now) < 0.1 / self.frame_rate:
        #    logging.info('%dus elapsed since last phasespace update',
        #                 1000000 * (now - self._updated))
        self._updated = now

        rigids = OWL.owlGetRigids()
        markers = OWL.owlGetMarkers()
        err = OWL.owlGetError()
        if err != OWL.OWL_NO_ERROR:
            hex = '0x%x' % err
            logging.debug(
                'OWL error %s (%s) getting marker data',
                ERROR_MAP.get(err, hex), hex)
            return
        getting_at = viz.tick() - now

        sx, sy, sz = self.scale
        ox, oy, oz = self.offset
        def transform(x, y, z):
            return sz * z + oz, sy * y + oy, sx * x + ox
        def swizzle(w, a, b, c):
            return c, b, a, -w

        for marker in markers:
            t, o = marker.id >> 12, marker.id & 0xfff
            x, y, z = marker.x, marker.y, marker.z
            self.trackers[t].update_markers(o,
                Marker(pos=transform(x, y, z), cond=marker.cond),
                Marker(pos=(x, y, z), cond=marker.cond))
        marker_at = viz.tick() - now

        for rigid in rigids:
            self.trackers[rigid.id].update_pose(Pose(
                pos=transform(*rigid.pose[0:3]),
                quat=swizzle(*rigid.pose[3:7]),
                cond=rigid.cond))
        rigid_at = viz.tick() - now

        #logging.info('phasespace update: %dus -> %dus -> %dus',
        #             1000000 * getting_at,
        #             1000000 * marker_at,
        #             1000000 * rigid_at)

        self._lock.release()

def testPhase():
	results = []
	
	if centerSensor not in manager.getActiveSensors():
		yield vizproximity.waitEnter(centerSensor)
	sensor = sphereSensors[0]
	info.setText("Walk to the sphere now.")
	startTime = viz.tick()
	yield vizproximity.waitEnter(sensor)
	info.setText('Please return to the center of the room')
	elapsedTime = viz.tick() - startTime
	results.append((sensor.name, elapsedTime))
	info.setText("You're all done now!")
	viztask.returnValue(results)

 def record_data(self):
     self.records.append((
         viz.tick() - self.start_tick,
         self.previous_target,
         self.current_target,
         self.suit.get_markers(),
     ))

def EnterProximity_end_sensor(end_sensor):
	start_node.translate(x_translate1,y_height1,z_depth1)
	right_node1.setPosition(0,100,0)
	right_node2.setPosition(0,100,0)
	right_node3.setPosition(0,100,0)
	sensor_data.write('\nEntered End sensor at:' + str(viz.tick()))
	print('Entered end_sensor')

def getData():
	elapsed_time = viz.tick() - start_time
	position = viz.MainView.getPosition()
	#Make a string out of the data. 
	data = "Time: " + str(elapsed_time) + '\t' + "Position: " + str(position) + '\n' 
	#Write it to the tracking file.
	game_data.write(data)

	def GameFinish (self, delay):
		self.info = vizinfo.add(self.tooltips['congrats'])
		self.info.visible(0)
		self.info.icon(viz.add('textures/c-olive_icon.png'))
		self.info.add(viz.TEXT3D, self.tooltips['finish']+'\n'+self.tooltips['produce'] % self._oil.getMessage())
		self.info.add(viz.TEXT3D, self.tooltips['stats'])
		self.info.translate(0.1,0.95)
		self.info.alignment(vizinfo.UPPER_LEFT)
		self.info.scale(2.4,2.6)
		self.info.messagecolor(100,100,0)
		self.info.bgcolor(viz.BLACK, 0.8)
		self.info.bordercolor([100,100,0], .9)
		points = self.info.add(viz.TEXQUAD, self.tooltips['score']+': %s' % self._total.getMessage())
		points.texture(viz.add('textures/total_icon.png'))
		time = self.info.add(viz.TEXQUAD, self.tooltips['time']+': %s' % self.ConvertTime(viz.tick()))
		time.texture(viz.add('textures/time_icon.png'))
		self.info.shrink()
		#hide all other panels
		self._scorePanel.visible(0)
		self._infoPanel.visible(0)
		self._alertPanel.visible(0)
		for p in self.PLAYERS.values():
			p._infoPanel.visible(0)
			p._alertPanel.visible(0)
			p._hud.visible(0)
		time.addAction(vizact.waittime(delay))
		time.addAction(vizact.call(self.info.visible, 1))
		time.addAction(vizact.waittime(.1))
		time.addAction(vizact.call(self.PlayVictory))
		time.addAction(vizact.call(self.info.expand))

def testPhase():
    results = []

    for i in range(0, 5):

        # Instruct participant where to go
        instruction = "Walk around for 5 seconds, see where you end up in this world.  You can press 1, 2, or 3".format(
            sensor.name
        )
        info.setText(instruction)

        # store the time at which this trial started
        startTime = viz.tick()

        position = viz.MainView.getPosition()
        before = str(subject) + "\t" + str(position) + "\n"

        # The yielded command returns a viz.Data object with information
        # about the proximity event such as the sensor, target involved
        yield vizproximity.wait(5)

        position = viz.MainView.getPosition()
        after = str(subject) + "\t" + str(position) + "\n"

        # save results
        results.append((before, after))

    info.setText("Thank You. You have completed the experiment")

    # return results
    viztask.returnValue(results)

 def update_thread(self):
     while self._running:
         self.update()
         elapsed = viz.tick() - self._updated
         wait = 1. / self.frame_rate - elapsed
         while wait < 0:
             wait += 1. / self.frame_rate

    def __init__(self,
                 server_name,
                 freq=OWL.OWL_MAX_FREQUENCY,
                 scale=(0.001, 0.001, 0.001),
                 offset=(0, 0, 0),
                 postprocess=False,
                 slave=False):
        super(Phasespace, self).__init__()

        flags = 0
        if postprocess:
            flags |= OWL.OWL_POSTPROCESS
        if slave:
            flags |= OWL.OWL_SLAVE

        if OWL.owlInit(server_name, flags) < 0:
            raise OwlError('phasespace')

        OWL.owlSetFloat(OWL.OWL_FREQUENCY, freq)
        OWL.owlSetInteger(OWL.OWL_STREAMING, OWL.OWL_ENABLE)

        logging.info('running phasespace at %.1f Hz', freq)

        self.scale = scale
        self.offset = offset
        self.trackers = []

        self.frame_rate = freq
        self._updated = viz.tick()
        self._lock = threading.Lock()
        self._thread = None
        self._running = False

 def runExperimentPathSet(self, pathNum, myTimeline=None):
     global speedMultiplier
     # speedMultipler = 1
     # for ps in self.pathSets:
     print pathNum
     print len(self.pathSets)
     ps = self.pathSets[pathNum]
     if myTimeline != None:
         timeline = myTimeline
     else:
         timeline = self.timelines[pathNum]
     self.peopleset = []
     newPs = PathSet()
     for personPath in ps.peoplePaths:
         p = people.a_person(speedMultiplier)
         p.custom_walk(personPath.getFullPath())
         self.peopleset.append(p)
     tophat = people.a_person(speedMultiplier, 1)
     self.abe = tophat
     tophat.custom_walk(ps.abePath.getFullPath())
     self.peopleset.append(tophat)
     self.starttime = viz.tick()
     self.errlist = []
     self.timelist = []
     # error_timer = vizact.ontimer(0.1/speedMultiplier,self.checkError,tophat,self.errlist)
     error_timer = vizact.onupdate(-10, self.checkError, tophat)
     yield self.runPathSet(self.peopleset, newPs, tophat, 1, timeline)
     vizact.removeEvent(error_timer)

 def update_thread(self):
     while self._running:
         
         self.update()
         
         #time.sleep(1./1000)
         
         try:
             elapsed = viz.tick() - self._updated
         except:
             tick = viz.tick()
             upd = self._updated
             
         wait = 1. / 1000 - elapsed
         
         if( wait > 0 ):
             time.sleep(wait)

def ExitProximity_end_sensor(end_sensor):
	sensor_data.write('\nexited start plane at: ' + str(viz.tick())+'seconds')
	global times_entered_end_plane
	global scale_x1
	global n
	times_entered_end_plane=+1
	array_manipulator(control_array)
	n=n+1