Intermittent orthographic stereo projection problems

[AySz88]

I have an application where I am using both stereo and orthographic projection. For apparently arbitrary reasons, everything in the scene will suddenly have an incorrect disparity, all too far forward or too far back, and sometimes with a spurious vertical component - as if the projection has gotten changed somewhere. It seems to happen just before or after "important" events fire, such as timer events.

I have code that can reproduce the bug reliably for me, but very subtle changes (such as changing the frequencies of the aforementioned timers) will lead to the bug going in and out of existence, so I don't know if it would be helpful at all.

Any suggestions as to what could be going wrong? I also have been trying to narrow down what exactly changes - my hunch is the screen distance, but is there any way to query its value?

[edit] I do have trackers that can be linked to the viewpoint when I'm running in cave mode, but I break the links with the viewpoint when I switch to orthographic projection (by giving a None tracker to CaveView, IIRC). Are there any problems with doing it this way?

[farshizzo]

Are you using the vizcave module? Depending on how you setup the Cave object, it will update the projection matrix every frame to account for the latest position of the head tracker. If you have other code running in a timer that tries to change the projection, then this could be the cause of the conflict. It's hard to say without seeing some sample code.

[AySz88]

I do use the vizcave module, but even when I make sure no viewpoints are moving around (like by replacing the trackers with something that doesn't move), I get a lot of different disparity values. The disparity only seems to change when certain important code is run, too (it is when I re-apply the orthographic projection, for example).

Here's some code that reproduces the problem. Press 4 or 6 to have it repeatedly display the "stimulus". In case of no stereo equipment, the most obvious symptom is that the white box doesn't always stay in the same centered location from one trial to the next - it appears left or right by some unpredictable amount. (With stereo equipment, it's more apparent that what is happening is that the disparity is changing.) It usually starts happening by the 5th trial.

Here's the file for the stimulus part with as much code as I dared to remove taken out. I don't think most of this is too important, except that I do call orthoUpdateCaveAndView() in the restart() helper function, which is run each time you press 4 or 6.

import viz
import vizact
import vizshape
import sunyhardware

def makeCylinderSpheres(radius, height, vertexCount, vertexRadius, vac=None, dc=None):
	# FIXME quite slow - profile for problems
	import random
	from math import sin, cos, pi
	
	if vac and vertexRadius != 1.0:
		print "WARNING: setting vertex radius to 1.0 meters"
		print "  for VisualAngleConstantizer to scale later"
		vertexRadius = 1.0
	
	cylinder = viz.addGroup()
	
	# Distribution of verts in theta, stratifed, parameters by trial and error
	# TODO parameterize
	skipWidth = 4.0*pi/5.0
	sliceWidth = pi/3.0
	# in height
	base = -height*0.5
	climb = height/(vertexCount-1)
	
	for vertNum in xrange(vertexCount):
		# HACK Don't render the middle few to leave room for fixation dot
		if abs(vertNum - vertexCount/2.0) <= 1.1:
			continue;
		theta = skipWidth*vertNum + sliceWidth*random.random()
		pos = [radius*sin(theta), base + vertNum*climb, radius*cos(theta)]
		
		sphere = vizshape.addSphere(radius=vertexRadius, parent=cylinder)
		sphere.setPosition(*pos)
		
		if dc:
			dc.add(sphere)
		if vac:
			vac.add(sphere, vertexRadius*2)
	
	return cylinder

# TODO error message if HiBall not available?

(METERS, DEGREES) = xrange(2) # valid units

(offX, offY, offZ) = sunyhardware.getValue(('xZero', 'yZero', 'zZero'))

DEFAULT_PARAMS = {
	'vertexRadius': 0.01, # radius of spheres, in visual angle or length
	'vertexUnits': METERS, # unit of the above radius ('degrees' only works if not orthographic)
	# Rotation options
	'rotateSpeed': 180.0, # Degrees per second, positive = front goes left
	'spinAxis': (0,1,0), # Axis of rotation in world space, not local cube space
	
	'fixationSize': 0.02,
	'fixationColor': [0.5,0.5,0.5],
	'fixationFrameSize': 0.005, # just the frame around fixationSize
	'fixationFrameColor': [1.0,1.0,1.0],
	
	# Graphical options
	'orthographic': True,
	'objectConstructor': makeCylinderSpheres,
	# Define either 'dcTable' or a 'dc' DepthColorizer object; 'dc' takes priority over 'dcTable'
	'dcTable': ( # (distance from head, [H,S,V])
		( 1.7, [240, 0.75, 0.0]),
		( 1.7, [240, 0.75, 1.0]),
		( 2.3, [360, 0.75, 1.0]),
		( 2.3, [360, 0.75, 0.0])
	),
	
	#Interface options
	'interfaceParams': {
		'usePosition': False, #True,
		'centerThreshold': 180, #offX, # Dividing line between left and right (degrees or meters)
		'centerIgnore': 5, #0.02 # Zone (in each direction) in which answer is ambiguous and ignored (degrees or meters)
		'reverse': True, # Move or point rightwards for a 'correct' answer normally, leftwards for not
	},
	'indicParams': {
		# visual indicators for pointing left/center/right
		'leftObjPos': [-0.5, -0.25, 0], # Relative to center position
		'ambigObjPos': [0.0, -0.5, 0], # Relative to center position
		'rightObjPos': [0.5, -0.25, 0], # Relative to center position
	}
}

DEFAULT_PARAMS.update({
	'objectParams': {
		'radius': 0.10, # of the circle around the cylinder
		'height': 0.45,
		'vertexCount': 24,
		},
	'startAngle': (0,0,0), # Euler angles of initial rotation
	'centerPosition': [offX, offY, offZ]
	})

class Stimulus(viz.EventClass):
	""" TODO documentation """
	
	TIMER_ID = 0
	
	def __init__(self, stimParams):
		viz.EventClass.__init__(self)
		
		self.headTrkr = stimParams['headTrkr']
		
		# Construct stimulus object to display
		params = stimParams['objectParams'].copy()
		
		params['dc']=None
		params['vertexRadius'] = stimParams['vertexRadius']
		self.obj = stimParams['objectConstructor'](**params)
		
		# Apply actual spin to object
		self.spinObject = viz.addGroup()
		self.obj.parent(self.spinObject)
		
		self.spinObject.setPosition(stimParams['centerPosition'])
		spinAxis = stimParams['spinAxis']
		spin = vizact.spin(spinAxis[0], spinAxis[1], spinAxis[2], stimParams['rotateSpeed'], viz.FOREVER)
		self.spinObject.addAction(spin)
		self.obj.visible(viz.OFF)
		self.spinObject.disable(viz.ANIMATIONS)
		
		# Create fixation block
		self.fixGroup = viz.addGroup()
		
		self.fixation = vizshape.addQuad(
			size=(stimParams['fixationSize'], stimParams['fixationSize']),
			parent = self.fixGroup)
		self.fixation.color(stimParams['fixationColor'])
		self.fixation.billboard(viz.BILLBOARD_VIEW)
		
		totalFrameSize = stimParams['fixationSize'] + stimParams['fixationFrameSize']
		self.fixationFrame = vizshape.addQuad(size=(totalFrameSize, totalFrameSize),
			parent = self.fixGroup)
		self.fixationFrame.color(stimParams['fixationFrameColor'])
		self.fixationFrame.billboard(viz.BILLBOARD_VIEW)
		
		self.fixGroup.setPosition(stimParams['centerPosition'])
		self.fixGroup.visible(viz.OFF)
		
		# Save parameters for later
		self.stimParams = stimParams
	
	def startFixation(self, trialParams):
		self.obj.setEuler(*self.stimParams['startAngle'])
		
		viz.ipd(trialParams['ipd'])
		
		self.fixGroup.visible(viz.ON)
	
	def startStimulus(self, trialParams):
		self.spinObject.enable(viz.ANIMATIONS)
		self.obj.visible(viz.ON)
	
	def endStimulus(self, stairCallback):
		self.fixGroup.visible(viz.OFF)
		self.obj.visible(viz.OFF)
		self.spinObject.disable(viz.ANIMATIONS)
		
		#self.callback(viz.SENSOR_UP_EVENT, self.onButtonUp)
		self.callback(viz.KEYUP_EVENT, self.onKeyUp)
		
		self.stairCallback = stairCallback
	
	def onKeyUp(self, key):
		if key == '4' or key == '6':
			self.callback(viz.KEYUP_EVENT, None)
			return self.stairCallback(key == '4', False)
		else:
			pass # TODO 'try again' prompt

if __name__=='__main__':
	viz.go()
	
	stimParams = DEFAULT_PARAMS.copy()
	
	trackers = sunyhardware.getAllSensors()
	(stimParams['headTrkr'], stimParams['stylusTrkr'], stimParams['stylusBtn']) = trackers
	
	# test multiple simultaneous stimulus objects
	stim = Stimulus(stimParams)
	#stim2 = Stimulus(stimParams)
	
	RESTART_DELAY = 0.5
	
	import random
	
	def delayedRestart(*args):
		viz.callback(viz.TIMER_EVENT, restart)
		viz.starttimer(0, RESTART_DELAY)
		
	def restart(*args):
		print 'starting 1'
		headTrkr = stimParams['headTrkr']
		sunyhardware.orthoUpdateCaveAndView(
			tracker = headTrkr.head,
			cave = headTrkr.cave,
			view = headTrkr.view,
			ortho = stimParams['orthographic'])
		stim.startFixation({'ipd': random.uniform(-0.05, 0.05)})
		stim.startStimulus({})
		
		viz.callback(viz.TIMER_EVENT, endStim)
		viz.starttimer(0, 1.0)
	
	def endStim(*args):
		print 'ended 1'
		viz.killtimer(0)
		#stim.endStimulus(delayedRestart2)
		stim.endStimulus(delayedRestart)
	
	delayedRestart()

...and in the next post(s) are the potentially more-relevant hardware abstraction code. The most relevant functions are loadCave() (where I define helper functions makeOrthographic() and makePerspective()) and orthoUpdateCaveAndView(), which does the dirty work of turning off caves and such.

I edited the file so you'd get dummy VRPN sensors from localhost, which definitely don't move at all. It throws slightly-annoying "no response from server" warnings, though.

[AySz88]

(The bulk of the file is mostly due to documentation, which I'm keeping intact in case it's useful.)

Part 1 of sunyhardware.py:

"""
This module provides functions and classes related to the utilization of
virtual reality hardware with Vizard in the lab of _______ at SUNY Optometry.

Variables: None.
Functions: getValue, loadCave, linkView,
	isHiBallAvailable, getTracker, getAllSensors.
Classes: Keyboard, HiBall.

For additional information about a particular function or class, please see
the documentation string for that attribute.

Usage examples:
>>> (headTrkr, stylusTrkr, stylusBtn) = sunyhardware.getAllSensors()
>>> tracker = HiBall()
>>> screenWidth = getValue('screenWidth')
>>> print loadCave.__doc__

<removed>
August 4, 2008
	edited by:
	<removed>
	July 29, 2011
"""

from __future__ import division #implements "/" as division without truncation regardless of its operands
import viz #standard Vizard module
import vizcave #Vizard virtual reality cave module

#private variables (measurements taken by hand [AEY 8/11/2011] in meters)
	#1024x768, projector settings: 'size' = 1.060, 'vertical stretch' = 1.000
	#most are a rough average of two measurements
_screenHeight = 1.779
_screenWidth = 2.396
_screenHeightOffset = (
	0.448	#floor-to-frame
	+ 0.034	#plus frame width
	+ 0.030	#plus frame-to-image
	)
_screenWidthOffset = (
	-0.060	#origin-to-right-wall
	+ 0.270	#plus wall-to-big-frame
	+ 0.034	#plus frame width
	+ 0.030	#plus frame-to-image
	)
_screenDepthOffset = (
	0.573	#origin-to-wall
	+ 0.083	#plus wall-to-frame
	+ 0.023	#plus frame width
	+ 0.008	#plus glass-to-image (glass thickness)
	)
_eyesHeightOffset = 0.140 #approx dist of eyes below HiBall (MAR+SJH 1/23/2009, RBM subject)
_eyesDepthOffset = 0.110 #approx dist of eyes in front of HiBall (MAR+SJH 1/23/2009, RBM subject)

_stylusOffset = [-0.00175, -0.1050, -0.1693] #TODO from HiBall stylus calibration procedure, currently 2003 numbers
	# intended for link.preTrans(); see Help (Reference > Linking > Operators on Links)

def getValue(parameter):
	"""
	Returns the read-only value of the named private attribute.
	
	Currently accepted parameter names include: 'screenHeight', 'screenWidth',
	'screenHeightOffset', 'screenWidthOffset', 'screenDepthOffset',
	'eyesHeightOffset', 'eyesDepthOffset'.
	
	Definition:
	getValue(parameter)
	
	Usage:
	>>> screenWidth = getValue('screenWidth')
	"""
	
	if parameter=='screenWidth':
		return _screenWidth
	elif parameter=='screenHeight':
		return _screenHeight
	elif parameter=='screenHeightOffset':
		return _screenHeightOffset
	elif parameter=='screenWidthOffset':
		return _screenWidthOffset
	elif parameter=='screenDepthOffset':
		return _screenDepthOffset
	elif parameter=='eyesHeightOffset':
		return _eyesHeightOffset
	elif parameter=='eyesDepthOffset':
		return _eyesDepthOffset
	elif parameter=='xZero':
		return -_screenWidthOffset - _screenWidth/2
	elif parameter=='yZero':
		return _screenHeightOffset + _screenHeight/2
	elif parameter=='zZero':
		return _screenDepthOffset
	elif parameter=='stylusOffset':
		return _stylusOffset
	elif isinstance(parameter,tuple): # must use tuples since strings are lists
		return [getValue(x) for x in parameter]

def getVisualBounds(origin):
	# Given HiBall coordinates of a viewpoint, return elevations and azimuths of each edge of screen (l,r,t,b)
	from math import atan2, degrees
	(x0, y0, z0) = getValue(('xZero', 'yZero', 'zZero'))
	(w, h) = getValue(('screenWidth', 'screenHeight'))
	[x,y,z] = origin
	lrtb = (x0-w/2-x, x0+w/2-x, y0+h/2-y, y0-h/2-y)
	angles = map(lambda opposite: atan2(opposite,z), lrtb)
	print "bounds at", origin
	print "... are", map(degrees, angles)
	return angles

def loadCave(tracker=None,orthographic=False):
	"""
	Returns a Vizard cave optionally driven by tracker coordinates.
	
	Creates a vizcave wall based on coordinates for the Christie Mirage S+4K
	projection screen. Creates a stereo vizcave cave to which the wall and
	optionally provided tracker are added. The cave can optionally be placed
	in orthographic projection (defaults to perspective). The tracker, if
	provided, sends position and orientation information to the cave, which
	is used in the calculation of the viewing frustum. Note that the active
	viewport is not updated with the tracking position; please use linkView
	to do so.
	
	Definition:
	loadCave(tracker=None,orthographic=False)
	
	Usage:
	>>> cave = loadCave(tracker)
	"""
	
	#save default inter-pupilary distance (IPD)
	ipd = viz.MainWindow.getIPD()
	if not isinstance(tracker,viz.VizView):
		ipd = -ipd #KLUDGE - this solves eye-swap problem, but still not sure where this problem comes from
	
	def makeOrthographic():
		# TODO Doesn't change IPD based on orientation of eyes with head
		# Requires the wall to be in the X-Y plane
		# to set up tracker so that stereo IPD will be correct?
		
		# NOTE this is the "intended" way of doing this, but has drawbacks
		viz.MainView.eyeheight(0)
		viz.MainView.reset(viz.RESET_POS)
		viz.MainWindow.ortho(
			-_screenWidthOffset - _screenWidth,
			-_screenWidthOffset,
			_screenHeightOffset,
			_screenHeightOffset + _screenHeight,
			-1, -1, # automatic near and far clip
			eye = viz.BOTH_EYE)
		viz.MainWindow.screenDistance(_screenDepthOffset)
		
		return None
	
	cave = vizcave.Cave()
	
	def makePerspective():
		#setup wall using world coordinates
		upperLeft = [-_screenWidthOffset-_screenWidth, _screenHeightOffset+_screenHeight, _screenDepthOffset]
		upperRight = [-_screenWidthOffset, _screenHeightOffset+_screenHeight, _screenDepthOffset]
		lowerLeft = [-_screenWidthOffset-_screenWidth, _screenHeightOffset, _screenDepthOffset]
		lowerRight = [-_screenWidthOffset, _screenHeightOffset, _screenDepthOffset]
		wall = vizcave.Wall('wall',upperLeft,upperRight,lowerLeft,lowerRight)
		
		#setup cave with wall and tracker (optional)
		cave.setIPD(ipd)
		cave.addWall(wall)
		if tracker:
			cave.setTracker(pos=tracker, ori=tracker)
	
	tracker.makeOrthographic = makeOrthographic
	tracker.makePerspective = makePerspective
	
	if orthographic:
		tracker.makeOrthographic()
	else:
		tracker.makePerspective()
	
	return cave
	
	# FAILED METHOD
	# Below code **messes up stereo** when giving orthographic-like projection
	"""
	#setup wall using world coordinates
	upperLeft = [-_screenWidthOffset-_screenWidth, _screenHeightOffset+_screenHeight, _screenDepthOffset]
	upperRight = [-_screenWidthOffset, _screenHeightOffset+_screenHeight, _screenDepthOffset]
	lowerLeft = [-_screenWidthOffset-_screenWidth, _screenHeightOffset, _screenDepthOffset]
	lowerRight = [-_screenWidthOffset, _screenHeightOffset, _screenDepthOffset]
	wall = vizcave.Wall('wall',upperLeft,upperRight,lowerLeft,lowerRight)
	
	#setup cave with wall and tracker (optional)
	cave = vizcave.Cave()
	cave.setIPD(ipd)
	cave.addWall(wall)
	if tracker:
		# HACK if orthographic, shift viewpoint as if view is from far away (image as through a telescope)
		cave.orthoTracker = viz.link(tracker, viz.NullLinkable)
		cave.orthoTracker.postTrans([0,0,-100])
		
		def makeOrthographic():
			cave.setTracker(pos=cave.orthoTracker, ori=tracker)
		def makePerspective():
			cave.setTracker(pos=tracker, ori=tracker) #named arguments used for clarity (ori required for stereo)
		
		cave.makeOrthographic = makeOrthographic
		cave.makePerspective = makePerspective
		
		if orthographic:
			cave.makeOrthographic()
		else:
			cave.makePerspective()
	return cave
	"""

def linkView(tracker,withCave=False):
	"""
	Returns a view based on tracker coordinates.
	
	Links the provided tracker to the Vizard main viewpoint. If
	withCave=True, links the tracker to main view through the cave
	view, otherwise links directly to the main view (default).
	
	Definition:
	linkView(tracker,withCave=False)
	
	Usage:
	>>> view = linkView(tracker,True)
	"""
	
	# HACK CaveView doesn't require a cave...at the moment
	return vizcave.CaveView(tracker)
	"""
	if withCave:
		#link tracker to CaveView
		view = vizcave.CaveView(tracker) #added flexibility to change viewpoint manually
	else:
		#link tracker directly to viz.MainView
		view = viz.link(tracker,viz.MainView)
		view.setDstFlag(viz.LINK_POS_RAW) #use the raw tracker position coordinates
	return view
	"""

def orthoUpdateCaveAndView(tracker, cave, view, ortho):
	if ortho:
		tracker.makeOrthographic()
		cave.setTracker(pos=None, ori=None)
		view.setView(viz.NullLinkable) # disassociate CaveView and tracker
		viz.cam.reset()
	else:
		tracker.makePerspective()
		cave.setTracker(pos=tracker,ori=tracker)
		view.setView(viz.MainView)

[AySz88]

Part 2 of sunyhardware.py:

class Keyboard:
	"""
	Implements a simulated positional tracker using the keyboard.
	
	This class is especially useful for debugging, when access to the
	HiBall hardware is unavailable or undesirable. The key mapping is
	displayed in the main window. An associated cave object, with
	tracker-adjusted frustum, and link to the active viewpoint are
	created by default.
	
	Variables: head, cave, view.
	Functions: write.
	
	The variable head provides access to the Vizard tracker object, the
	variable cave provides access to the Vizard cave object with which
	the tracker is associated, and the variable view provides access to
	the view to which the tracker is linked. For additional information
	about a particular function, please see the documentation string
	for that function.
	
	Definition:
	Keyboard(makeCave=True,orthographic=False,trackCave=True,makeLink=True)
	
	Usage:
	>>> tracker = Keyboard()
	>>> position = tracker.head.getPosition()
	"""
	
	head = cave = view = None
	
	def __init__(self,makeCave=True,orthographic=False,trackCave=True,makeLink=True):
		#keyboard simulated tracker
		import viztracker
		self.head = viztracker.add()
		self.head.setPosition(-_screenWidth/2-_screenWidthOffset,_screenHeight/2+_screenHeightOffset+_eyesHeightOffset,-2) #start in the "middle" of the room
		
		#display keyboard mapping
		import vizinfo #Vizard 2D GUI commands
		self.info = vizinfo.add('Left/Right = Q/E\n'+
			'Up/Down = R/F\n'+
			'Forwards/Backwards = W/S\n\n'+
			'Roll Left/Right = G/J\n'+
			'Pitch Up/Down = Y/H\n'+
			'Yaw Left/Right = A/D')
		self.info.title('Keyboard Tracker Mapping')
		
		#add cave and link viewpoint
		if makeCave:
			if trackCave:
				self.cave = loadCave(self.head,orthographic)
			else:
				self.cave = loadCave(None,orthographic)
		if makeLink:
			self.view = linkView(self.head,makeCave)
		
	def write(self,timerID):
		"""
		Prints the simulated keyboard coordinates to standard output.
		
		Accepts the timerID as specified by viz.callback. Prints the
		current tracker position and orientation whenever a timer
		expires.
		
		Definition:
		write(timerID)
		
		Usage:
		>>> viz.callback(viz.TIMER_EVENT,write)
		>>> viz.starttimer(0,3,viz.FOREVER)
		"""
		
		print 'Keyboard [x, y, z] = [%.3f, %.3f, %.3f]'%tuple(self.head.getPosition())
		print 'Keyboard [yaw, pitch, roll] = [%.3f, %.3f, %.3f]'%tuple(self.head.getEuler())

class HiBall:
	"""
	Implements a connection to the HiBall Wide Area Tracker via VRPN.
	
	This class simplifies access to the HiBall hardware. It loads the
	required VRPN plug-in and creates the tracker object(s). An
	associated cave object, with tracker-adjusted frustum, and link
	to the active viewpoint are created by default.
	
	The HiBall sensor zero point (X=Y=Z=0) is located on floor below
	front-right LED. The default directional vectors (+X=Left,
	+Y=Backwards, +Z=Up) are remapped (+X=Right, +Y=Up, +Z=Forwards).
	The default orientational vectors are correspondingly remapped.
	
	For the headtracker, the location tracked is between the eyes of
	a generic individual.  For the stylus, the location tracked is at
	the base of the HiBall sensor. (TODO calibrate for the stylus point)
	
	Variables: head, cave, view.
	Functions: write.
	
	The variable head provides access to a viz.Linkable tracking the
	appropriate location (not necessarily a VizExtensionSensor), the
	variable cave provides access to the Vizard cave object with which
	the tracker is associated, and the variable view provides access to
	the view to which the tracker is linked. For additional information
	about a particular function, please see the documentation string
	for that function.
	
	Definition:
	HiBall(makeCave=True,orthographic=False,trackCave=True,makeLink=True,sensor=SENSOR_HEADTRACKER)
	
	Usage:
	>>> tracker = HiBall()
	>>> position = tracker.head.getPosition()
	"""
	
	SENSOR_HEADTRACKER = 0;
	SENSOR_STYLUS = 1; #handheld stylus (borrowed from UNC as of 7/2011)
	
	SENSOR_DEFAULT = SENSOR_HEADTRACKER;
	
	vrpn = viz.add('vrpn7.dle') #VRPN 7.15 plug-in
	
	head = cave = view = None
	
	def __init__(self,makeCave=True,orthographic=False,trackCave=True,makeLink=True,sensor=SENSOR_DEFAULT):
		"""VRPN head tracker"""
		
		# the 0 in 'Tracker0' is NOT the sensor number
		self.raw = self.__class__.vrpn.addTracker('Tracker0@localhost', sensor)
		self.raw.swapPos([-1,3,-2])
		self.raw.swapQuat([1,-3,2,4])
		
		# Find appropriate offset in local coordinate space
		if sensor == self.__class__.SENSOR_HEADTRACKER:
			offset = (0,-_eyesHeightOffset,-_eyesDepthOffset)
		elif sensor == self.__class__.SENSOR_STYLUS:
			offset = _stylusOffset
		else:
			offset = (0,0,0)
			print 'Unknown sensor %s; please update sunyhardware'%sensor
		
		link = viz.link(self.raw, viz.NullLinkable)
		link.preTrans(offset)
		self.head = link # Links are themselves linkables
		
		self.sensor = sensor; # just for .write()
		
		#add cave and link viewpoint
		if makeCave:
			if trackCave:
				self.cave = loadCave(self.head,orthographic)
			else:
				self.cave = loadCave(None,orthographic)
		if makeLink:
			self.view = linkView(self.head,makeCave)
		
	def write(self,timerID):
		"""
		Prints the HiBall coordinates to standard output.
		
		Accepts the timerID as specified by viz.callback. Prints the
		current tracker position and orientation whenever any timer
		expires.
		
		Definition:
		write(timerID)
		
		Usage:
		>>> viz.callback(viz.TIMER_EVENT,write)
		>>> viz.starttimer(0,3,viz.FOREVER)
		"""
		print 'HiBall%s'%self.sensor, '[x, y, z] = [%.3f, %.3f, %.3f]'%tuple(self.head.getPosition())
		print 'HiBall%s'%self.sensor, '[yaw, pitch, roll] = [%.3f, %.3f, %.3f]'%tuple(self.head.getEuler())

def isHiBallAvailable():
	"""
	Tries to connect to the HiBall server (computer name 'hiball')
	on port 3883, and returns true when successful.
	Doesn't actually do anything (similar to a ping).
	"""
	
	import socket #built-in Python socket module
	
	try:
		udpSock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #create UDP socket
		udpSock.connect(('hiball',3883)) #try to connect
		udpSock.close() #close socket test connection
		return True
	except socket.gaierror:
		return False

def getTracker(makeCave=True,orthographic=False,trackCave=True,makeLink=True,sensor=HiBall.SENSOR_DEFAULT):
	"""
	Factory function to return a HiBall or Keyboard tracker.
	
	This class is a factory function, which returns a HiBall tracker
	object when the HiBall system is present, or a simulated Keyboard
	tracker object otherwise. For additional information about the
	HiBall and Keyboard classes, please see the class documentation
	strings.
	
	The boolean flags makeCave, orthographic, trackCave, and makeLink
	specify the type of virtual reality environment to construct:
	makeCave=True uses hard-coded cave parameters (see loadCave),
	orthographic=True results in orthographic projection (object size
	will need to be reduced by a factor of 100), trackCave=True allows
	the tracker object to update the cave frustums, and makeLink=True
	links the tracker object's position to the cave's view matrix.
	
	Definition:
	getTracker(makeCave=True,orthographic=False,trackCave=True,makeLink=True,sensor=HiBall.SENSOR_DEFAULT)
	
	Usage:
	>>> tracker = getTracker(sensor=HiBall.SENSOR_HEADTRACKER)
	>>> position = tracker.head.getPosition()
	"""
	
	# return appropriate tracker object
	if isHiBallAvailable():
		return HiBall(makeCave,orthographic,trackCave,makeLink,sensor)
	else:
		return Keyboard(makeCave,orthographic,trackCave,makeLink)

def getAllSensors():
	"""
	Returns all three sensors (head and stylus trackers, and stylus button)
	after constructing them using 'reasonable' default settings.  This sets
	up the cave with perspective projection, with tracking, and links the
	headtracker to the cave's view matrix.
	
	The head tracker tracks the orientation of the head and the location of
	the point between the eyes (of a generic subject).  The stylus tracker
	provides the position of the stylus at the bottom of the sensor and its
	orientation.
	
	Note that if the hiball server is not available, it will return a
	keyboard tracker as the headtracker, and None for the stylus tracker
	and stylus button.
	
	Usage:
	>>> (headTracker, stylusTracker, button) = getAllSensors()
	>>> # EXAMPLES FOR DEBUGGING
	>>> def writeAll(timerID):
			headTracker.write(timerID)
			if stylusTracker: stylusTracker.write(timerID)
			if stylusButton: print 'Button =', stylusButton.buttonState(), '(buttons:' + str(stylusButton.buttonCount()) + ')'
	>>> viz.callback(viz.TIMER_EVENT,writeAll)
	>>> viz.starttimer(0,3,viz.FOREVER)
	
	>>> def onButtonUp(e):
			if e.object is stylusButton:
				pass #YOUR CODE HERE
	>>> viz.callback(viz.SENSOR_UP_EVENT,onButtonUp)
	
	>>> def onButtonDown(e):
			if e.object is stylusButton:
				pass #YOUR CODE HERE
	>>> viz.callback(viz.SENSOR_DOWN_EVENT,onButtonDown)
	"""
	
	if True:#isHiBallAvailable():
		headTracker = HiBall(sensor=HiBall.SENSOR_HEADTRACKER)
		stylusTracker = HiBall(makeCave=False,
								   makeLink=False,
								   sensor=HiBall.SENSOR_STYLUS)
		button = HiBall.vrpn.addButton('Button0@localhost')
	else:
		headTracker = Keyboard()
		stylusTracker = None
		button = None
		
	return (headTracker, stylusTracker, button)

if __name__=='__main__': #if module is run as a script
	#display the documentation string
	print __doc__

[farshizzo]

As I mentioned, the Cave object will automatically call <window>.frustum every frame if you specify a tracker. I noticed your code will call <window>.ortho under certain circumstances. So one call will be overriding the other, depending on which is called first. Do any of your code paths allow for <window>.ortho to be called while a tracker is specified for the cave object?

[AySz88]

The code always does the following at the same time as calling <window>.ortho(). (Testing it just now, doing it just before or just after makes no difference.)

cave.setTracker(pos=None, ori=None)
view.setView(viz.NullLinkable) # disassociate CaveView and tracker
viz.cam.reset()

This should cause the cave object to stop calling <window>.frustum, correct?

[farshizzo]

That should stop the cave object from automatically changing the frustum. Try adding the following line as well:

viz.MainWindow.ipdVector(None)

I noticed the IPD values changes drastically from trial to trial. Are you sure this isn't causing the problem?

[AySz88]

Yes - the center of the object is at the same distance as the screendistance used for the orthographic projection. Thus the square mark should always have zero disparity, so it shouldn't move no matter what the IPD is.

Does that line of code force the IPD value to zero? That wouldn't work for my purposes, since I do need stereo - it is adjusting the IPD value so as to "turn up" or "turn down" the stereo cue on demand, as needed by the rest of the experiment.

[farshizzo]

The IPD vector is used by vizcave to change the direction the IPD shift is applied to the view matrix. I think adding that line should fix your problem.

[AySz88]

Just got a chance to try it, and it works! Thanks!