def motion():
# Create Fixation Dot
viz.startLayer(viz.POINTS)
viz.pointSize(self.POINTSIZE)
viz.vertexColor(viz.GRAY)
viz.vertex(0, 1.8, 4)
points = viz.endLayer()
points.disable(viz.CULLING)
# Create the circles
sphere = self.createCircles(26, 1, 30, -26)
sphere2 = self.createCircles(22, 0.8, 30, -26)
sphere3 = self.createCircles(18, 0.6, 30, -26)
sphere4 = self.createCircles(14, 0.4, 30, -26)
sphere5 = self.createCircles(10, 0.2, 30, -26)
viz.MainView.move([0, 0, 3])
def keydown(key):
if key == 'f':
self.response = 'self motion'
self.keyPressTime = viz.tick() # get time for keypress
print(self.response, self.keyPressTime)
self.STATE = 'State - self Motion'
if key == 'j':
self.response = 'object motion'
self.keyPressTime = viz.tick() # get time for keypress
print(self.response, self.keyPressTime)
self.STATE = 'State - Object Motion'
viz.callback(viz.KEYDOWN_EVENT, keydown)
def flashingCloud(height, width, depth, offset, number, node):
positions = np.random.uniform(low = -width/2, high = width/2, size = (number, 3))
positions[:, 1] = positions[:, 1]/(width/height)
# Save the location of each dots into a .csv file
record = open('Cloud_positions_' + str(number) + '.csv', 'a' )
for n in range(number):
record.write(str(positions[n, 0]) + ',' + str(positions[n, 1]) + ',' + str(positions[n, 2]) + '\n')
positions[:, 2] = positions[:, 2] - (depth/2 - offset)
clouds = []
viz.startLayer(viz.POINTS)
viz.pointSize(2) # Set the size of the dots on the display
# Draw each dot
for i in range(number):
viz.vertex(positions[i, 0], positions[i, 1], positions[i, 2])
cloud = viz.endLayer()
# Set a parent object for the cloud.
# Therefore, once the location of the parent is determined, the location of the cloud as a whole is also determined.
cloud.setParent(node)
return cloud
def createRod(): viz.startLayer(viz.POINTS) viz.pointSize(4) viz.vertex(0,1.65,1) viz.vertex(0,1.70,1) viz.vertex(0,1.75,1) viz.vertex(0,1.80,1) viz.vertex(0,1.85,1) viz.vertex(0,1.90,1) viz.vertex(0,1.95,1) line = viz.endLayer() line.visible(viz.OFF) line.center(0,1.8,1) initLinePos = 0 + 20 * random.uniform(-1,1) line.setEuler([0,0,initLinePos]) class LineRotation(viz.EventClass): def __init__(self): viz.EventClass.__init__(self) self.callback(viz.KEYDOWN_EVENT, self.keyboardAction) def keyboardAction(self,key): currentPosition = line.getEuler() currentRoll = currentPosition[2] if viz.key.isDown(viz.KEY_LEFT): line.setEuler([0,0,currentRoll + 1]) elif viz.key.isDown(viz.KEY_RIGHT): line.setEuler([0,0,currentRoll -1]) LineRotation() return line, initLinePos
def GenerateStarDome(numStars, pointSize, minRadius, maxRadius, scene=1, yCenter=0):
#Create a star dome of random points
viz.startLayer(viz.POINTS)
viz.pointSize(pointSize)
for i in range(0, numStars):
x = random() - 0.5
y = random() - 0.5
z = random() - 0.5
length = math.sqrt(x*x + y*y + z*z)
rad = vizmat.GetRandom(minRadius,maxRadius)
x = x / length * rad
y = y / length * rad
y += yCenter
z = z / length * rad
color = vizmat.GetRandom(0.4,1)
viz.vertexColor([color,color,color-vizmat.GetRandom(0,0.2)])
viz.vertex([x, y, z])
stardome = viz.endLayer()
stardome.setParent(viz.WORLD, scene=scene)
stardome.texture( viz.addTexture('particle.rgb') )
stardome.blendFunc(viz.GL_SRC_ALPHA,viz.GL_DST_ALPHA)
stardome.enable(viz.POINT_SPRITE)
stardome.disable(viz.DEPTH_TEST)
stardome.draworder(-100000)
def getViewXYZ(self, dist="far", reFrame=viz.ABS_GLOBAL):
# temporarily add vertex to track parcel pos in abs coords
viz.startLayer(viz.POINTS)
viz.vertexColor(1,0,0)
viz.pointSize(30)
viz.vertex(0,0,0)
cV = viz.endLayer()
cV.setParent(self.bNodeOp)
if dist == "far":
cV.setPosition(self.viewLocFar, mode=viz.ABS_LOCAL)
zoneXYZ = cV.getPosition(mode=reFrame)
elif dist == "near":
cV.setPosition(self.viewLocNear, mode=viz.ABS_LOCAL)
zoneXYZ = cV.getPosition(mode=reFrame)
elif dist == 'center':
zoneXYZ = self.bNodeOp.getPosition(mode=reFrame)
cV.visible(viz.OFF)
cV.remove()
# set y to eye height
zoneXYZ[1] = ct.EYE_HEIGHT
return zoneXYZ
def getCornerCoords(cNode, quSpace):
nBox = cNode.getBoundingBox(viz.ABS_LOCAL)
cCrns = [ (nBox.xmin, 0, nBox.zmin), (nBox.xmin, 0, nBox.zmax), (nBox.xmax, 0, nBox.zmax), (nBox.xmax, 0, nBox.zmin) ]
globalCrns = []
singleVertChildren = []
for c in cNode.getChildren():
if c.__class__ == viz.VizPrimitive:
singleVertChildren.append( c )
#print "nChildren: ", singleVertChildren
i = 0
for cC in cCrns:
# add helper vertices if this node does not contain
# four children -> heuristic
if not len(singleVertChildren) == 4:
# create vertex
viz.startLayer(viz.POINTS)
viz.vertexColor(1,0,0)
viz.pointSize(30)
viz.vertex(0,0,0)
cV = viz.endLayer()
# set obst as parent
cV.setParent(cNode)
# move to parent's corner
x,y,z = cC
cV.setPosition(x, y, z, viz.ABS_PARENT)
else:
cV = singleVertChildren[i]
# set obst as parent
cV.setParent(cNode)
# move to parent's corner
x,y,z = cC
cV.setPosition(x, y, z, viz.ABS_PARENT)
# get global coords
x,y,z = cV.getPosition(viz.ABS_GLOBAL)
# flip z axis to get from world to pedSim space
if quSpace == 'ped':
z=-z
globalCrns.append( (x,y,z) )
# remove this vertex
#cV.remove()
i = i+1
return globalCrns
def __init__(self, x, y):
self.x = x
self.y = y
viz.startLayer(viz.QUADS)
viz.vertexColor(0, 0, 0)
viz.pointSize(100)
viz.vertex(-1, 0)
viz.vertex(+1, 0)
viz.vertex(+1, 2)
viz.vertex(-1, 2)
viz.endLayer()
def __init__(self, x, y): height = 10 width = 10 self.x = 0 self.y = 0 viz.startLayer(viz.QUADS) viz.vertexColor(1,1,0) viz.pointSize(1) viz.vertex(-5,10) viz.vertex(5,10) viz.vertex(5,-10) viz.vertex(-5,-10) viz.endLayer()
def generate_cloud(self, data, color_array_name):
"""
Render the vtk data as a cloud, centered at origin and return the Vizard object.
color_array_name defines the name of the CellData array (for example: "equivalent_stress" or "material")
"""
# Start creating the model
viz.startLayer(viz.POINTS)
viz.pointSize(self.cloud_point_size)
# Use the range of the complete data set to ensure consitency
minimum, maximum = self.vtk_data_local.GetCellData().GetArray(
color_array_name).GetRange()
# Generate cloud model by iterating over every cell
num_of_cells = data.GetNumberOfCells()
for i in range(num_of_cells):
cell = data.GetCell(i)
# Calculate the center of the cell
x = 0.0
y = 0.0
z = 0.0
num_of_points = cell.GetNumberOfPoints()
for j in range(num_of_points):
point = cell.GetPoints().GetPoint(j)
x += point[0]
y += point[1]
z += point[2]
x /= num_of_points
y /= num_of_points
z /= num_of_points
# Get the value of the cell for color calculation
value = data.GetCellData().GetArray(color_array_name).GetValue(i)
color = Simulation_Data._get_color(minimum, maximum, value)
viz.vertexColor(color[0], color[1], color[2])
# Draw the point
viz.vertex(x, y, z)
# Finish the model
model = viz.endLayer()
# Set the center of the model to (0, 0, 0)
model.setPosition(-(self._original_center[0]),
-(self._original_center[1]),
-(self._original_center[2]))
# Create group to get a centered model with coordinates (0, 0, 0)
group = viz.addGroup()
model.setParent(group)
return group
def createCircles(self, NUM_DOTS, RADIUS, POINTSIZE, VELOCITYDIRECTION):
#Build sphere
viz.startLayer(viz.POINTS)
viz.vertexColor(viz.WHITE)
viz.pointSize(self.POINTSIZE)
for i in range(0, NUM_DOTS):
x = RADIUS * math.cos((i * 2 * math.pi) / NUM_DOTS)
y = RADIUS * math.sin((i * 2 * math.pi) / NUM_DOTS)
viz.vertex([x, y, 0])
sphere = viz.endLayer()
sphere.setPosition([0, 1.8, 4])
sphere.addAction(vizact.spin(0, 0, 1, VELOCITYDIRECTION))
return sphere
def refreshing(clouds):
index = 0
while True:
clouds[index].remove()
pos = np.random.uniform(low=-6, high=6, size=(cloudFreq / freq, 3))
pos[:, 1] = pos[:, 1] / 2
pos[:, 2] = pos[:, 2] - 5
viz.startLayer(viz.POINTS)
viz.pointSize(2)
for n in range(cloudFreq / freq):
viz.vertex(pos[n, 0], pos[n, 1], pos[n, 2])
single_cloud = viz.endLayer()
single_cloud.disable(viz.CULLING)
single_cloud.setParent(Target)
clouds.append(single_cloud)
index += 1
yield viztask.waitDraw()
def __init__(self, length, colors, x, y):
self.length = length
self.colors = colors
self.x = x
self.y = y
viz.startLayer(viz.POLYGON)
viz.vertexColor(colors[0], colors[1], colors[2])
viz.pointSize(1)
viz.vertex(0, 0)
viz.vertex(length, 0)
viz.vertex(length, length)
viz.vertex(0, length)
viz.endLayer()
def setStage():
global groundplane, groundtexture
# ###should set this hope so it builds new tiles if you are reaching the boundary.
# fName = 'textures\strong_edge.bmp'
#
# # add groundplane (wrap mode)
# groundtexture = viz.addTexture(fName)
# groundtexture.wrap(viz.WRAP_T, viz.REPEAT)
# groundtexture.wrap(viz.WRAP_S, viz.REPEAT)
#
# groundplane = viz.addTexQuad() ##ground for right bends (tight)
# tilesize = 5000#300 #F***ING MASSIVE
# planesize = tilesize/5
# groundplane.setScale(tilesize, tilesize, tilesize)
# groundplane.setEuler((0, 90, 0),viz.REL_LOCAL)
# #groundplane.setPosition((0,0,1000),viz.REL_LOCAL) #move forward 1km so don't need to render as much.
# matrix = vizmat.Transform()
# matrix.setScale( planesize, planesize, planesize )
# groundplane.texmat( matrix )
# groundplane.texture(groundtexture)
# groundplane.visible(1)
gsize = [1000, 1000] #groundplane size, metres
groundplane = vizshape.addPlane(size=(gsize[0], gsize[1]),
axis=vizshape.AXIS_Y,
cullFace=True) ##make groundplane
groundplane.texture(viz.add('black.bmp')) #make groundplane black
#Build dot plane to cover black groundplane
ndots = 200000 #arbitrarily picked. perhaps we could match dot density to K & W, 2013?
viz.startlayer(viz.POINTS)
viz.vertexColor(viz.WHITE)
viz.pointSize(2)
for i in range(0, ndots):
x = (random.random() - .5) * gsize[0]
z = (random.random() - .5) * gsize[1]
viz.vertex([x, 0, z])
dots = viz.endLayer()
dots.setPosition(0, 0, 0)
dots.visible(1)
groundplane.visible(1)
def __init__(self, bldList):
self.info = PointInfo()
self.buildings = bldList
self.trials = []
self.cTrial = None
self.trialCtr = -1
self.trgAngle = None
self.hideBuildings()
self.trialData = {}
# add vertex to measure true target angel
viz.startLayer(viz.POINTS)
viz.vertexColor(1,0,0)
viz.pointSize(30)
viz.vertex(0,0,0)
self.refVert = viz.endLayer()
self.refVert.disable(viz.RENDERING)
# add grid to orient subject during
# pointing
viz.startLayer(viz.LINES)
viz.lineWidth(6)
viz.vertexColor(0,0.6,0)
viz.vertex(-100, 0.01, 0)
viz.vertex( 100, 0.01, 0)
viz.vertex( 0, 0.01,-100)
viz.vertex( 0, 0.01, 100)
self.cross90 = viz.endLayer()
self.cross90.visible(viz.OFF)
self.grid = vizshape.addGrid(size=[200,200], step=10.0, boldStep=None)
self.grid.color([0,.6,0])
self.grid.visible(viz.OFF)
# add logger
self.fields2log = {'trialNr' : 'i8', 'srcBuilding' : 'S10', 'trgBuilding' : 'S10', 'refAngle' : 'f4', 'measAngle' : 'f4', 'trueAngle' : 'f4', 'trialOnset' : 'f8', 'tChoiceMade' : 'f8', 'srcXZ' : [('x', 'f4'), ('z', 'f4')], 'trgXZ' : [('x', 'f4'), ('z', 'f4')], 'srcCtxt' : 'S1', 'trgCtxt' :'S1'}
self.logHdl = lg.LogData(self.fields2log)
# handle exit
vizact.onexit( self.saveOnExit )
def flashingCloud(height, width, depth, offset, number, node, frequence):
positions = np.random.uniform(low=-width / 2,
high=width / 2,
size=(number, 3))
positions[:, 1] = positions[:, 1] / (width / height) + height / 2
positions[:, 2] = positions[:, 2] - (depth / 2 - offset)
clouds = []
for j in range(frequence):
viz.startLayer(viz.POINTS)
viz.pointSize(2) #Set the size of the points.
bin = number / frequence
for i in range(bin):
viz.vertex(positions[j * bin + i, 0], positions[j * bin + i, 1],
positions[j * bin + i, 2])
single_cloud = viz.endLayer()
clouds.append(single_cloud)
clouds[-1].setParent(node)
return clouds
def set_cloud_point_size(self, point_size=1):
"""
Sets the current size of the point cloud points.
This function also updates the point cloud model.
"""
self.cloud_point_size = point_size
# update the models of the different materials
for key in self.cloud_materials.keys():
old_model = self.cloud_materials[key].getChildren()[0]
# Create new model
viz.startLayer(viz.POINTS)
viz.pointSize(point_size)
# Copy the old model with new point_size
for point_id in range(old_model.getVertexCount()):
viz.vertexColor(old_model.getVertexColor(point_id))
viz.vertex(old_model.getVertex(point_id))
model = viz.endLayer()
# Replace the old model with the new one
model.setParent(self.cloud_materials[key])
model.setPosition(old_model.getPosition())
model.setScale(old_model.getScale())
model.setEuler(old_model.getEuler())
old_model.remove()
def runtrials(self):
"""Loops through the trial sequence"""
setStage()
self.driver = vizdriver.Driver(self.caveview)
self.SAVEDATA = True # switch saving data on.
viz.MainScene.visible(viz.ON, viz.WORLD)
#add text to denote conditons - COMMENT OUT FOR EXPERIMENT
# txtCondt = viz.addText("Condition",parent = viz.SCREEN)
# txtCondt.setPosition(.7,.2)
# txtCondt.fontSize(36)
if self.EYETRACKING:
comms.start_trial()
for i, trialtype_signed in enumerate(self.TRIALSEQ_signed):
### iterates each trial ###
#import vizjoy
print("Trial: ", str(i))
print("TrialType: ", str(trialtype_signed))
print("gplanez", self.gplane_z_size)
print("gplane2", self.gplane2)
trialtype = abs(trialtype_signed)
trial_heading = self.ConditionList_heading[
trialtype] #set heading for that trial
trial_dots = self.ConditionList_dots[trialtype]
print(str([trial_heading, trial_dots]))
######choose correct road object.######
# changes message on screen
# msg = msg = "Heading: " + str(trial_heading) # COMMENT OUT FOR EXPERIMENT
#update class trial parameters#
self.Trial_N = i
self.Trial_heading = trial_heading
self.Trial_dots = trial_dots
self.Trial_trialtype_signed = trialtype_signed
#1) Offset camera and manipulate dot flow
#FOR EQUAL AND OPPOSITE USE THE LINE BELOW:
self.Trial_Camera_Offset = trial_heading
#put a mask on so that the jump isn't so visible
self.blackscreen.visible(viz.ON)
yield viztask.waitFrame(
12) #wait for six frames (.2 s) originally 6
viz.startlayer(viz.POINTS)
viz.vertexColor(viz.WHITE)
viz.pointSize(2)
for i in range(0, trial_dots):
x = (random.random() - .5) * tilesize
z = (random.random() - .5) * tilesize
viz.vertex([x, 0, z])
dots = viz.endLayer()
dots.setPosition(0, 0, 0)
dots.visible(1)
offset = viz.Matrix.euler(self.Trial_Camera_Offset, 0, 0)
viz.MainWindow.setViewOffset(offset) # counter rotates camera
self.blackscreen.visible(viz.OFF) #turn the mask
#2) give participant time with new flow field - might be extra important when manipulating flow field
yield viztask.waitTime(
2) #wait for one second after change of camera heading
# msg = msg + '\n' + 'Offset: ' + str(self.Trial_Camera_Offset) #Save your variables - COMMENT OUT FOR EXPERIMENT
# txtCondt.message(msg) # COMMENT OUT FOR EXPERIMENT
#3) Move straight to desired position
# Translate straight to driver position.
driverpos = viz.MainView.getPosition()
print(driverpos)
self.Straight.setPosition(driverpos[0], 0, driverpos[2])
# Match straight orientation to the driver
driverEuler = viz.MainView.getEuler(
) # gets current driver euler (orientation)
print("driverEuler", driverEuler) # prints the euler
self.Straight.setEuler(
driverEuler, viz.ABS_GLOBAL
) # then sets the straight euler as the driver euler in global coordinates.
# Offset the angle
offsetEuler = [trial_heading, 0,
0] # this creates the straight offset
self.Straight.setEuler(offsetEuler, viz.REL_LOCAL)
#will need to save initial vertex for line origin, and Euler. Is there a nifty way to save the relative position to the road?
#4) Reset set point and make the straight visible
self.Trial_setpoint = self.driver.reset_setpoint()
self.driver.setSWA_invisible() # sets SWA invisible on screen
self.Straight.visible(1)
#5) Wait for the trial time
yield viztask.waitTime(
self.VisibleRoadTime
) # add the road again. 2.5s to avoid ceiling effects.
#6) Remove straight
self.Straight.visible(0)
#7) remove dot flow - unsure whether this is the correct thing to do - might need standard level of flow that is then manipulated
dots.remove()
def checkCentred():
centred = False
x = self.driver.getPos()
if abs(x) < .1:
centred = True
return (centred)
##wait a while
#print "waiting"
#TODO: Recentre the wheel on automation.
#yield viztask.waitTrue(checkCentred)
#print "waited"
#loop has finished.
CloseConnections(self.EYETRACKING)
def diskCreator(node):
disks = viz.addGroup()
#Generate random values for position and orientation
disk_rad = 0.5
space_width = 80
disk_number = np.int_(
np.floor(0.2 * (space_width * space_width) / (4 * disk_rad)))
al_valu = 0.55
segment_no = 36
viz.startLayer(viz.POLYGON)
viz.pointSize(1)
for i in range(segment_no):
pt_z = disk_rad * math.cos(2 * math.pi * i / segment_no)
pt_x = disk_rad * math.sin(2 * math.pi * i / segment_no)
viz.vertex([pt_x, 0, pt_z])
disk = viz.endLayer()
a = np.arange(2 * disk_rad, space_width - 2 * disk_rad, 4 * disk_rad)
x = np.repeat(a, len(a)) - space_width / 2
z = np.tile(a, len(a)) - disk_rad
pool = np.vstack((x, z))
pool = np.transpose(pool)
ind = np.random.choice(len(pool), disk_number, replace=False)
noise = np.random.uniform(-disk_rad, disk_rad, (disk_number, 2))
positions = pool[ind, :] + noise
#disk=vizfx.addChild('disk.osgb')
for i in range(disk_number):
#Load a disk
if i < disk_number / 5:
d = disk.copy()
d.color(0, 0, 0.5)
d.alpha(al_valu) #Blue
elif disk_number / 5 <= i < 2 * disk_number / 5:
d = disk.copy()
d.color(0.55, 0, 0)
d.alpha(al_valu) #Red
elif 2 * disk_number / 5 <= i < 3 * disk_number / 5:
d = disk.copy()
d.color(1, 0.84, 0)
d.alpha(al_valu) #Yellow
elif 3 * disk_number / 5 <= i < 4 * disk_number / 5:
d = disk.copy()
d.color(0, 0.5, 0)
d.alpha(al_valu) #Green
elif 4 * disk_number / 5 <= i < disk_number:
d = disk.copy()
d.color(0.5, 0, 0.5)
d.alpha(al_valu) #Purple
#Set position, orientation, and state
d.setPosition([positions[i, 0], 0, positions[i, 1]])
d.zoffset(-1)
d.setParent(disks)
disk.remove()
disks.setParent(node)
return disks