def _resize_display(self, width, height):
"""Change the display size."""
maximised = sdl2.SDL_GetWindowFlags(
self.display) & sdl2.SDL_WINDOW_MAXIMIZED
# workaround for maximised state not reporting correctly (at least on Ubuntu Unity)
# detect if window is very large compared to screen; force maximise if so.
to_maximised = (width >= 0.95 * self.physical_size[0]
and height >= 0.9 * self.physical_size[1])
if not maximised:
if to_maximised:
# force maximise for large windows
sdl2.SDL_MaximizeWindow(self.display)
else:
# regular resize on non-maximised windows
sdl2.SDL_SetWindowSize(self.display, width, height)
else:
# resizing throws us out of maximised mode
if not to_maximised:
sdl2.SDL_RestoreWindow(self.display)
# get window size
w, h = ctypes.c_int(), ctypes.c_int()
sdl2.SDL_GetWindowSize(self.display, ctypes.byref(w), ctypes.byref(h))
self.window_width, self.window_height = w.value, h.value
self.display_surface = sdl2.SDL_GetWindowSurface(self.display)
self.screen_changed = True
def run():
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
window = sdl2.SDL_CreateWindow(b"Hello World", sdl2.SDL_WINDOWPOS_CENTERED,
sdl2.SDL_WINDOWPOS_CENTERED, 592, 460,
sdl2.SDL_WINDOW_SHOWN)
fname = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", "hello.bmp")
image = sdl2.SDL_LoadBMP(fname.encode("utf-8"))
windowsurface = sdl2.SDL_GetWindowSurface(window)
sdl2.SDL_BlitSurface(image, None, windowsurface, None)
sdl2.SDL_UpdateWindowSurface(window)
sdl2.SDL_FreeSurface(image)
running = True
event = sdl2.SDL_Event()
while running:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
break
sdl2.SDL_Delay(10)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
return 0
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Fireworks Demo",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED,
width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load Textures
texture = loadTexture(b'res/flare.bmp', gl.GL_ALPHA, gl.GL_REPEAT)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(0.001, 0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# the base system
self.basesystem = BaseSystem(self.height, texture)
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleY = 0.0
self.camPosZ = 5.0
self.spacePressed = -1.0
self.systems = []
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks()-1]
self.lasttime = self.frames[-1]
def showImage(image):
global windowArray, window
if windowArray is None:
sdl2.ext.init()
window = sdl2.ext.Window("test", size=(image.shape[0],image.shape[1]))
window.show()
windowSurf = sdl2.SDL_GetWindowSurface(window.window)
windowArray = sdl2.ext.pixels3d(windowSurf.contents)
numpy.copyto(windowArray, image)
window.refresh()
def stimDisplayMirrorChildFunction(qTo,
qFrom,
windowSize=[1920 / 2, 1080 / 2],
windowPosition=[0, 0]):
import sdl2
import sdl2.ext
import sys
import time
from PIL import Image #for image manipulation
try:
import appnope
appnope.nope()
except:
pass
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
window = sdl2.ext.Window("mirror",
size=windowSize,
position=windowPosition,
flags=sdl2.SDL_WINDOW_SHOWN)
windowID = sdl2.SDL_GetWindowID(window.window)
windowSurf = sdl2.SDL_GetWindowSurface(window.window)
windowArray = sdl2.ext.pixels3d(windowSurf.contents)
sdl2.ext.fill(windowSurf.contents,
sdl2.pixels.SDL_Color(r=255, g=255, b=255, a=255))
window.refresh()
for i in range(10):
sdl2.SDL_PumpEvents() #to show the windows
def exitSafely():
sys.exit()
while True:
if not qTo.empty():
message = qTo.get()
if message == 'quit':
exitSafely()
elif message[0] == 'frame':
# print ['q',time.time()-message[3]] #time spent in queue
res = message[1]
buffer = message[2]
image = Image.fromstring(mode="RGB", size=res, data=buffer)
image = image.transpose(Image.ROTATE_270)
# start = time.time()
# image.thumbnail([res[1]/2,res[0]/2],Image.LANCZOS)
# print ['resize',time.time()-start]
windowArray[:, :, 0:3] = image
window.refresh()
sdl2.SDL_PumpEvents()
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_WINDOWEVENT:
if (event.window.event == sdl2.SDL_WINDOWEVENT_CLOSE):
exitSafely()
def writerChildFunction(qTo,
qFrom,
windowSize=[200, 200],
windowPosition=[0, 0]):
import sdl2
import sdl2.ext
import sys
import time
try:
import appnope
appnope.nope()
except:
pass
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
window = sdl2.ext.Window("writer",
size=windowSize,
position=windowPosition,
flags=sdl2.SDL_WINDOW_SHOWN)
windowID = sdl2.SDL_GetWindowID(window.window)
windowSurf = sdl2.SDL_GetWindowSurface(window.window)
sdl2.ext.fill(windowSurf.contents,
sdl2.pixels.SDL_Color(r=255, g=255, b=255, a=255))
window.refresh()
for i in range(10):
sdl2.SDL_PumpEvents() #to show the windows
files = {}
def exitSafely():
try:
for index, fileObj in files.items():
fileObj.close()
# gpg -r "Michael Lawrence <*****@*****.**>" -e mac.txt
except:
pass
sys.exit()
while True:
if not qTo.empty():
message = qTo.get()
if message == 'quit':
exitSafely()
elif message[0] == 'newFile':
files[message[1]] = open(message[2], 'w')
elif message[0] == 'write':
files[message[1]].write(message[2] + '\n')
else:
time.sleep(1)
sdl2.SDL_PumpEvents()
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_WINDOWEVENT:
if (event.window.event == sdl2.SDL_WINDOWEVENT_CLOSE):
exitSafely()
def _do_create_window(self, width, height):
"""Create a new SDL window """
flags = sdl2.SDL_WINDOW_RESIZABLE | sdl2.SDL_WINDOW_SHOWN
if self.fullscreen:
flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP | sdl2.SDL_WINDOW_BORDERLESS
sdl2.SDL_DestroyWindow(self.display)
self.display = sdl2.SDL_CreateWindow(self.caption,
sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED,
width, height, flags)
self._set_icon()
self.display_surface = sdl2.SDL_GetWindowSurface(self.display)
self.screen_changed = True
self.window_width, self.window_height = width, height
def __init__(self):
self.windowSize = (960, 720)
# initialize sdl2 game window
sdl2.ext.init()
self.window = sdl2.ext.Window("test", size=self.windowSize)
self.window.show()
windowSurf = sdl2.SDL_GetWindowSurface(self.window.window)
self.windowArray = sdl2.ext.pixels3d(windowSurf.contents)
self.image = None
# Init Tello object that interacts with the Tello drone
self.drone = Drone()
self.mode = None
self.yolo_initialized = False
self.tracker_initialized = False
self.face_finder_initialized = False
self.FPS = 25
self.follow_obj = "person"
self.yolo_tracker_sync_time = 4 # time to run yolo once every _3_ sec
self.yolo_tracker_last_sync = time.time()
logger.info("Game Initialized")
def show(self):
# Init video
global HAS_INIT_SDL_VIDEO
if not HAS_INIT_SDL_VIDEO:
self._no_error(sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO))
else:
HAS_INIT_SDL_VIDEO = True
# Create window
self._window = self._no_null(
sdl2.SDL_CreateWindow(b"FGAme Game", sdl2.SDL_WINDOWPOS_CENTERED,
sdl2.SDL_WINDOWPOS_CENTERED, self.width,
self.height, sdl2.SDL_WINDOW_SHOWN))
self._surface = sdl2.SDL_GetWindowSurface(self._window)
# Create a renderer
# flags = sdl2.SDL_RENDERER_SOFTWARE
# flags = sdl2.SDL_RENDERER_ACCELERATED
# flags = sdl2.SDL_RENDERER_PRESENTVSYNC
flags = sdl2.SDL_RENDERER_ACCELERATED | sdl2.SDL_RENDERER_PRESENTVSYNC
self._renderer = self._no_null(
sdl2.SDL_CreateRenderer(self._window, -1, flags))
# Create a rect instance that stores the window shape
self._screen_rect = self._no_null(
sdl2.SDL_Rect(x=0, y=0, w=self.width, h=self.height))
# Saves background color
if self.background is not None:
R, B, G, A = Color(self.background)
self._bg_color = (R << 24) + (G << 16) + (B << 8) + A
else:
self._bg_color = None
self._LP_short = gfx.aapolygonRGBA.argtypes[1]
# Flip image
self.flip()
def labjackChildFunction(qTo,
qFrom,
windowSize=[200, 200],
windowPosition=[0, 0]):
import sdl2
import sdl2.ext
import sys
import time
try:
import appnope
appnope.nope()
except:
pass
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
window = sdl2.ext.Window("labjack",
size=windowSize,
position=windowPosition,
flags=sdl2.SDL_WINDOW_SHOWN)
windowID = sdl2.SDL_GetWindowID(window.window)
windowSurf = sdl2.SDL_GetWindowSurface(window.window)
sdl2.ext.fill(windowSurf.contents,
sdl2.pixels.SDL_Color(r=255, g=255, b=255, a=255))
window.refresh()
for i in range(10):
sdl2.SDL_PumpEvents() #to show the windows
import u3
d = u3.U3()
d.configU3()
d.getCalibrationData()
d.configAnalog(u3.FIO0)
checkForNextZeroTime = False
checkForTrialNextZeroTime = False
def exitSafely():
d.close()
sys.exit()
sendTriggers = False
while True:
if sendTriggers:
if not checkForNextZeroTime:
temp = d.getAIN(0)
# print temp
if temp > .5: #photosensor surpasses criterion
d.getFeedback(u3.BitStateWrite(IONumber=8, State=1))
nextZeroTime = time.time(
) + .010 #wait 10ms before setting the state back to zero, giving the amp time to pick it up
checkForNextZeroTime = True
else:
if time.time() >= nextZeroTime: #time to turn the bit back off
d.getFeedback(u3.BitStateWrite(IONumber=8, State=0))
checkForNextZeroTime = False
if checkForTrialNextZeroTime:
if time.time() >= trialNextZeroTime:
d.getFeedback(u3.BitStateWrite(IONumber=9, State=0))
checkForTrialNextZeroTime = False
if not qTo.empty():
message = qTo.get()
if message == 'quit':
exitSafely()
elif message == 'trialDone':
sendTriggers = False
checkForTrialNextZeroTime = False
checkForNextZeroTime = False
d.getFeedback(u3.BitStateWrite(
IONumber=8, State=0)) #should be zero, but just in case...
d.getFeedback(u3.BitStateWrite(
IONumber=9, State=0)) #should be zero, but just in case...
elif message == 'trialStart':
sendTriggers = True
d.getFeedback(u3.BitStateWrite(IONumber=9, State=1))
trialNextZeroTime = time.time(
) + .010 #wait 10ms before setting the state back to zero, giving the amp time to pick it up
checkForTrialNextZeroTime = True
sdl2.SDL_PumpEvents()
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_WINDOWEVENT:
if (event.window.event == sdl2.SDL_WINDOWEVENT_CLOSE):
exitSafely()
def eyelinkChildFunction(qTo,
qFrom,
windowSize=[200, 200],
windowPosition=[0, 0],
stimDisplayRes=[1920, 1080],
calibrationDisplaySize=[1920, 1080],
calibrationDotSize=10,
eyelinkIp='100.1.1.1',
edfFileName='temp.edf',
edfPath='./_Data/temp.edf',
saccadeSoundFile='_Stimuli/stop.wav',
blinkSoundFile='_Stimuli/stop.wav'):
import sdl2
import sdl2.ext
import math
import OpenGL.GL as gl
import sdl2.sdlmixer
import pylink
import numpy
import sys
import shutil
import subprocess
import time
import os
import array
from PIL import Image
from PIL import ImageDraw
try:
import appnope
appnope.nope()
except:
pass
byteify = lambda x, enc: x.encode(enc)
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
window = sdl2.ext.Window("eyelink",
size=windowSize,
position=windowPosition,
flags=sdl2.SDL_WINDOW_SHOWN)
windowID = sdl2.SDL_GetWindowID(window.window)
windowSurf = sdl2.SDL_GetWindowSurface(window.window)
sdl2.ext.fill(windowSurf.contents,
sdl2.pixels.SDL_Color(r=0, g=0, b=0, a=255))
window.refresh()
for i in range(10):
sdl2.SDL_PumpEvents() #to show the windows
sdl2.SDL_Init(sdl2.SDL_INIT_AUDIO)
sdl2.sdlmixer.Mix_OpenAudio(44100, sdl2.sdlmixer.MIX_DEFAULT_FORMAT, 2,
1024)
class Sound:
def __init__(self, fileName):
self.sample = sdl2.sdlmixer.Mix_LoadWAV(
sdl2.ext.compat.byteify(fileName, "utf-8"))
self.started = False
def play(self):
self.channel = sdl2.sdlmixer.Mix_PlayChannel(-1, self.sample, 0)
self.started = True
def stillPlaying(self):
if self.started:
if sdl2.sdlmixer.Mix_Playing(self.channel):
return True
else:
self.started = False
return False
else:
return False
saccadeSound = Sound(saccadeSoundFile)
blinkSound = Sound(blinkSoundFile)
def exitSafely():
if 'eyelink' in locals():
if eyelink.isRecording() == 0:
eyelink.stopRecording()
eyelink.setOfflineMode()
eyelink.closeDataFile()
eyelink.receiveDataFile(edfFileName, 'temp.edf')
eyelink.close()
if os.path.isfile('temp.edf'):
shutil.move('temp.edf', edfPath)
# if os.path.isfile(edfPath):
# subprocess.call('./edf2asc -y ./'+edfPath,shell=True)
sys.exit(
) #process gets hung here if called when showing images from eyelink
pylink.setDriftCorrectSounds('off', 'off', 'off')
pylink.setCalibrationSounds('off', 'off', 'off')
edfPath = './_Data/temp.edf' #temporary default location, to be changed later when ID is established
done = False
while not done:
try:
# print '\neyelink: Attempting to connect to eyelink (check that wifi is off!)'
eyelink = pylink.EyeLink(eyelinkIp)
done = True
except:
while not qTo.empty():
message = qTo.get()
if message == 'quit':
exitSafely()
else:
qTo.put(message)
# print 'eyelink: connected'
eyelink.sendCommand(
'select_parser_configuration 0'
) # 0--> standard (cognitive); 1--> sensitive (psychophysical)
# eyelink.sendCommand('sample_rate 500')
eyelink.setLinkEventFilter("SACCADE,BLINK,FIXATION,LEFT,RIGHT")
eyelink.openDataFile(edfFileName)
eyelink.sendCommand(
"screen_pixel_coords = %d %d %d %d" %
(stimDisplayRes[0] / 2 - calibrationDisplaySize[0] / 2,
stimDisplayRes[1] / 2 - calibrationDisplaySize[1] / 2,
stimDisplayRes[0] / 2 + calibrationDisplaySize[0] / 2,
stimDisplayRes[1] / 2 + calibrationDisplaySize[1] / 2))
eyelink.sendMessage("DISPLAY_COORDS 0 0 %d %d" %
(stimDisplayRes[0], stimDisplayRes[1]))
eyelink.sendCommand("saccade_velocity_threshold = 60")
eyelink.sendCommand("saccade_acceleration_threshold = 19500")
class EyeLinkCoreGraphicsPySDL2(pylink.EyeLinkCustomDisplay):
def __init__(self):
# self.__target_beep__ = Sound('_Stimuli/type.wav')
# self.__target_beep__done__ = Sound('qbeep.wav')
# self.__target_beep__error__ = Sound('error.wav')
if sys.byteorder == 'little':
self.byteorder = 1
else:
self.byteorder = 0
self.imagebuffer = array.array('I')
self.pal = None
self.__img__ = None
def record_abort_hide(self):
pass
def play_beep(self, beepid):
pass
# if beepid == pylink.DC_TARG_BEEP or beepid == pylink.CAL_TARG_BEEP:
# self.__target_beep__.play()
# elif beepid == pylink.CAL_ERR_BEEP or beepid == pylink.DC_ERR_BEEP:
# self.__target_beep__error__.play()
# else:# CAL_GOOD_BEEP or DC_GOOD_BEEP
# self.__target_beep__done__.play()
def clear_cal_display(self):
# # print 'clear_cal_display'
qFrom.put('clearCalDisplay')
def setup_cal_display(self):
# # print 'setup_cal_display'
qFrom.put('setupCalDisplay')
def exit_cal_display(self):
# # print 'exit_cal_display'
qFrom.put('exitCalDisplay')
def erase_cal_target(self):
# # print 'erase_cal_target'
qFrom.put('eraseCalTarget')
def draw_cal_target(self, x, y):
# # print 'draw_cal_target'
qFrom.put(['drawCalTarget', x, y])
def setup_image_display(self, width, height):
# # print 'eyelink: setup_image_display'
self.img_size = (width, height)
return (0)
def exit_image_display(self):
# # print 'eyelink: exit_image_display'
pass
def image_title(self, text):
# # print 'eyelink: image_title'
pass
def set_image_palette(self, r, g, b):
# # print 'eyelink: set_image_palette'
self.imagebuffer = array.array('I')
sz = len(r)
i = 0
self.pal = []
while i < sz:
rf = int(b[i])
gf = int(g[i])
bf = int(r[i])
if self.byteorder:
self.pal.append((rf << 16) | (gf << 8) | (bf))
else:
self.pal.append(
(bf << 24) | (gf << 16) | (rf << 8)) #for mac
i = i + 1
def draw_image_line(self, width, line, totlines, buff):
# # print 'eyelink: draw_image_line'
i = 0
while i < width:
if buff[i] >= len(self.pal):
buff[i] = len(self.pal) - 1
self.imagebuffer.append(self.pal[buff[i] & 0x000000FF])
i = i + 1
if line == totlines:
img = Image.fromstring('RGBX', (width, totlines),
self.imagebuffer.tostring())
img = img.convert('RGBA')
self.__img__ = img.copy()
self.__draw__ = ImageDraw.Draw(self.__img__)
self.draw_cross_hair(
) #inherited method, calls draw_line and draw_losenge
qFrom.put([
'image',
numpy.array(
self.__img__.resize([
self.__img__.size[0] * 4, self.__img__.size[1] * 4
], Image.BICUBIC))
])
self.__img__ = None
self.__draw__ = None
self.imagebuffer = array.array('I')
def getColorFromIndex(self, colorindex):
if colorindex == pylink.CR_HAIR_COLOR: return (255, 255, 255, 255)
elif colorindex == pylink.PUPIL_HAIR_COLOR:
return (255, 255, 255, 255)
elif colorindex == pylink.PUPIL_BOX_COLOR:
return (0, 255, 0, 255)
elif colorindex == pylink.SEARCH_LIMIT_BOX_COLOR:
return (255, 0, 0, 255)
elif colorindex == pylink.MOUSE_CURSOR_COLOR:
return (255, 0, 0, 255)
else:
return (0, 0, 0, 0)
def draw_line(self, x1, y1, x2, y2, colorindex):
# # print 'eyelink: draw_line'
if x1 < 0: x1 = 0
if x2 < 0: x2 = 0
if y1 < 0: y1 = 0
if y2 < 0: y2 = 0
if x1 > self.img_size[0]: x1 = self.img_size[0]
if x2 > self.img_size[0]: x2 = self.img_size[0]
if y1 > self.img_size[1]: y1 = self.img_size[1]
if y2 > self.img_size[1]: y2 = self.img_size[1]
imr = self.__img__.size
x1 = int((float(x1) / float(self.img_size[0])) * imr[0])
x2 = int((float(x2) / float(self.img_size[0])) * imr[0])
y1 = int((float(y1) / float(self.img_size[1])) * imr[1])
y2 = int((float(y2) / float(self.img_size[1])) * imr[1])
color = self.getColorFromIndex(colorindex)
self.__draw__.line([(x1, y1), (x2, y2)], fill=color)
return 0
def draw_lozenge(self, x, y, width, height, colorindex):
# # print 'eyelink: draw_lozenge'
color = self.getColorFromIndex(colorindex)
imr = self.__img__.size
x = int((float(x) / float(self.img_size[0])) * imr[0])
width = int((float(width) / float(self.img_size[0])) * imr[0])
y = int((float(y) / float(self.img_size[1])) * imr[1])
height = int((float(height) / float(self.img_size[1])) * imr[1])
if width > height:
rad = height / 2
self.__draw__.line([(x + rad, y), (x + width - rad, y)],
fill=color)
self.__draw__.line([(x + rad, y + height),
(x + width - rad, y + height)],
fill=color)
clip = (x, y, x + height, y + height)
self.__draw__.arc(clip, 90, 270, fill=color)
clip = ((x + width - height), y, x + width, y + height)
self.__draw__.arc(clip, 270, 90, fill=color)
else:
rad = width / 2
self.__draw__.line([(x, y + rad), (x, y + height - rad)],
fill=color)
self.__draw__.line([(x + width, y + rad),
(x + width, y + height - rad)],
fill=color)
clip = (x, y, x + width, y + width)
self.__draw__.arc(clip, 180, 360, fill=color)
clip = (x, y + height - width, x + width, y + height)
self.__draw__.arc(clip, 360, 180, fill=color)
return 0
def get_mouse_state(self):
# pos = pygame.mouse.get_pos()
# state = pygame.mouse.get_pressed()
# return (pos,state[0])
pass
def get_input_key(self):
ky = []
while not qTo.empty():
message = qTo.get()
# print 'eyelink: '
# print message
if message == 'button':
ky.append(
pylink.KeyInput(32, 0)
) #button translated to space keypress (for drift correct)
# if message=='quit':
# # print 'received message to exit'
# exitSafely()
# el
elif message[0] == 'keycode':
keysym = message[1]
keycode = keysym.sym
if keycode == sdl2.SDLK_F1: keycode = pylink.F1_KEY
elif keycode == sdl2.SDLK_F2: keycode = pylink.F2_KEY
elif keycode == sdl2.SDLK_F3: keycode = pylink.F3_KEY
elif keycode == sdl2.SDLK_F4: keycode = pylink.F4_KEY
elif keycode == sdl2.SDLK_F5: keycode = pylink.F5_KEY
elif keycode == sdl2.SDLK_F6: keycode = pylink.F6_KEY
elif keycode == sdl2.SDLK_F7: keycode = pylink.F7_KEY
elif keycode == sdl2.SDLK_F8: keycode = pylink.F8_KEY
elif keycode == sdl2.SDLK_F9: keycode = pylink.F9_KEY
elif keycode == sdl2.SDLK_F10: keycode = pylink.F10_KEY
elif keycode == sdl2.SDLK_PAGEUP: keycode = pylink.PAGE_UP
elif keycode == sdl2.SDLK_PAGEDOWN:
keycode = pylink.PAGE_DOWN
elif keycode == sdl2.SDLK_UP:
keycode = pylink.CURS_UP
elif keycode == sdl2.SDLK_DOWN:
keycode = pylink.CURS_DOWN
elif keycode == sdl2.SDLK_LEFT:
keycode = pylink.CURS_LEFT
elif keycode == sdl2.SDLK_RIGHT:
keycode = pylink.CURS_RIGHT
elif keycode == sdl2.SDLK_BACKSPACE:
keycode = ord('\b')
elif keycode == sdl2.SDLK_RETURN:
keycode = pylink.ENTER_KEY
elif keycode == sdl2.SDLK_ESCAPE:
keycode = pylink.ESC_KEY
elif keycode == sdl2.SDLK_TAB:
keycode = ord('\t')
elif keycode == pylink.JUNK_KEY:
keycode = 0
ky.append(pylink.KeyInput(keycode, keysym.mod))
return ky
customDisplay = EyeLinkCoreGraphicsPySDL2()
pylink.openGraphicsEx(customDisplay)
newGazeTarget = False
gazeTarget = numpy.array(calibrationDisplaySize) / 2.0
gazeTargetCriterion = calibrationDotSize
doSounds = False
reportSaccades = False
reportBlinks = False
lastMessageTime = time.time()
lastStartBlinkTime = time.time()
while True:
sdl2.SDL_PumpEvents()
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_WINDOWEVENT:
if (event.window.event == sdl2.SDL_WINDOWEVENT_CLOSE):
exitSafely()
if not qTo.empty():
message = qTo.get()
if message == 'quit':
exitSafely()
elif message[0] == 'edfPath':
edfPath = message[1]
elif message[0] == 'doSounds':
doSounds = message[1]
elif message[0] == 'reportSaccades':
reportSaccades = message[1]
elif message[0] == 'reportBlinks':
reportBlinks = message[1]
elif message[0] == 'sendMessage':
eyelink.sendMessage(message[1])
elif message[0] == 'doDriftCorrect':
# print 'eyelink: drift correct requested'
if eyelink.isRecording() == 0:
eyelink.stopRecording()
try:
location = message[1]
error = eyelink.doDriftCorrect(location[0], location[1], 0,
1)
# print error
# print 'eyelink: drift correct attempted'
if error != 27:
qFrom.put('driftCorrectComplete')
else:
qFrom.put('doCalibration')
except:
qFrom.put('doCalibration')
elif message == 'startRecording':
# print 'eyelink: received message to begin recording'
eyelink.startRecording(
1, 1, 1, 1
) #this retuns immediately takes 10-30ms to actually kick in on the tracker
while not (eyelink.isRecording() == 0):
pass
# print eyelink.isRecording()
qFrom.put('recordingStarted')
elif message[0] == 'newGazeTarget':
# # print message
newGazeTarget = True
gazeTarget = numpy.array(message[1])
gazeTargetCriterion = numpy.array(message[2])
# # print message
# # print 'waiting for gaze confirmation'
elif message[0] == 'acceptTrigger':
eyelink.accept_trigger()
elif message == 'doCalibration':
doSounds = False
if eyelink.isRecording() == 0:
eyelink.stopRecording()
eyelink.doTrackerSetup()
# # print 'calComplete'
qFrom.put('calibrationComplete')
if eyelink.isRecording(
) == 0: #stupid, I know, but eyelink.isRecording() returns 0 if it *is* indeed recording!
eyeData = eyelink.getNextData()
# if eyeData==pylink.SAMPLE_TYPE:
# eyeSample = eyelink.getFloatData()
# gaze = None
# if eyeSample.isRightSample():
# gaze = eyeSample.getRightEye().getGaze()
# elif eyeSample.isLeftSample():
# gaze = eyeSample.getLeftEye().getGaze()
# if gaze!=None:
# if gaze[0]!=-32768.0:
# gazeDistFromGazeTarget = numpy.linalg.norm(numpy.array(gaze)-gazeTarget)
# if newGazeTarget:
# if gazeDistFromGazeTarget<gazeTargetCriterion:
# # print ['gazeTargetMet',gaze,gazeTargetCriterion,gazeTarget,gazeDistFromGazeTarget]
# qFrom.put(['gazeTargetMet',gazeTarget])
# newGazeTarget = False
# else:
# qFrom.put(['gazeTargetNotMet',gazeTarget])
# # print ['gazeTargetNotMet',gaze,gazeTarget,gazeDistFromGazeTarget,gazeTargetCriterion]
if eyeData == pylink.ENDSACC:
eyeSample = eyelink.getFloatData()
gazeStartTime = eyeSample.getStartTime()
gazeStart = eyeSample.getStartGaze()
gazeEnd = eyeSample.getEndGaze()
# # print ['eyelink: saccade',gazeStart,gazeEnd]
if (gazeStart[0] != -32768.0) & (gazeEnd[0] != -32768.0):
gazeDistFromGazeTarget = numpy.linalg.norm(
numpy.array(gazeEnd) - gazeTarget)
if gazeDistFromGazeTarget < 1000:
if newGazeTarget:
# # print [gazeDistFromGazeTarget,gazeTargetCriterion,gazeTarget,gazeEnd]
if gazeDistFromGazeTarget < gazeTargetCriterion:
# # print ['gazeTargetMet',gazeEnd,gazeTargetCriterion,gazeTarget,gazeDistFromGazeTarget]
qFrom.put([
'gazeTargetMet', gazeTarget, gazeStartTime
])
newGazeTarget = False
# # print 'gazeTargetMet'
elif gazeDistFromGazeTarget > gazeTargetCriterion:
if reportSaccades:
qFrom.put(['gazeTargetLost', gazeTarget])
# # print ['gazeTargetLost',gazeTarget]
if (not saccadeSound.stillPlaying()) and (
not blinkSound.stillPlaying()):
if doSounds:
saccadeSound.play()
elif eyeData == pylink.STARTBLINK:
# lastStartBlinkTime = time.time()
# elif eyeData==pylink.ENDBLINK:
# if (time.time()-lastStartBlinkTime)>.1:
if reportBlinks:
qFrom.put('blink')
# # print 'eyelink: blink'
if (not saccadeSound.stillPlaying()) and (
not blinkSound.stillPlaying()):
if doSounds:
#blinkSound.play()
qFrom.put('blink')
"""
Gets details of window position by title text. [Windows Only]
"""
def _window_callback(hwnd, all_windows):
all_windows.append((hwnd, win32gui.GetWindowText(hwnd)))
windows = []
win32gui.EnumWindows(_window_callback, windows)
if exact:
return [hwnd for hwnd, title in windows if title_text == title]
else:
return [hwnd for hwnd, title in windows if title_text in title]
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
#window_handle = get_windows_bytitle("Dwarf Fortress", True)
window_handle = get_windows_bytitle("Untitled", False)
df_window = sdl2.SDL_CreateWindowFrom(window_handle[0])
df_sur = sdl2.SDL_GetWindowSurface(df_window)
save_sur = sdl2.SDL_CreateRGBSurface(0, df_sur[0].w, df_sur[0].h, 32, 0, 0, 0,
0)
#result = sdl2.SDL_SaveBMP(save_sur,'test.bmp')
result = sdl2.SDL_SaveBMP(df_sur, 'test.bmp')
print result
sdl2.SDL_FreeSurface(df_sur)
print(sdl2.SDL_GetError())
sys.exit()
else:
print('mode 2: basic rgb rendering (slow)...')
# mode 2
m.addScaler(vstream, *size)
else:
print('mode 3: software rendering (very slow)...')
# mode 3
m.addScaler(vstream, *size)
sdl2.SDL_DestroyRenderer(renderer)
windowSurface = sdl2.SDL_GetWindowSurface(window)
print('Press Esc to quit...')
running = True
event = sdl2.SDL_Event()
while running:
# process events...
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
keySim = event.key.keysym.sym
if (event.type == sdl2.SDL_KEYDOWN and keySim == sdl2.SDLK_ESCAPE) or\
event.type == sdl2.SDL_QUIT:
running = False
break
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Galaxy Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
gl.glEnable(gl.GL_DEPTH_TEST)
# load Textures
texture = loadTexture(b'res/flare.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useRealStep() # no adjustment
# create Renderer
renderer = GLQuadRenderer.create() # type: GLQuadRenderer
renderer.setTexturingMode(spk.TEXTURE_2D)
renderer.setTexture(texture)
renderer.setTextureBlending(gl.GL_MODULATE)
renderer.setScale(0.05, 0.05)
renderer.setBlending(spk.BLENDING_ADD)
renderer.enableRenderingHint(spk.DEPTH_WRITE, False)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
galaxy_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_SIZE
galaxy_mutable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE
galaxy_random = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_SIZE
galaxy_interpolated = spk.FLAG_ALPHA
galaxyModel = spk.Model.create(galaxy_enable, galaxy_mutable,
galaxy_random,
galaxy_interpolated) # type: spk.Model
galaxyModel.setParam(spk.PARAM_RED, 0.0, 0.3, 0.5, 0.5)
galaxyModel.setParam(spk.PARAM_GREEN, 0.0, 0.3, 0.5, 0.5)
galaxyModel.setParam(spk.PARAM_BLUE, 1.0, 0.1)
galaxyModel.setParam(spk.PARAM_SIZE, 0.1, 5.0)
galaxyModel.setLifeTime(35.0, 40.0)
ip_alpha = galaxyModel.getInterpolator(spk.PARAM_ALPHA)
ip_alpha.addEntry(0.0, 0.0)
ip_alpha.addEntry(0.95, 0.6, 1.0)
ip_alpha.addEntry(1.0, 0.0)
star_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_SIZE
star_mutable = spk.FLAG_NONE
star_random = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_ALPHA | spk.FLAG_SIZE
starModel = spk.Model.create(star_enable, star_mutable,
star_random) # type: spk.Model
starModel.setParam(spk.PARAM_RED, 0.8, 1.0)
starModel.setParam(spk.PARAM_GREEN, 0.4, 1.0)
starModel.setParam(spk.PARAM_BLUE, 0.8, 1.0)
starModel.setParam(spk.PARAM_ALPHA, 0.2, 1.0)
starModel.setParam(spk.PARAM_SIZE, 0.1, 5.0)
starModel.setImmortal(True)
# create Emitter
# 2 emitters in diagonal lines on Y=0 plane
lineEmitter1 = spk.RandomEmitter.create() # type: spk.RandomEmitter
lineEmitter1.setZone(
spk.Line.create(spk.Vector3D(-2.5, 0.0, -2.5),
spk.Vector3D(2.5, 0.0, 2.5)))
lineEmitter1.setFlow(100)
lineEmitter1.setForce(0.0, 0.01)
lineEmitter2 = spk.RandomEmitter.create()
lineEmitter2.setZone(
spk.Line.create(spk.Vector3D(-2.5, 0.0, 2.5),
spk.Vector3D(2.5, 0.0, -2.5)))
lineEmitter2.setFlow(100)
lineEmitter2.setForce(0.0, 0.01)
# create Modifier
vortex = spk.Vortex.create() # type: spk.Vortex
vortex.setRotationSpeed(0.4,
False) # True->[rad/sec], False->[unit/src]
vortex.setAttractionSpeed(0.04, True)
vortex.setEyeRadius(0.05)
vortex.enableParticleKilling(True) # kill attracted particles
# create Group
galaxyGroup = spk.Group.create(galaxyModel, 8000) # type: spk.Group
galaxyGroup.addEmitter(lineEmitter1)
galaxyGroup.addEmitter(lineEmitter2)
galaxyGroup.setRenderer(renderer)
galaxyGroup.addModifier(vortex)
self.galaxyGroup = galaxyGroup
starGroup = spk.Group.create(starModel, 1000)
starGroup.setRenderer(renderer)
skySphere = spk.Sphere(spk.Vector3D(), 16.0)
starGroup.addParticles(1000,
zone=skySphere,
velocity=spk.Vector3D(),
full=False)
starGroup.flushAddedParticles()
# create System
galaxySystem = spk.System.create() # type: spk.System
galaxySystem.addGroup(galaxyGroup)
self.galaxySystem = galaxySystem
starSystem = spk.System.create()
starSystem.addGroup(starGroup)
self.starSystem = starSystem
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.angleY = 0.0
self.angleX = 45.0
self.camPosZ = 5.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def calibrationChildFunction(qTo,
qFrom,
viewingDistance=100,
stimDisplayWidth=100,
stimDisplayRes=(2560, 1440),
stimDisplayPosition=(-2560, 0),
mirrorDisplayPosition=(0, 0),
calibrationDotSizeInDegrees=1,
timestampMethod=0,
mirrorDownSize=2,
manualCalibrationOrder=True):
import numpy #for image and display manipulation
import scipy.misc #for image and display manipulation
import math #for trig and other math stuff
import sys #for quitting
import sdl2
import sdl2.ext
import random
#set the getTime function
if (timestampMethod == 0) or (timestampMethod == 1):
#initialize timer
sdl2.SDL_Init(sdl2.SDL_INIT_TIMER)
if timestampMethod == 0:
#define a function to use the high-precision timer, returning a float in seconds
def getTime():
return sdl2.SDL_GetPerformanceCounter(
) * 1.0 / sdl2.SDL_GetPerformanceFrequency()
elif timestampMethod == 1:
#use the SDL_GetTicks timer
def getTime():
return sdl2.SDL_GetTicks() / 1000.0
elif timestampMethod == 2:
#use time.time()
import time
getTime = time.time
#initialize video
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
sdl2.SDL_SetHint("SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS", "0")
mirrorDisplay = sdl2.ext.Window("Mirror",
size=(stimDisplayRes[0] / mirrorDownSize,
stimDisplayRes[1] / mirrorDownSize),
position=mirrorDisplayPosition,
flags=sdl2.SDL_WINDOW_SHOWN)
mirrorDisplaySurf = sdl2.SDL_GetWindowSurface(mirrorDisplay.window)
mirrorDisplayArray = sdl2.ext.pixels3d(mirrorDisplaySurf.contents)
# stimDisplay = sdl2.ext.Window("Calibration",size=stimDisplayRes,position=stimDisplayPosition,flags=sdl2.SDL_WINDOW_SHOWN|sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP|sdl2.SDL_RENDERER_ACCELERATED | sdl2.SDL_RENDERER_PRESENTVSYNC)
stimDisplay = sdl2.ext.Window(
"Calibration",
size=stimDisplayRes,
position=stimDisplayPosition,
flags=sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_BORDERLESS
| sdl2.SDL_RENDERER_ACCELERATED | sdl2.SDL_RENDERER_PRESENTVSYNC)
stimDisplaySurf = sdl2.SDL_GetWindowSurface(stimDisplay.window)
stimDisplayArray = sdl2.ext.pixels3d(stimDisplaySurf.contents)
sdl2.SDL_PumpEvents() #to show the windows
sdl2.SDL_PumpEvents() #to show the windows
sdl2.SDL_PumpEvents() #to show the windows
sdl2.SDL_PumpEvents() #to show the windows
sdl2.SDL_PumpEvents() #to show the windows
sdl2.SDL_PumpEvents() #to show the windows
########
#Perform some calculations to convert stimulus measurements in degrees to pixels
########
stimDisplayWidthInDegrees = math.degrees(
math.atan((stimDisplayWidth / 2.0) / viewingDistance) * 2)
PPD = stimDisplayRes[
0] / stimDisplayWidthInDegrees #compute the pixels per degree (PPD)
calibrationDotSize = int(calibrationDotSizeInDegrees * PPD)
#initialize font
sdl2.sdlttf.TTF_Init()
font = sdl2.sdlttf.TTF_OpenFont('./pytracker/Resources/DejaVuSans.ttf',
int(PPD) * 2)
########
# Define some useful colors for SDL2
########
white = sdl2.pixels.SDL_Color(r=255, g=255, b=255, a=255)
black = sdl2.pixels.SDL_Color(r=0, g=0, b=0, a=255)
grey = sdl2.pixels.SDL_Color(r=127, g=127, b=127, a=255)
lightGrey = sdl2.pixels.SDL_Color(r=200, g=200, b=200, a=255)
def drawDot(loc):
cy, cx = loc
cx = stimDisplayRes[1] / 2 + cx
cy = stimDisplayRes[0] / 2 + cy
radius = calibrationDotSize / 2
y, x = numpy.ogrid[-radius:radius, -radius:radius]
index = numpy.logical_and((x**2 + y**2) <= (radius**2),
(x**2 + y**2) >= ((radius / 4)**2))
stimDisplayArray[(cy - radius):(cy + radius),
(cx - radius):(cx + radius), ][index] = [
255, 255, 255, 255
]
calibrationLocations = dict()
calibrationLocations['CENTER'] = numpy.array([0, 0])
calibrationLocations['N'] = numpy.array(
[0, int(0 - stimDisplayRes[1] / 2.0 + calibrationDotSize)])
calibrationLocations['S'] = numpy.array(
[0, int(0 + stimDisplayRes[1] / 2.0 - calibrationDotSize)])
calibrationLocations['E'] = numpy.array(
[int(0 - stimDisplayRes[0] / 2.0 + calibrationDotSize), 0])
calibrationLocations['W'] = numpy.array(
[int(0 + stimDisplayRes[0] / 2.0 - calibrationDotSize), 0])
calibrationLocations['NE'] = numpy.array([
int(0 + stimDisplayRes[0] / 2.0 - calibrationDotSize),
int(0 - stimDisplayRes[1] / 2.0 + calibrationDotSize)
])
calibrationLocations['SE'] = numpy.array([
int(0 + stimDisplayRes[0] / 2.0 - calibrationDotSize),
int(0 + stimDisplayRes[1] / 2.0 - calibrationDotSize)
])
calibrationLocations['NW'] = numpy.array([
int(0 - stimDisplayRes[0] / 2.0 + calibrationDotSize),
int(0 - stimDisplayRes[1] / 2.0 + calibrationDotSize)
])
calibrationLocations['SW'] = numpy.array([
int(0 - stimDisplayRes[0] / 2.0 + calibrationDotSize),
int(0 + stimDisplayRes[1] / 2.0 - calibrationDotSize)
])
calibrationKey = {
'q': 'NW',
'w': 'N',
'e': 'NE',
'a': 'E',
's': 'CENTER',
'd': 'W',
'z': 'SW',
'x': 'S',
'c': 'SE'
}
# calibrationLocations['N2'] = numpy.array([0,int((0-stimDisplayRes[1]/2.0+calibrationDotSize)/2.0)])
# calibrationLocations['S2'] = numpy.array([0,int((0+stimDisplayRes[1]/2.0-calibrationDotSize)/2.0)])
# calibrationLocations['W2'] = numpy.array([int((0-stimDisplayRes[0]/2.0+calibrationDotSize)/2.0),0])
# calibrationLocations['E2'] = numpy.array([int((0+stimDisplayRes[0]/2.0-calibrationDotSize)/2.0),0])
# calibrationLocations['NE2'] = numpy.array([int((0+stimDisplayRes[0]/2.0-calibrationDotSize)/2.0),int((0-stimDisplayRes[1]/2.0+calibrationDotSize)/2.0)])
# calibrationLocations['SE2'] = numpy.array([int((0+stimDisplayRes[0]/2.0-calibrationDotSize)/2.0),int((0+stimDisplayRes[1]/2.0-calibrationDotSize)/2.0)])
# calibrationLocations['NW2'] = numpy.array([int((0-stimDisplayRes[0]/2.0+calibrationDotSize)/2.0),int((0-stimDisplayRes[1]/2.0+calibrationDotSize)/2.0)])
# calibrationLocations['SW2'] = numpy.array([int((0-stimDisplayRes[0]/2.0+calibrationDotSize)/2.0),int((0+stimDisplayRes[1]/2.0-calibrationDotSize)/2.0)])
#define a function that will kill everything safely
def exitSafely():
qFrom.put(['stopQueing', getTime()])
sdl2.ext.quit()
sys.exit()
#define a function that waits for a given duration to pass
def simpleWait(duration):
start = getTime()
while getTime() < (start + duration):
sdl2.SDL_PumpEvents()
#define a function to draw a numpy array on surface centered on given coordinates
def blitArray(src, dst, xOffset=0, yOffset=0):
x1 = dst.shape[0] / 2 + xOffset - src.shape[0] / 2
y1 = dst.shape[1] / 2 + yOffset - src.shape[1] / 2
x2 = x1 + src.shape[0]
y2 = y1 + src.shape[1]
dst[x1:x2, y1:y2, :] = src
def blitSurf(srcSurf, dst, dstSurf, xOffset=0, yOffset=0):
x = dst.size[0] / 2 + xOffset - srcSurf.w / 2
y = dst.size[1] / 2 + yOffset - srcSurf.h / 2
sdl2.SDL_BlitSurface(srcSurf, None, dstSurf,
sdl2.SDL_Rect(x, y, srcSurf.w, srcSurf.h))
sdl2.SDL_UpdateWindowSurface(
dst.window
) #should this really be here? (will it cause immediate update?)
# sdl2.SDL_FreeSurface(srcSurf)
#define a function that waits for a response
def waitForResponse():
# sdl2.SDL_FlushEvents()
done = False
while not done:
sdl2.SDL_PumpEvents()
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_KEYDOWN:
response = sdl2.SDL_GetKeyName(
event.key.keysym.sym).lower()
if response == 'escape':
exitSafely()
else:
done = True
# sdl2.SDL_FlushEvents()
return response
def refreshWindows():
stimDisplay.refresh()
image = stimDisplayArray[:, :, 0:3]
image = scipy.misc.imresize(
image, (stimDisplayRes[0] / 2, stimDisplayRes[1] / 2),
interp='nearest')
mirrorDisplayArray[:, :, 0:3] = image
mirrorDisplay.refresh()
return None
def clearScreen(color):
sdl2.ext.fill(stimDisplaySurf.contents, color)
def drawText(myText, myFont, textColor, textWidth=.9):
lineHeight = sdl2.sdlttf.TTF_RenderText_Blended(
myFont, 'T', textColor).contents.h
textWidthMax = int(stimDisplay.size[0])
paragraphs = myText.splitlines()
renderList = []
textHeight = 0
for thisParagraph in paragraphs:
words = thisParagraph.split(' ')
if len(words) == 1:
renderList.append(words[0])
if (thisParagraph != paragraphs[len(paragraphs) - 1]):
renderList.append(' ')
textHeight = textHeight + lineHeight
else:
thisWordIndex = 0
while thisWordIndex < (len(words) - 1):
lineStart = thisWordIndex
lineWidth = 0
while (thisWordIndex <
(len(words) - 1)) and (lineWidth <= textWidthMax):
thisWordIndex = thisWordIndex + 1
lineWidth = sdl2.sdlttf.TTF_RenderText_Blended(
myFont,
' '.join(words[lineStart:(thisWordIndex + 1)]),
textColor).contents.w
if thisWordIndex < (len(words) - 1):
#last word went over, paragraph continues
renderList.append(' '.join(
words[lineStart:(thisWordIndex - 1)]))
textHeight = textHeight + lineHeight
thisWordIndex = thisWordIndex - 1
else:
if lineWidth <= textWidthMax:
#short final line
renderList.append(' '.join(
words[lineStart:(thisWordIndex + 1)]))
textHeight = textHeight + lineHeight
else:
#full line then 1 word final line
renderList.append(' '.join(
words[lineStart:thisWordIndex]))
textHeight = textHeight + lineHeight
renderList.append(words[thisWordIndex])
textHeight = textHeight + lineHeight
#at end of paragraph, check whether a inter-paragraph space should be added
if (thisParagraph != paragraphs[len(paragraphs) - 1]):
renderList.append(' ')
textHeight = textHeight + lineHeight
numLines = len(renderList) * 1.0
for thisLine in range(len(renderList)):
thisRender = sdl2.sdlttf.TTF_RenderText_Blended(
myFont, renderList[thisLine], textColor).contents
x = int(stimDisplay.size[0] / 2.0 - thisRender.w / 2.0)
y = int(stimDisplay.size[1] / 2.0 - thisRender.h / 2.0 +
1.0 * thisLine / numLines * textHeight)
sdl2.SDL_BlitSurface(
thisRender, None, stimDisplaySurf,
sdl2.SDL_Rect(x, y, thisRender.w, thisRender.h))
sdl2.SDL_UpdateWindowSurface(
stimDisplay.window
) #should this really be here? (will it cause immediate update?)
#define a function that prints a message on the stimDisplay while looking for user input to continue. The function returns the total time it waited
def showMessage(myText, lockWait=False):
messageViewingTimeStart = getTime()
clearScreen(black)
refreshWindows()
clearScreen(black)
drawText(myText, font, lightGrey)
simpleWait(0.500)
refreshWindows()
clearScreen(black)
if lockWait:
response = None
while response not in ['return', 'y', 'n']:
response = waitForResponse()
else:
response = waitForResponse()
refreshWindows()
clearScreen(black)
simpleWait(0.500)
messageViewingTime = getTime() - messageViewingTimeStart
return [response, messageViewingTime]
#define a function to show stimuli and collect calibration data
def getCalibrationData():
if not manualCalibrationOrder:
dotLocationList = ['q', 'w', 'e', 'a', 's', 'd', 'z', 'x', 'c']
random.shuffle(dotLocationList)
done = False
eyeData = []
coordsList = []
startTimes = []
stopTimes = []
qFrom.put('startQueing')
while not done:
if manualCalibrationOrder:
dotLocation = waitForResponse()
else:
if len(dotLocationList) == 0:
break
else:
dotLocation = dotLocationList.pop()
if dotLocation == '0':
phase1Done = True
elif not dotLocation in calibrationKey:
pass
else:
displayCoords = calibrationLocations[
calibrationKey[dotLocation]]
coordsList.append(displayCoords / PPD)
clearScreen(black)
drawDot(displayCoords)
refreshWindows()
junk = waitForResponse()
startTimes.append(getTime())
simpleWait(1)
stopTimes.append(getTime())
while not qTo.empty():
eyeData.append(qTo.get())
clearScreen(black)
refreshWindows()
qFrom.put(['stopQueing', getTime()])
simpleWait(1)
done = False
while not done:
if not qTo.empty():
message = qTo.get()
if message == 'doneQueing':
done = True
else:
eyeData.append(message)
calibrationData = []
for i in range(len(startTimes)):
temp = [[
list(coordsList[i])[0],
list(coordsList[i])[1], 1.0, e[1], e[2], e[1] * e[2], e[3],
e[4], e[3] * e[4]
] for e in eyeData
if ((e[0] > startTimes[i]) and (e[0] < stopTimes[i]))]
temp = [item for sublist in temp for item in sublist]
calibrationData.append(temp)
calibrationData = numpy.array(
[item for sublist in calibrationData for item in sublist])
calibrationData = calibrationData.reshape(
[len(calibrationData) / 9, 9])
return calibrationData
#define a function to compute prediciton error
def getErrors(calibrationData, xCoefLeft, xCoefRight, yCoefLeft,
yCoefRight, leftCols, rightCols):
xPredsLeft = xCoefLeft[0] + xCoefLeft[1] * calibrationData[:, leftCols[
1]] + xCoefLeft[2] * calibrationData[:, leftCols[2]] + xCoefLeft[
3] * calibrationData[:, leftCols[3]]
yPredsLeft = yCoefLeft[0] + yCoefLeft[1] * calibrationData[:, leftCols[
1]] + yCoefLeft[2] * calibrationData[:, leftCols[2]] + yCoefLeft[
3] * calibrationData[:, leftCols[3]]
xPredsRight = xCoefRight[
0] + xCoefRight[1] * calibrationData[:, rightCols[1]] + xCoefRight[
2] * calibrationData[:, rightCols[2]] + xCoefRight[
3] * calibrationData[:, rightCols[3]]
yPredsRight = yCoefRight[
0] + yCoefRight[1] * calibrationData[:, rightCols[1]] + yCoefRight[
2] * calibrationData[:, rightCols[2]] + yCoefRight[
3] * calibrationData[:, rightCols[3]]
xPreds = (xPredsLeft + xPredsRight) / 2
yPreds = (yPredsLeft + yPredsRight) / 2
xError = numpy.mean((xPreds - calibrationData[:, 0])**2)**.5
yError = numpy.mean((yPreds - calibrationData[:, 1])**2)**.5
totError = numpy.mean((((xPreds - calibrationData[:, 0])**2) +
(yPreds - calibrationData[:, 1])**2)**.5)
return [xError, yError, totError]
#start calibration
done = False
while not done:
showMessage('When you are ready to begin calibration, press any key.')
calibrationData = getCalibrationData()
leftCols = [2, 3, 4, 5]
rightCols = [2, 6, 7, 8]
xCoefLeft = numpy.linalg.lstsq(calibrationData[:, leftCols],
calibrationData[:, 0])[0]
xCoefRight = numpy.linalg.lstsq(calibrationData[:, rightCols],
calibrationData[:, 0])[0]
yCoefLeft = numpy.linalg.lstsq(calibrationData[:, leftCols],
calibrationData[:, 1])[0]
yCoefRight = numpy.linalg.lstsq(calibrationData[:, rightCols],
calibrationData[:, 1])[0]
xError, yError, totError = getErrors(calibrationData, xCoefLeft,
xCoefRight, yCoefLeft, yCoefRight,
leftCols, rightCols)
showMessage('Calibration results:\nx = ' + str(xError) + '\ny = ' +
str(yError) + '\nz = ' + str(totError) +
'\nPress any key to validate calibration.')
validationData = getCalibrationData()
xError, yError, totError = getErrors(validationData, xCoefLeft,
xCoefRight, yCoefLeft, yCoefRight,
leftCols, rightCols)
done2 = False
while not done2:
response = showMessage(
'Validation results:\nx = ' + str(xError) + '\ny = ' +
str(yError) + '\nz = ' + str(totError) +
'\nExperimenter: Press "a" to accept calibration, or "r" to repeat calibration.'
)
if response[0] == 'a':
qFrom.put([
'calibrationCoefs',
[xCoefLeft, xCoefRight, yCoefLeft, yCoefRight]
])
done = True
done2 = True
elif response[0] == 'r':
done2 = True
exitSafely()
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
#This will return a handle to an open 'Notepad.exe' window.
window_handle = get_windows_bytitle("Untitled", False)
#Create a window so that the hint below can be set
a = sdl2.SDL_CreateWindow("test window", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, 200, 200, 0)
#Set hint as recommended by SDL documentation: https://wiki.libsdl.org/SDL_CreateWindowFrom#Remarks
result = sdl2.SDL_SetHint(sdl2.SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT,
hex(id(a)))
print(sdl2.SDL_GetError())
np_window = sdl2.SDL_CreateWindowFrom(window_handle[0])
print(sdl2.SDL_GetError())
np_sur = sdl2.SDL_GetWindowSurface(np_window)
print(sdl2.SDL_GetError())
save_sur = sdl2.SDL_CreateRGBSurface(0, np_sur[0].w, np_sur[0].h, 32, 0, 0, 0,
0)
print(sdl2.SDL_GetError())
r = sdl2.SDL_BlitSurface(np_sur, None, save_sur, None)
print(sdl2.SDL_GetError())
result = sdl2.SDL_SaveBMP(save_sur, 'test.bmp')
print(sdl2.SDL_GetError())
sdl2.SDL_FreeSurface(save_sur)
print(sdl2.SDL_GetError())
def stamperChildFunction(qTo,
qFrom,
windowSize=[200, 200],
windowPosition=[0, 0],
windowColor=[255, 255, 255],
doBorder=True):
import sdl2
import sdl2.ext
import sys
import time
try:
import appnope
appnope.nope()
except:
pass
sdl2.SDL_Init(sdl2.SDL_INIT_TIMER)
timeFreq = 1.0 / sdl2.SDL_GetPerformanceFrequency()
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
if doBorder:
flags = sdl2.SDL_WINDOW_SHOWN
else:
flags = sdl2.SDL_WINDOW_BORDERLESS | sdl2.SDL_WINDOW_SHOWN
window = sdl2.ext.Window("pyStamper",
size=windowSize,
position=windowPosition,
flags=flags)
windowID = sdl2.SDL_GetWindowID(window.window)
windowSurf = sdl2.SDL_GetWindowSurface(window.window)
red = sdl2.pixels.SDL_Color(r=255, g=0, b=0, a=255)
green = sdl2.pixels.SDL_Color(r=0, g=255, b=0, a=255)
black = sdl2.pixels.SDL_Color(r=0, g=0, b=0, a=255)
white = sdl2.pixels.SDL_Color(r=255, g=255, b=255, a=255)
if doBorder:
sdl2.ext.fill(windowSurf.contents, green)
else:
sdl2.ext.fill(
windowSurf.contents,
sdl2.pixels.SDL_Color(r=windowColor[0],
g=windowColor[1],
b=windowColor[2],
a=255))
window.refresh()
for i in range(10):
sdl2.SDL_PumpEvents() #to show the windows
sdl2.SDL_Init(
sdl2.SDL_INIT_JOYSTICK) #uncomment if you want joystick input
sdl2.SDL_JoystickOpen(0) #uncomment if you want joystick input
lostFocus = True
lostColors = [red, black, red, white]
lastRefreshTime = time.time()
while True:
if lostFocus and doBorder:
if time.time() > (lastRefreshTime + (2.0 / 60)):
sdl2.ext.fill(windowSurf.contents, lostColors[0])
window.refresh()
lostColors.append(lostColors.pop(0))
lastRefreshTime = time.time()
sdl2.SDL_PumpEvents()
if not qTo.empty():
message = qTo.get()
if message == 'quit':
sys.exit()
elif message == 'raise':
sdl2.SDL_RaiseWindow(window.window)
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_WINDOWEVENT:
if event.window.windowID == windowID:
if (event.window.event == sdl2.SDL_WINDOWEVENT_CLOSE):
qFrom.put({
'type': 'key',
'time': event.window.timestamp * timeFreq,
'value': 'escape'
})
sys.exit()
elif event.window.event == sdl2.SDL_WINDOWEVENT_FOCUS_LOST:
lostFocus = True
elif event.window.event == sdl2.SDL_WINDOWEVENT_FOCUS_GAINED:
lostFocus = False
if doBorder:
sdl2.ext.fill(windowSurf.contents, green)
window.refresh()
else:
message = {}
if event.type == sdl2.SDL_KEYDOWN:
message['type'] = 'key'
message['time'] = event.key.timestamp * timeFreq
message['value'] = sdl2.SDL_GetKeyName(
event.key.keysym.sym).lower()
message['keysym'] = event.key.keysym
qFrom.put(message)
elif event.type == sdl2.SDL_JOYAXISMOTION:
message['type'] = 'axis'
message['axis'] = event.jaxis.axis
message['time'] = event.jaxis.timestamp * timeFreq
message['value'] = event.jaxis.value
qFrom.put(message)
elif event.type == sdl2.SDL_JOYBUTTONDOWN:
message['type'] = 'button'
message['time'] = event.jbutton.timestamp * timeFreq
message['value'] = event.jbutton.button
qFrom.put(message)
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Rain Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_MULTISAMPLESAMPLES, 4)
gl.glClearColor(0.8, 0.8, 0.8, 0.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# gl.glDisable(gl.GL_DEPTH)
gl.glDisable(gl.GL_DEPTH_TEST)
# load Textures
self.txPaving = loadTexture(b'res/paving.bmp',
gl.GL_RGB,
gl.GL_REPEAT,
mipmap=True)
txSplash = loadTexture(b'res/waterdrops.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# init fog
gl.glEnable(gl.GL_FOG)
gl.glFogi(gl.GL_FOG_MODE, gl.GL_EXP2)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
self.sizeRatio = self.width / 1440
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
dropRenderer = GLPointRenderer.create()
dropRenderer.setType(spk.POINT_CIRCLE)
dropRenderer.setSize(2.0 * self.sizeRatio)
dropRenderer.enableBlending(True)
self.dropRenderer = dropRenderer
rainRenderer = GLLineRenderer.create()
rainRenderer.setLength(-0.1)
rainRenderer.enableBlending(True)
self.rainRenderer = rainRenderer
splashRenderer = GLQuadRenderer.create()
splashRenderer.setScale(0.05, 0.05)
splashRenderer.setTexturingMode(spk.TEXTURE_2D)
splashRenderer.setTexture(txSplash)
splashRenderer.enableBlending(True)
splashRenderer.enableRenderingHint(spk.DEPTH_WRITE, False)
self.splashRenderer = splashRenderer
# create Model
rain_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_MASS
rain_mutable = spk.FLAG_NONE
rain_random = spk.FLAG_MASS
rainModel = spk.Model.create(rain_enable, rain_mutable, rain_random)
rainModel.setParam(spk.PARAM_ALPHA, 0.2)
rainModel.setImmortal(True)
self.rainModel = rainModel
dropModel = spk.Model.create(rain_enable, rain_mutable,
rain_random) # same as rain
dropModel.setParam(spk.PARAM_ALPHA, 0.6)
self.dropModel = dropModel
splash_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_SIZE | spk.FLAG_ANGLE
splash_mutable = spk.FLAG_SIZE | spk.FLAG_ALPHA
splash_random = spk.FLAG_SIZE | spk.FLAG_ANGLE
splashModel = spk.Model.create(splash_enable, splash_mutable,
splash_random)
splashModel.setParam(spk.PARAM_ANGLE, 0.0, 2.0 * math.pi)
splashModel.setParam(spk.PARAM_ALPHA, 1.0, 0.0)
self.splashModel = splashModel
# create Emitter
rainZone = spk.Ring.create(spk.Vector3D(0.0, 5.0, 0.0))
self.rainZone = rainZone
rainEmitter = spk.SphericEmitter.create(spk.Vector3D(0.0, -1.0, 0.0),
0.0, 0.03 * math.pi)
rainEmitter.setZone(rainZone)
self.rainEmitter = rainEmitter
self.dropEmitter = spk.SphericEmitter.create(
spk.Vector3D(0.0, 1.0, 0.0), 0.0, 0.2 * math.pi)
# create Group
gravity = spk.Vector3D(0.0, -2.0, 0.0)
rainGroup = spk.Group.create(rainModel, 8000)
rainGroup.setCustomUpdate(lambda p, t: self.killRain(p, t))
rainGroup.setRenderer(rainRenderer)
rainGroup.addEmitter(rainEmitter)
rainGroup.setFriction(0.7)
rainGroup.setGravity(gravity)
self.rainGroup = rainGroup
dropGroup = spk.Group.create(dropModel, 16000)
dropGroup.setRenderer(dropRenderer)
dropGroup.setFriction(0.7)
dropGroup.setGravity(gravity)
self.dropGroup = dropGroup
splashGroup = spk.Group.create(splashModel, 2400)
splashGroup.setRenderer(splashRenderer)
self.splashGroup = splashGroup
# create System
system = spk.System.create()
system.addGroup(splashGroup)
system.addGroup(dropGroup)
system.addGroup(rainGroup)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.angleY = 0.0
self.angleX = 12.0
self.posX = 0.0
self.posZ = 0.0
self.rainRatio = 0.5
self.recompute = True
self.nbParticles = ''
self.fps = ''
self.strRainRate = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Fountain Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.68, 0.85, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# init fog
gl.glEnable(gl.GL_FOG)
gl.glFogi(gl.GL_FOG_MODE, gl.GL_EXP2)
gl.glFogfv(gl.GL_FOG_COLOR, [0.0, 0.68, 0.85, 1.0])
gl.glFogf(gl.GL_FOG_DENSITY, 0.04)
gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST)
# load Textures
self.txGrass = loadTexture(b'res/grass.bmp',
gl.GL_RGB,
gl.GL_REPEAT,
mipmap=True)
self.txFountain = loadTexture(b'res/tile.bmp',
gl.GL_RGB,
gl.GL_REPEAT,
mipmap=True)
self.txWater = loadTexture(b'res/water.bmp',
gl.GL_RGB,
gl.GL_REPEAT,
mipmap=True)
txSplash = loadTexture(b'res/waterdrops.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# create display lists
self.createDisplayLists()
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLQuadRenderer.create(1.0) # type: GLQuadRenderer
renderer.setScale(0.06, 0.06)
renderer.setTexturingMode(spk.TEXTURE_2D)
renderer.setTexture(txSplash)
renderer.setBlending(spk.BLENDING_ALPHA)
renderer.enableRenderingHint(spk.DEPTH_WRITE, False)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_ALPHA | spk.FLAG_SIZE | spk.FLAG_ANGLE
model_mutable = spk.FLAG_ALPHA | spk.FLAG_SIZE | spk.FLAG_ANGLE
model_random = spk.FLAG_SIZE | spk.FLAG_ANGLE
model = spk.Model.create(model_enable, model_mutable,
model_random) # type: spk.Model
model.setParam(spk.PARAM_ALPHA, 0.2, 0.0)
model.setParam(spk.PARAM_SIZE, 1.0, 1.0, 2.0, 8.0)
model.setParam(spk.PARAM_ANGLE, 0.0, 4.0 * math.pi, 0.0, 4.0 * math.pi)
model.setLifeTime(1.6, 2.2)
self.model = model
# create Emitter
self.emitterZones = []
self.emitters = []
# splash to just above(x1)
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(0.0, 1.0, 0.0)))
# splash from center of fountain(x4)
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1, 0.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.0, 3.0, 1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.0, 3.0, -1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.0, 3.0, 1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.0, 3.0, -1.0)))
# splash from the side of fountain(x8)
self.emitterZones.append(
spk.Point.create(spk.Vector3D(-1.6, 0.1, -1.6)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(1.6, 0.1, 1.6)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(1.6, 0.1,
-1.6)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(-1.6, 0.1,
1.6)))
self.emitterZones.append(
spk.Point.create(spk.Vector3D(-2.26, 0.1, 0.0)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(2.26, 0.1,
0.0)))
self.emitterZones.append(
spk.Point.create(spk.Vector3D(0.0, 0.1, -2.26)))
self.emitterZones.append(spk.Point.create(spk.Vector3D(0.0, 0.1,
2.26)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.0, 2.0, 1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.0, 2.0, -1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.0, 2.0, 1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.0, 2.0, -1.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(1.41, 2.0, 0.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(-1.41, 2.0, 0.0)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(0.0, 2.0, 1.41)))
self.emitters.append(
spk.StraightEmitter.create(spk.Vector3D(0.0, 2.0, -1.41)))
self.flow = [
500.0, 600.0, 600.0, 600.0, 600.0, 900.0, 900.0, 900.0, 900.0,
900.0, 900.0, 900.0, 900.0
]
self.flowLow = [
150.0, 200.0, 200.0, 200.0, 200.0, 250.0, 250.0, 250.0, 250.0,
250.0, 250.0, 250.0, 250.0
]
for i in range(len(self.emitters)):
self.emitters[i].setZone(self.emitterZones[i])
self.emitters[i].setFlow(self.flow[i])
self.emitters[i].setForce(2.5, 4.0)
self.emitters[0].setForce(3.0, 3.5)
# no Modifier
# create Group
group = spk.Group.create(model, 20000) # type: spk.Group
for emitter in self.emitters:
group.addEmitter(emitter)
group.setRenderer(renderer)
group.setCustomUpdate(self.splash)
group.setGravity(spk.Vector3D(0.0, -2.2, 0.0))
group.setFriction(0.7)
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.totalTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.highGraphics = True
self.angleY = 25.0
self.angleX = 25.0
self.camPosZ = 8.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Collision Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load Texture
txParticle = loadTexture(b'res/ball2.bmp', gl.GL_RGBA, gl.GL_CLAMP)
self.txCrate = loadTexture(b'res/crate.bmp', gl.GL_RGB, gl.GL_REPEAT)
self.txFloor = loadTexture(b'res/floor.bmp', gl.GL_RGB, gl.GL_REPEAT)
self.txWall = loadTexture(b'res/wall.bmp', gl.GL_RGB, gl.GL_REPEAT)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# create Renderer
spk.setRandomSeed(int(time.time()))
renderer = GLPointRenderer.create(1.0) # type: GLPointRenderer
renderer.setType(
spk.POINT_SPRITE) # using Point Sprite(require >=OpenGL2.0)
renderer.setTexture(txParticle) # use the texture on drawing
renderer.enableWorldSize(
True
) # true: unit is adjusted with the screen, false: unit is pixel(fixed)
GLPointRenderer.setPixelPerUnit(45.0 * math.pi / 180.0, self.height)
renderer.setSize(0.05)
renderer.setBlending(
spk.BLENDING_NONE
) # blending method between particles(no blending)
renderer.enableRenderingHint(spk.ALPHA_TEST,
True) # notifying not to use depth info
renderer.setAlphaTestThreshold(0.8)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE # use color channels(RGB)
model = spk.Model.create(model_enable) # type: spk.Model
model.setLifeTime(10.0, 10.0) # particle's life time is 10[sec]
self.model = model
# create Emitter
emit_dir = spk.Vector3D(0.0, 0.0, -1.0)
emit_center = spk.Vector3D(0.0, 2.0, 4.475)
minangle = 0.0 * math.pi # zenith angle(min)
maxangle = 0.5 * math.pi # zenith angle(max)
emitter = spk.SphericEmitter.create(
emit_dir, minangle, maxangle) # type: spk.SphericEmitter
emitter.setZone(
spk.Point.create(emit_center),
True) # particles are randomly placed in the specified zone
emitter.setFlow(300) # max number of particles
emitter.setForce(1.5, 2.5) # emittion power
# create Group
maxparticle = 3100 # upper limit number of particles
group = spk.Group.create(model, maxparticle) # type: spk.Group
group.addEmitter(emitter)
group.setRenderer(renderer)
group.setCustomBirth(self.assignColor)
group.setGravity(spk.Vector3D(0.0, -0.8, 0.0))
group.setFriction(0.2)
self.group = group
# create Room objects
self.ROOM_X = 7.0
self.ROOM_Y = 3.0
self.ROOM_Z = 9.0
self.boxes = []
self.partitions = []
self.initRoom(group) # obstacles
self.createDisplayLists() # display list for OpenGL drawing
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.enableBoxDrawing = False
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.angleY = 90.0
self.angleX = 45.0
self.camPosZ = 10.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self,
*,
width=SCR_W,
height=SCR_H,
framerate=FPS,
show_fps=True,
show_play_time=False,
scene=None,
test=False,
scene_args=None,
opacity=255,
window_color=None):
"""Initialization.
Args:
opacity (int): a number from 0 to 255, where 0 will make the
window fully transparent (invisible) and 255 fully opaque (
opacity value will be ignored in that case)
"""
self.alive = False
self._scene = None
self.text_input = False
self.show_fps = show_fps
self.width = width
self.height = height
self.fps = framerate
self.test = test
sdl2.ext.init()
window = sdl2.ext.Window("Tiles",
size=(SCR_W, SCR_H),
flags=sdl2.SDL_WINDOW_BORDERLESS)
if opacity < 255:
sdl2.video.SDL_SetWindowOpacity(window.window, opacity / 255)
sfc = sdl2.SDL_GetWindowSurface(window.window).contents
opf = sfc.format.contents
self._window = window
self.opacity = opacity
self.window_color = window_color or (0, 0, 0, 255)
self.colors = data_handler.get_colors()
renderer = sdl2.ext.Renderer(window)
self.renderer = renderer
factory = SpriteFactory(sdl2.ext.TEXTURE, renderer=renderer)
factory.opf = opf
self.factory = factory
sdl2.sdlttf.TTF_Init()
self.fonts = FontsManager(factory)
self.tile_size = TILE_W
self.spriterenderer = self.factory.create_sprite_render_system(window)
window.show()
# self.renderer.clear()
scene_args = scene_args or {}
if scene:
self.set_scene(scene, **scene_args)
sdl2.SDL_RaiseWindow(window.window)
self.alive = True
self.get_mouse_state()
self.clock = time.Clock()
def trackerChildFunction(qTo,
qFrom,
camIndex=0,
camRes=[1920, 1080],
previewDownsize=2,
previewLoc=[0, 0],
faceDetectionScale=10,
eyeDetectionScale=5,
timestampMethod=0,
viewingDistance=100,
stimDisplayWidth=100,
stimDisplayRes=[1920, 1080],
stimDisplayPosition=[0, 0],
mirrorDisplayPosition=[0, 0],
mirrorDownSize=2,
manualCalibrationOrder=True,
calibrationDotSizeInDegrees=.5):
import fileForker
import numpy
import cv2
import scipy.ndimage.filters
# import scipy.interpolate
import sys
import sdl2
import sdl2.ext
import sdl2.sdlmixer
#define a class for a clickable text UI
class clickableText:
def __init__(self, x, y, text, rightJustified=False, valueText=''):
self.x = x
self.y = y
self.text = text
self.rightJustified = rightJustified
self.valueText = valueText
self.isActive = False
self.clicked = False
self.updateSurf()
def updateSurf(self):
if self.isActive:
self.surf = sdl2.sdlttf.TTF_RenderText_Blended_Wrapped(
font, self.text + self.valueText,
sdl2.pixels.SDL_Color(r=0, g=255, b=255, a=255),
previewWindow.size[0]).contents
else:
self.surf = sdl2.sdlttf.TTF_RenderText_Blended_Wrapped(
font, self.text + self.valueText,
sdl2.pixels.SDL_Color(r=0, g=0, b=255, a=255),
previewWindow.size[0]).contents
def checkIfActive(self, event):
if self.rightJustified:
xLeft = self.x - self.surf.w
xRight = self.x
else:
xLeft = self.x
xRight = self.x + self.surf.w
if (event.button.x > xLeft) & (event.button.x < xRight) & (
event.button.y > self.y) & (event.button.y <
(self.y + fontSize)):
self.isActive = True
else:
self.isActive = False
self.updateSurf()
def draw(self, targetWindowSurf):
if self.rightJustified:
sdl2.SDL_BlitSurface(
self.surf, None, targetWindowSurf,
sdl2.SDL_Rect(self.x - self.surf.w, self.y, self.surf.w,
self.surf.h))
else:
sdl2.SDL_BlitSurface(
self.surf, None, targetWindowSurf,
sdl2.SDL_Rect(self.x, self.y, self.surf.w, self.surf.h))
#define a class for settings
class settingText(clickableText):
def __init__(self, value, x, y, text, rightJustified=False):
self.value = value
self.valueText = str(value)
clickableText.__init__(self, x, y, text, rightJustified,
self.valueText)
def addValue(self, toAdd):
self.valueText = self.valueText + toAdd
self.updateSurf()
def delValue(self):
if self.valueText != '':
self.valueText = self.valueText[0:(len(self.valueText) - 1)]
self.updateSurf()
def finalizeValue(self):
try:
self.value = int(self.valueText)
except:
print 'Non-numeric value entered!'
#define a class for dots
class dotObj:
def __init__(self, name, isFid, fid, xPixel, yPixel, radiusPixel,
blinkCriterion, blurSize, filterSize):
self.name = name
self.isFid = isFid
self.x = xPixel
self.y = yPixel
self.radius = radiusPixel
self.first = True
self.last = [self.x, self.y, self.radius]
self.lost = False
self.blinkHappened = False
self.radii = []
self.SDs = []
self.lostCount = 0
self.blinkCriterion = blinkCriterion
self.blurSize = blurSize
self.filterSize = filterSize
self.setPixels()
if not self.isFid:
self.makeRelativeToFid(fid)
def setPixels(self):
self.xPixel = int(self.x)
self.yPixel = int(self.y)
self.radiusPixel = int(self.radius)
return None
def makeRelativeToFid(self, fid):
self.x2 = (self.x - fid.x) / fid.radius
self.y2 = (self.y - fid.y) / fid.radius
self.radius2 = self.radius / fid.radius
return None
def getDarkEllipse(self, img):
#if not self.isFid:
# #cv2.imwrite(self.name + "_" + "%.2d" % imageNum + "_raw.png" , img)
try:
smoothedImg = cv2.GaussianBlur(img,
(self.blurSize, self.blurSize),
0)
#if not self.isFid:
# #cv2.imwrite(self.name + "_" + "%.2d" % imageNum + "_smoothed.png" , img)
except:
print 'cv2.GaussianBlur failed'
# cv2.imwrite('temp.png',img)
return None
try:
dataMin = scipy.ndimage.filters.minimum_filter(
smoothedImg, self.filterSize)
except:
print 'scipy.ndimage.filters.minimum_filter failed'
# cv2.imwrite('temp.png',img)
return None
if dataMin != None:
try:
minLocs = numpy.where(
dataMin < (numpy.min(dataMin) + numpy.std(dataMin)))
except:
print 'numpy.where failed'
# cv2.imwrite('temp.png',img)
return None
if len(minLocs[0]) >= 5:
try:
ellipse = cv2.fitEllipse(
numpy.reshape(
numpy.column_stack((minLocs[1], minLocs[0])),
(len(minLocs[0]), 1, 2)))
except:
print 'cv2.fitEllipse failed'
# cv2.imwrite('temp.png',img)
return None
return ellipse
def cropImage(self, img, cropSize):
xLo = self.xPixel - cropSize
if xLo < 0:
xLo = 0
xHi = self.xPixel + cropSize
if xHi > img.shape[1]:
xHi = img.shape[1]
yLo = self.yPixel - cropSize
if yLo < 0:
yLo = 0
yHi = self.yPixel + cropSize
if yHi > img.shape[0]:
yHi = img.shape[0]
return [img[yLo:yHi, xLo:xHi], xLo, xHi, yLo, yHi]
def search(self, img):
if self.first and self.isFid:
searchSize = 1
elif self.lost:
searchSize = 5
else:
searchSize = 3
if self.first:
self.first = False
img, xLo, xHi, yLo, yHi = self.cropImage(img=img,
cropSize=searchSize *
self.radiusPixel)
self.ellipse = self.getDarkEllipse(img=img)
if self.ellipse != None:
self.ellipse = ((self.ellipse[0][0] + xLo,
self.ellipse[0][1] + yLo), self.ellipse[1],
self.ellipse[2])
self.lost = False
self.x = self.ellipse[0][0]
self.y = self.ellipse[0][1]
self.major = self.ellipse[1][0]
self.minor = self.ellipse[1][1]
self.angle = self.ellipse[2]
self.radius = (self.ellipse[1][0] + self.ellipse[1][1]) / 4
self.setPixels()
else:
self.lost = True
def checkSearch(self):
self.medianRadius = numpy.median(self.radii)
self.critRadius = 10 * ((numpy.median(
(self.radii - self.medianRadius)**2))**.5)
#print [self.name, self.radius2,(self.radius2<(1/6)) , (self.radius2>2)]
if len(self.radii) < 30:
self.radii.append(self.radius2)
self.lost = False
else:
#fid diameter is 6mm, so range from 1mm to 12mm
#if (self.radius2<(1/6)) or (self.radius2>2) or (self.radius2<(self.medianRadius - self.critRadius)) or (self.radius2>(self.medianRadius + self.critRadius)):
if (self.radius2 < (1 / 6)) or (self.radius2 > 2):
self.lost = True
else:
self.lost = False
self.radii.append(self.radius2)
if len(self.radii) >= 300:
self.radii.pop()
def checkSD(self, img, fid):
self.obsSD = numpy.std(
self.cropImage(img=img, cropSize=5 * fid.radiusPixel)[0])
self.medianSD = numpy.median(self.SDs)
self.critSD = self.medianSD * self.blinkCriterion
#print [self.name,self.obsSD,self.medianSD,self.critSD,self.blinkCriterion]
if len(self.SDs) < 30:
self.SDs.append(self.obsSD)
self.blinkHappened = False
else:
if (self.obsSD < self.critSD):
self.blinkHappened = True
else:
self.SDs.append(self.obsSD)
self.blinkHappened = False
if len(self.SDs) >= 300:
self.SDs.pop()
def update(self, img, fid, blinkCriterion, blurSize, filterSize):
self.blinkCriterion = blinkCriterion
self.blurSize = blurSize
self.filterSize = filterSize
self.last = [self.x, self.y, self.radius]
if self.isFid:
self.search(img=img)
else:
self.checkSD(
img=img, fid=fid
) #alters the value of self.blinkHappened, amongst other things
if self.blinkHappened:
self.x, self.y, self.radius = self.last
self.setPixels()
self.makeRelativeToFid(fid)
else:
self.search(
img=img
) #alters the value of self.lost, amongst other things
if self.lost:
self.x, self.y, self.radius = self.last
self.setPixels()
self.makeRelativeToFid(fid)
else:
self.makeRelativeToFid(fid=fid)
self.checkSearch(
) #alters the value of self.lost, among other things
if self.lost:
self.x, self.y, self.radius = self.last
self.setPixels()
self.makeRelativeToFid(fid)
if self.lost and not self.blinkHappened:
self.lostCount += 1
else:
self.lostCount = 0
########
# Initialize audio and define a class that handles playing sounds in PySDL2
########
sdl2.SDL_Init(sdl2.SDL_INIT_AUDIO)
sdl2.sdlmixer.Mix_OpenAudio(44100, sdl2.sdlmixer.MIX_DEFAULT_FORMAT, 2,
1024)
class Sound:
def __init__(self, fileName):
self.sample = sdl2.sdlmixer.Mix_LoadWAV(
sdl2.ext.compat.byteify(fileName, "utf-8"))
self.started = False
def play(self):
self.channel = sdl2.sdlmixer.Mix_PlayChannel(-1, self.sample, 0)
self.started = True
def stillPlaying(self):
if self.started:
if sdl2.sdlmixer.Mix_Playing(self.channel):
return True
else:
self.started = False
return False
########
# define some useful functions
########
#define a function to exit safely
def exitSafely():
qFrom.put('done')
sys.exit()
#define a function to rescale
def rescaleBiggestHaar(detected, scale, addToX=0, addToY=0):
x, y, w, h = detected[numpy.argmax(
[numpy.sqrt(w * w + h * h) for x, y, w, h in detected])]
return [x * scale + addToX, y * scale + addToY, w * scale, h * scale]
########
# Initialize variables
########
#initialize sounds
blinkSound = Sound('./pytracker/Resources/sounds/beep.wav')
saccadeSound = Sound('./pytracker/Resources/sounds/stop.wav')
#specify the getTime function
if (timestampMethod == 0) or (timestampMethod == 1):
#initialize timer
sdl2.SDL_Init(sdl2.SDL_INIT_TIMER)
if timestampMethod == 0:
#define a function to use the high-precision timer, returning a float in seconds
def getTime():
return sdl2.SDL_GetPerformanceCounter(
) * 1.0 / sdl2.SDL_GetPerformanceFrequency()
elif timestampMethod == 1:
#use the SDL_GetTicks timer
def getTime():
return sdl2.SDL_GetTicks() / 1000.0
elif timestampMethod == 2:
#use time.time
import time
getTime = time.time
#initialize font
fontSize = camRes[1] / previewDownsize / 10
sdl2.sdlttf.TTF_Init()
font = sdl2.sdlttf.TTF_OpenFont('./pytracker/Resources/DejaVuSans.ttf',
fontSize)
#initialize preview video
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
previewWindow = sdl2.ext.Window("Preview",
size=(camRes[0] / previewDownsize,
camRes[1] / previewDownsize),
position=previewLoc,
flags=sdl2.SDL_WINDOW_SHOWN)
previewWindowSurf = sdl2.SDL_GetWindowSurface(previewWindow.window)
previewWindowArray = sdl2.ext.pixels3d(previewWindowSurf.contents)
sdl2.ext.fill(previewWindowSurf.contents,
sdl2.pixels.SDL_Color(r=255, g=255, b=255, a=255))
previewWindow.refresh()
lastRefreshTime = getTime()
#initialize the settings window
settingsWindow = sdl2.ext.Window(
"Settings",
size=(camRes[0] / previewDownsize, camRes[1] / previewDownsize),
position=[
previewLoc[0] + camRes[0] / previewDownsize + 1, previewLoc[1]
])
settingsWindowSurf = sdl2.SDL_GetWindowSurface(settingsWindow.window)
settingsWindowArray = sdl2.ext.pixels3d(settingsWindowSurf.contents)
sdl2.ext.fill(settingsWindowSurf.contents,
sdl2.pixels.SDL_Color(r=0, g=0, b=0, a=255))
settingsWindow.hide()
settingsWindow.refresh()
#import the haar cascades
faceCascade = cv2.CascadeClassifier(
'./pytracker/Resources/cascades/haarcascade_frontalface_alt2.xml')
eyeLeftCascade = cv2.CascadeClassifier(
'./pytracker/Resources/cascades/LEye18x12.1.xml')
eyeRightCascade = cv2.CascadeClassifier(
'./pytracker/Resources/cascades/REye18x12.1.xml')
#create some settings
settingsDict = {}
settingsDict['blink'] = settingText(value=75,
x=fontSize,
y=fontSize,
text='Blink (0-100) = ')
settingsDict['blur'] = settingText(value=3,
x=fontSize,
y=fontSize * 2,
text='Blur (0-; odd only) = ')
settingsDict['filter'] = settingText(value=3,
x=fontSize,
y=fontSize * 3,
text='Filter (0-; odd only) = ')
settingsDict['saccade0'] = settingText(value=50,
x=fontSize,
y=fontSize * 4,
text='Saccade (0-) = ')
settingsDict['saccade'] = settingText(value=1,
x=fontSize,
y=fontSize * 5,
text='Calibrated Saccade (0-) = ')
#create some text UIs
clickableTextDict = {}
clickableTextDict['manual'] = clickableText(x=0, y=0, text='Manual')
clickableTextDict['auto'] = clickableText(x=0, y=fontSize, text='Auto')
clickableTextDict['calibrate'] = clickableText(x=0,
y=previewWindow.size[1] -
fontSize,
text='Calibrate')
clickableTextDict['settings'] = clickableText(x=previewWindow.size[0],
y=0,
text='Settings',
rightJustified=True)
clickableTextDict['lag'] = clickableText(x=previewWindow.size[0],
y=previewWindow.size[1] -
fontSize * 2,
text='Lag: ',
rightJustified=True)
clickableTextDict['f2f'] = clickableText(x=previewWindow.size[0],
y=previewWindow.size[1] -
fontSize,
text='Frame-to-frame: ',
rightJustified=True)
#initialize variables
previewInFocus = True
settingsInFocus = False
lastTime = 0
dotList = []
lastLocs = [None, None]
displayLagList = []
frameToFrameTimeList = []
doHaar = False
clickingForDots = False
calibrating = False
doneCalibration = False
doSounds = True
queueDataToParent = False
#set dummy calibration coefficients (yields untransformed pixel locs)
calibrationCoefs = [[0, 1, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 1, 0]]
########
# Initialize camera
########
vc = cv2.VideoCapture(camIndex)
vc.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, camRes[0])
vc.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, camRes[1])
imageNum = 0
#start the loop
while True:
#poll the camera
t1 = getTime() #time right before requesting the image
_, image = vc.read() #request the image
t2 = getTime() #time right after requesting the image
imageTime = t1 + (
t2 - t1
) / 2.0 #timestamp the image as halfway between times before and after request
image = image[:, :, 2] #grab red channel (image is BGR)
imageNum += 1 #iterate the image number
#check for messages from the main process
if not qTo.empty():
message = qTo.get()
if message == 'quit':
exitSafely()
#process input
sdl2.SDL_PumpEvents()
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_WINDOWEVENT:
targetWindow = sdl2.SDL_GetWindowFromID(event.window.windowID)
title = sdl2.SDL_GetWindowTitle(targetWindow)
# if event.window.event==sdl2.SDL_WINDOWEVENT_FOCUS_GAINED:
# print title + "focused"
# if event.window.event==sdl2.SDL_WINDOWEVENT_ENTER:
# print title + " entered"
# elif event.window.event==sdl2.SDL_WINDOWEVENT_FOCUS_LOST:
# print title + " lost focus"
if event.window.event == sdl2.SDL_WINDOWEVENT_LEAVE:
if title == 'Preview':
previewInFocus = False
settingsInFocus = True
if (event.window.event == sdl2.SDL_WINDOWEVENT_FOCUS_GAINED
) or (event.window.event == sdl2.SDL_WINDOWEVENT_ENTER):
if title == 'Preview':
previewInFocus = True
settingsInFocus = False
elif title == 'Settings':
previewInFocus = False
settingsInFocus = True
elif (event.window.event == sdl2.SDL_WINDOWEVENT_CLOSE):
if title == 'Preview':
exitSafely()
elif title == 'Settings':
previewInFocus = True
settingsInFocus = False
settingsWindow.hide()
previewWindow.show()
elif settingsInFocus:
# if event.type==sdl2.SDL_MOUSEBUTTONUP:
# if blinkTextButtonDown:
# blinkTextButtonDown = False
# if event.type==sdl2.SDL_MOUSEBUTTONDOWN:
# if mouseInBlinkText:
# blinkTextButtonDown = True
if event.type == sdl2.SDL_MOUSEMOTION:
alreadyClicked = False
for setting in settingsDict:
if (settingsDict[setting].isActive) and (
settingsDict[setting].clicked):
alreadyClicked = True
if not alreadyClicked:
for setting in settingsDict:
settingsDict[setting].checkIfActive(event)
elif event.type == sdl2.SDL_MOUSEBUTTONDOWN:
alreadyClicked = False
for setting in settingsDict:
if (settingsDict[setting].isActive) and (
settingsDict[setting].clicked):
alreadyClicked = True
if not alreadyClicked:
for setting in settingsDict:
if settingsDict[setting].isActive:
settingsDict[setting].clicked = True
elif event.type == sdl2.SDL_KEYDOWN:
key = sdl2.SDL_GetKeyName(event.key.keysym.sym).lower()
if key == 'backspace':
for setting in settingsDict:
if (settingsDict[setting].isActive) and (
settingsDict[setting].clicked):
settingsDict[setting].delValue()
elif key == 'return':
for setting in settingsDict:
if (settingsDict[setting].isActive) and (
settingsDict[setting].clicked):
settingsDict[setting].finalizeValue()
settingsDict[setting].clicked = False
else:
for setting in settingsDict:
if (settingsDict[setting].isActive) and (
settingsDict[setting].clicked):
settingsDict[setting].addValue(key)
elif previewInFocus:
if event.type == sdl2.SDL_KEYDOWN:
key = sdl2.SDL_GetKeyName(event.key.keysym.sym).lower()
if key == 'escape': #exit
# exitSafely()
clickingForDots = False
clickingForFid = False
definingFidFinderBox = False
dotList = []
if event.type == sdl2.SDL_MOUSEMOTION:
if clickingForDots:
clickableTextDict[
'manual'].isActive = True #just making sure
if definingFidFinderBox:
fidFinderBoxSize = abs(fidFinderBoxX -
(previewWindow.size[0] -
event.button.x))
else:
for clickableText in clickableTextDict:
if not (clickableText in ['lag', 'f2f']):
clickableTextDict[clickableText].checkIfActive(
event)
if event.type == sdl2.SDL_MOUSEBUTTONDOWN:
if clickingForDots:
if clickingForFid:
if not definingFidFinderBox:
definingFidFinderBox = True
fidFinderBoxX = previewWindow.size[
0] - event.button.x
fidFinderBoxY = event.button.y
fidFinderBoxSize = 0
else:
definingFidFinderBox = False
clickingForFid = False
fidFinderBoxSize = abs(fidFinderBoxX -
(previewWindow.size[0] -
event.button.x))
dotList.append(
dotObj(
name='fid',
isFid=True,
fid=None,
xPixel=fidFinderBoxX * previewDownsize,
yPixel=fidFinderBoxY * previewDownsize,
radiusPixel=fidFinderBoxSize *
previewDownsize,
blinkCriterion=settingsDict['blink'].
value / 100.0,
blurSize=settingsDict['blur'].value,
filterSize=settingsDict['filter'].value
))
else:
clickX = (previewWindow.size[0] - event.button.x)
clickY = event.button.y
if len(dotList) == 1:
dotList.append(
dotObj(
name='left',
isFid=False,
fid=dotList[0],
xPixel=clickX * previewDownsize,
yPixel=clickY * previewDownsize,
radiusPixel=dotList[0].radiusPixel,
blinkCriterion=settingsDict['blink'].
value / 100.0,
blurSize=settingsDict['blur'].value,
filterSize=settingsDict['filter'].value
))
else:
dotList.append(
dotObj(
name='right',
isFid=False,
fid=dotList[0],
xPixel=clickX * previewDownsize,
yPixel=clickY * previewDownsize,
radiusPixel=dotList[1].radiusPixel,
blinkCriterion=settingsDict['blink'].
value / 100.0,
blurSize=settingsDict['blur'].value,
filterSize=settingsDict['filter'].value
))
clickingForDots = False
manTextSurf = sdl2.sdlttf.TTF_RenderText_Blended_Wrapped(
font, 'Manual',
sdl2.pixels.SDL_Color(r=0,
g=0,
b=255,
a=255),
previewWindow.size[0]).contents
else:
if clickableTextDict['settings'].isActive:
if (sdl2.SDL_GetWindowFlags(settingsWindow.window)
& sdl2.SDL_WINDOW_SHOWN):
settingsWindow.hide()
else:
settingsWindow.show()
elif clickableTextDict['auto'].isActive:
waitingforHaar = False
doHaar = True #triggers haar detection for next frame
dotList = []
elif clickableTextDict['manual'].isActive:
clickingForDots = True
clickingForFid = True
definingFidFinderBox = False
dotList = []
elif clickableTextDict['calibrate'].isActive:
doneCalibration = False
calibrationChild = fileForker.childClass(
childFile='calibrationChild')
calibrationChild.initDict[
'timestampMethod'] = timestampMethod
calibrationChild.initDict[
'viewingDistance'] = viewingDistance
calibrationChild.initDict[
'stimDisplayWidth'] = stimDisplayWidth
calibrationChild.initDict[
'stimDisplayRes'] = stimDisplayRes
calibrationChild.initDict[
'stimDisplayPosition'] = stimDisplayPosition
calibrationChild.initDict[
'mirrorDisplayPosition'] = mirrorDisplayPosition
calibrationChild.initDict[
'mirrorDownSize'] = mirrorDownSize
calibrationChild.initDict[
'calibrationDotSizeInDegrees'] = calibrationDotSizeInDegrees
calibrationChild.initDict[
'manualCalibrationOrder'] = manualCalibrationOrder
calibrationChild.start()
calibrating = True
checkCalibrationStopTime = False
queueDataToCalibrationChild = False
#do haar detection if requested
if doHaar:
doHaar = False #only enter this section once
faceDetectionImage = cv2.resize(
image,
dsize=(image.shape[1] / faceDetectionScale,
image.shape[0] / faceDetectionScale),
interpolation=cv2.INTER_NEAREST)
detectedFaces = faceCascade.detectMultiScale(
faceDetectionImage
) #,scaleFactor=1.1,minNeighbors=3,minSize=(10,10))
if len(detectedFaces) == 0: #no faces found!
print 'no faces found!' #do something here
else:
faceX, faceY, faceW, faceH = rescaleBiggestHaar(
detected=detectedFaces,
scale=faceDetectionScale,
addToX=0,
addToY=0)
leftFaceImage = image[faceY:(faceY + faceH),
faceX:(faceX + faceW / 2)]
eyeLeftDetectionImage = cv2.resize(
leftFaceImage,
dsize=(leftFaceImage.shape[1] / eyeDetectionScale,
leftFaceImage.shape[0] / eyeDetectionScale),
interpolation=cv2.INTER_NEAREST)
detectedEyeLefts = eyeLeftCascade.detectMultiScale(
eyeLeftDetectionImage
) #,minSize=(leftFaceImage.shape[0]/8,leftFaceImage.shape[0]/8))
rightFaceImage = image[faceY:(faceY + faceH),
(faceX + faceW / 2):(faceX + faceW)]
eyeRightDetectionImage = cv2.resize(
rightFaceImage,
dsize=(rightFaceImage.shape[1] / eyeDetectionScale,
rightFaceImage.shape[0] / eyeDetectionScale),
interpolation=cv2.INTER_NEAREST)
detectedEyeRights = eyeRightCascade.detectMultiScale(
eyeRightDetectionImage
) #,minSize=(rightFaceImage.shape[0]/8,rightFaceImage.shape[0]/8))
if (len(detectedEyeLefts)
== 0) | (len(detectedEyeRights)
== 0): #at least one eye is missing!
if (len(detectedEyeLefts) == 0):
print 'left eye missing' #do something here
else:
print 'right eye missing' #do something here
else:
eyeLeftX, eyeLeftY, eyeLeftW, eyeLeftH = rescaleBiggestHaar(
detected=detectedEyeLefts,
scale=eyeDetectionScale,
addToX=faceX,
addToY=faceY)
eyeRightX, eyeRightY, eyeRightW, eyeRightH = rescaleBiggestHaar(
detected=detectedEyeRights,
scale=eyeDetectionScale,
addToX=faceX + faceW / 2,
addToY=faceY)
#initialize fid
dotList.append(
dotObj(name='fid',
isFid=True,
fid=None,
xPixel=faceX + faceW / 2,
yPixel=(faceY + (eyeLeftY + eyeRightY) / 2) / 2,
radiusPixel=(eyeLeftH + eyeRightH) / 4,
blinkCriterion=settingsDict['blink'].value /
100.0,
blurSize=settingsDict['blur'].value,
filterSize=settingsDict['filter'].value))
#initialize left
dotList.append(
dotObj(name='left',
isFid=False,
fid=dotList[0],
xPixel=eyeLeftX + eyeLeftW / 2,
yPixel=eyeLeftY + eyeLeftH / 2,
radiusPixel=eyeLeftH / 2,
blinkCriterion=settingsDict['blink'].value /
100.0,
blurSize=settingsDict['blur'].value,
filterSize=settingsDict['filter'].value))
#initialize right
dotList.append(
dotObj(name='right',
isFid=False,
fid=dotList[0],
xPixel=eyeRightX + eyeRightW / 2,
yPixel=eyeRightY + eyeRightH / 2,
radiusPixel=eyeRightH / 2,
blinkCriterion=settingsDict['blink'].value /
100.0,
blurSize=settingsDict['blur'].value,
filterSize=settingsDict['filter'].value))
#update the dots given the latest image
for i in range(len(dotList)):
dotList[i].update(img=image,
fid=dotList[0],
blinkCriterion=settingsDict['blink'].value /
100.0,
blurSize=settingsDict['blur'].value,
filterSize=settingsDict['filter'].value)
# print 'ok'
#some post-processing
blinkHappened = False
saccadeHappened = False
if len(dotList) == 3:
if dotList[0].lost:
dotList = []
print 'fid lost'
elif (dotList[1].lostCount > 30) or (dotList[2].lostCount > 30):
print "lost lots"
if (not dotList[1].blinkHappened) and (
not dotList[2].blinkHappened
): #only reset if not blinking
dotList = []
elif dotList[1].blinkHappened and dotList[2].blinkHappened:
blinkHappened = True
else:
#compute gaze location to check for saccades
xCoefLeft, xCoefRight, yCoefLeft, yCoefRight = calibrationCoefs
if dotList[1].lost: #left missing, use right
xLoc = xCoefRight[0] + xCoefRight[1] * dotList[
2].x2 + xCoefRight[2] * dotList[2].y2 + xCoefRight[
3] * dotList[2].y2 * dotList[2].x2
yLoc = yCoefRight[0] + yCoefRight[1] * dotList[
2].x2 + yCoefRight[2] * dotList[2].y2 + yCoefRight[
3] * dotList[2].y2 * dotList[2].x2
elif dotList[2].lost: #right missing, use left
xLoc = xCoefLeft[0] + xCoefLeft[1] * dotList[
1].x2 + xCoefLeft[2] * dotList[1].y2 + xCoefLeft[
3] * dotList[2].y2 * dotList[1].x2
yLoc = yCoefLeft[0] + yCoefLeft[1] * dotList[
1].x2 + yCoefLeft[2] * dotList[1].y2 + yCoefLeft[
3] * dotList[2].y2 * dotList[1].x2
elif dotList[1].lost and dotList[
2].lost: #both missing, use last
xLoc = lastLocs[0]
yLoc = lastLocs[1]
else: #both present, use average
xLocLeft = xCoefLeft[0] + xCoefLeft[1] * dotList[
1].x2 + xCoefLeft[2] * dotList[1].y2 + xCoefLeft[
3] * dotList[1].y2 * dotList[1].x2
yLocLeft = yCoefLeft[0] + yCoefLeft[1] * dotList[
1].x2 + yCoefLeft[2] * dotList[1].y2 + yCoefLeft[
3] * dotList[1].y2 * dotList[1].x2
xLocRight = xCoefRight[0] + xCoefRight[1] * dotList[
2].x2 + xCoefRight[2] * dotList[2].y2 + xCoefRight[
3] * dotList[2].y2 * dotList[2].x2
yLocRight = yCoefRight[0] + yCoefRight[1] * dotList[
2].x2 + yCoefRight[2] * dotList[2].y2 + yCoefRight[
3] * dotList[2].y2 * dotList[2].x2
xLoc = (xLocLeft + xLocRight) / 2.0
yLoc = (yLocLeft + yLocRight) / 2.0
if None not in lastLocs:
locDiff = (((xLoc - lastLocs[0])**2) +
((yLoc - lastLocs[1])**2))**.5
if doneCalibration:
saccadeCriterion = settingsDict['saccade'].value
else:
saccadeCriterion = settingsDict[
'saccade0'].value / 100.0
if locDiff > saccadeCriterion:
saccadeHappened = True
lastLocs = [xLoc, yLoc]
if queueDataToParent:
qFrom.put([
'eyeData',
[
str.format('{0:.3f}', imageTime), xLoc, yLoc,
dotlist[1].radius2, dotlist[2].radius2,
saccadeHappened, blinkHappened, dotList[1].lost,
dotList[2].lost, dotList[1].blinkHappened,
dotList[2].blinkHappened
]
])
#play sounds as necessary
if doSounds:
if (not saccadeSound.stillPlaying()) and (
not blinkSound.stillPlaying()):
if blinkHappened:
blinkSound.play()
elif saccadeHappened:
saccadeSound.play()
#do drawing
if previewDownsize != 1:
image = cv2.resize(image,
dsize=previewWindow.size,
interpolation=cv2.INTER_NEAREST)
image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
if clickingForDots:
if clickingForFid:
if definingFidFinderBox:
cv2.circle(image, (fidFinderBoxX, fidFinderBoxY),
fidFinderBoxSize,
color=(255, 0, 0, 255),
thickness=1)
for dot in dotList:
ellipse = ((dot.ellipse[0][0] / previewDownsize,
dot.ellipse[0][1] / previewDownsize),
(dot.ellipse[1][0] / previewDownsize,
dot.ellipse[1][1] / previewDownsize), dot.ellipse[2])
if dot.blinkHappened or dot.lost:
dotColor = (0, 0, 255, 255)
else:
dotColor = (0, 255, 0, 255)
cv2.ellipse(image, ellipse, color=dotColor, thickness=1)
image = numpy.rot90(image)
previewWindowArray[:, :, 0:3] = image
frameToFrameTimeList.append(imageTime - lastTime)
lastTime = imageTime
displayLagList.append(getTime() - imageTime)
if len(displayLagList) > 30:
displayLagList.pop(0)
frameToFrameTimeList.pop(0)
clickableTextDict['lag'].valueText = str(
int(numpy.median(displayLagList) * 1000))
clickableTextDict['lag'].updateSurf()
clickableTextDict['f2f'].valueText = str(
int(numpy.median(frameToFrameTimeList) * 1000))
clickableTextDict['f2f'].updateSurf()
for clickableText in clickableTextDict:
clickableTextDict[clickableText].draw(previewWindowSurf)
previewWindow.refresh()
thisRefreshTime = getTime()
# print (thisRefreshTime - lastRefreshTime)*1000
lastRefreshTime = thisRefreshTime
if (sdl2.SDL_GetWindowFlags(settingsWindow.window)
& sdl2.SDL_WINDOW_SHOWN):
sdl2.ext.fill(settingsWindowSurf.contents,
sdl2.pixels.SDL_Color(r=0, g=0, b=0, a=255))
for setting in settingsDict:
settingsDict[setting].draw(settingsWindowSurf)
settingsWindow.refresh()
#calibration stuff
if calibrating:
if not calibrationChild.qFrom.empty():
message = calibrationChild.qFrom.get()
if message == 'startQueing':
queueDataToCalibrationChild = True
elif message[0] == 'stopQueing':
calibrationStopTime = message[1]
checkCalibrationStopTime = True
elif message[0] == 'calibrationCoefs':
calibrationCoefs = message[1]
calibrating = False
doneCalibration = True
calibrationChild.stop()
del calibrationChild
lastLocs = []
qFrom.put(['calibrationComplete', message])
queueDataToParent = True
else:
print message
if checkCalibrationStopTime:
if imageTime > calibrationStopTime:
queueDataToCalibrationChild = False
calibrationChild.qTo.put('doneQueing')
checkCalibrationStopTime = False
if queueDataToCalibrationChild:
if len(dotList) > 0:
calibrationChild.qTo.put([
imageTime, dotList[1].x2, dotList[1].y2, dotList[2].x2,
dotList[2].y2
])
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Writing Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load texture
texture = loadTexture(b'res/point.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLQuadRenderer.create(1.0) # type: GLQuadRenderer
renderer.enableBlending(True)
renderer.setBlendingFunctions(gl.GL_SRC_ALPHA, gl.GL_ONE)
renderer.setTexturingMode(spk.TEXTURE_2D)
renderer.setTexture(texture)
renderer.setTextureBlending(gl.GL_MODULATE)
renderer.setScale(0.05, 0.05)
renderer.enableRenderingHint(spk.DEPTH_TEST, False)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | spk.FLAG_SIZE
model_mutable = spk.FLAG_ALPHA | spk.FLAG_SIZE
model = spk.Model.create(model_enable,
model_mutable) # type: spk.Model
model.setParam(spk.PARAM_ALPHA, 5.0,
0.0) # the particles will fade as the die
model.setParam(spk.PARAM_SIZE, 1.0,
15.0) # the particles will enlarge over time
model.setLifeTime(5.0, 6.0)
self.model = model
# create Emitter
# We set up a spheric emitter that emits in all direction with a very small force
# in order to slightly displace the particles
emitter = spk.RandomEmitter.create()
emitter.setForce(0.01, 0.01)
self.emitter = emitter # uses it at later directly
# create Group
group = spk.Group.create(model, 14000) # type: spk.Group
group.setRenderer(renderer)
group.setFriction(
-0.3) # negative friction: The particles will accelerate over time
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleY = 0.0
self.angleX = 0.0
self.camPosZ = 5.0
self.add = False
self.oldX = 0
self.oldY = 0
self.oldZ = 0
self.offset = 0.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
# This computes the ratio to go from screen coordinates to universe coordinates
self.screenToUniverse = 2.0 * self.camPosZ * math.tan(
45.0 * 0.5 * math.pi / 180.0) / self.height
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Flakes Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLPointRenderer.create(1.0) # type: GLPointRenderer
renderer.setBlending(
spk.BLENDING_ADD
) # blending method between particles(additive blending)
renderer.enableRenderingHint(spk.DEPTH_TEST,
False) # notifying not to use depth info
renderer.setAlphaTestThreshold(0.8)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA # use color channels(RGBA)
model = spk.Model.create(model_enable) # type: spk.Model
model.setParam(spk.PARAM_RED, 1.0)
model.setParam(spk.PARAM_GREEN, 0.8)
model.setParam(spk.PARAM_BLUE, 0.3)
model.setParam(spk.PARAM_ALPHA, 0.4)
model.setImmortal(True) # particle is immortal
self.model = model
# no Emitter
# create Modifier
self.sphere = spk.Sphere.create(spk.Vector3D(), 1.0)
obstacle = spk.Obstacle.create(self.sphere) # type: spk.Obstacle
obstacle.setFriction(0.9)
obstacle.setBouncingRatio(0.9)
self.obstacle = obstacle
# create Group
self.NB_PARTICLES = [10000, 25000, 50000, 100000, 200000, 500000]
group = spk.Group.create(model,
self.NB_PARTICLES[-1]) # type: spk.Group
group.addModifier(obstacle)
group.setRenderer(renderer)
group.setGravity(spk.Vector3D(0.0, -0.5, 0.0))
group.setFriction(0.2)
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleX = 0.0
self.angleZ = 0.0
self.camPosZ = 2.75
self.particleIndex = 2
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Fire Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load textures
txFire = loadTexture(b'res/fire2.bmp',
gl.GL_ALPHA,
gl.GL_CLAMP,
mipmap=True)
txSmoke = loadTexture(b'res/explosion.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# lighting
light_ambient = [0.15, 0.15, 0.25, 1.0]
light_diffuse = [1.0, 0.75, 0.25, 1.0]
gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, light_ambient)
gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, light_diffuse)
gl.glLightf(gl.GL_LIGHT0, gl.GL_QUADRATIC_ATTENUATION, 20.0)
mat_ambient = [0.2, 0.2, 0.2, 1.0]
mat_diffuse = [1.0, 1.0, 1.0, 1.0]
gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT, mat_ambient)
gl.glMaterialfv(gl.GL_FRONT_AND_BACK, gl.GL_DIFFUSE, mat_diffuse)
gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, light_ambient)
gl.glLightModelf(gl.GL_LIGHT_MODEL_LOCAL_VIEWER, 1.0)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init PyWavefront
self.scene = pywavefront.Wavefront('./res/SceneFireCamp.obj')
# init SPARK(pyspk)
# random seed initialization
spk.setRandomSeed(int(time.time()))
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
fireRenderer = GLQuadRenderer.create() # type: GLQuadRenderer
fireRenderer.setScale(0.3, 0.3)
fireRenderer.setTexturingMode(spk.TEXTURE_2D)
fireRenderer.setTexture(txFire)
fireRenderer.setTextureBlending(gl.GL_MODULATE)
fireRenderer.setBlending(spk.BLENDING_ADD)
fireRenderer.enableRenderingHint(spk.DEPTH_WRITE, False)
fireRenderer.setAtlasDimensions(2, 2)
self.fireRenderer = fireRenderer
smokeRenderer = GLQuadRenderer.create() # type: GLQuadRenderer
smokeRenderer.setScale(0.3, 0.3)
smokeRenderer.setTexturingMode(spk.TEXTURE_2D)
smokeRenderer.setTexture(txSmoke)
smokeRenderer.setTextureBlending(gl.GL_MODULATE)
smokeRenderer.setBlending(spk.BLENDING_ALPHA)
smokeRenderer.enableRenderingHint(spk.DEPTH_WRITE, False)
smokeRenderer.setAtlasDimensions(2, 2)
self.smokeRenderer = smokeRenderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
fire_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | \
spk.FLAG_SIZE | spk.FLAG_ANGLE | spk.FLAG_TEXTURE_INDEX
fire_mutable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_ALPHA | spk.FLAG_ANGLE
fire_random = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_TEXTURE_INDEX | spk.FLAG_ANGLE
fire_interpolated = spk.FLAG_SIZE
fireModel = spk.Model.create(fire_enable, fire_mutable, fire_random,
fire_interpolated) # type: spk.Model
fireModel.setParam(spk.PARAM_RED, 0.8, 0.9, 0.8,
0.9) # [min,max]on birth, [min,max]on death
fireModel.setParam(spk.PARAM_GREEN, 0.5, 0.6, 0.5, 0.6)
fireModel.setParam(spk.PARAM_BLUE, 0.3)
fireModel.setParam(spk.PARAM_ALPHA, 0.4, 0.0) # on birth, on death
minAngle, maxAngle = 0.0, 2.0 * math.pi
fireModel.setParam(spk.PARAM_ANGLE, minAngle, maxAngle, minAngle,
maxAngle)
fireModel.setParam(spk.PARAM_TEXTURE_INDEX, 0.0, 4.0)
fireModel.setLifeTime(1.0, 1.5)
ip_size = fireModel.getInterpolator(spk.PARAM_SIZE)
ip_size.addEntry(0.5, 2.0, 5.0)
ip_size.addEntry(1.0, 0.0)
self.fireModel = fireModel
smoke_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA | \
spk.FLAG_SIZE | spk.FLAG_ANGLE | spk.FLAG_TEXTURE_INDEX
smoke_mutable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_SIZE | spk.FLAG_ANGLE
smoke_random = spk.FLAG_TEXTURE_INDEX | spk.FLAG_ANGLE
smoke_interpolated = spk.FLAG_ALPHA
smokeModel = spk.Model.create(smoke_enable, smoke_mutable,
smoke_random,
smoke_interpolated) # type: spk.Model
smokeModel.setParam(spk.PARAM_RED, 0.3, 0.2)
smokeModel.setParam(spk.PARAM_GREEN, 0.25, 0.2)
smokeModel.setParam(spk.PARAM_BLUE, 0.2)
smokeModel.setParam(spk.PARAM_ALPHA, 0.2, 0.0)
smokeModel.setParam(spk.PARAM_SIZE, 5.0, 10.0)
smokeModel.setParam(spk.PARAM_TEXTURE_INDEX, 0.0, 4.0)
smokeModel.setParam(spk.PARAM_ANGLE, 0.0, 2.0 * math.pi, 0.0,
2.0 * math.pi)
smokeModel.setLifeTime(5.0, 5.0)
ip_alpha = smokeModel.getInterpolator(spk.PARAM_ALPHA)
ip_alpha.addEntry(0.0, 0.0)
ip_alpha.addEntry(0.2, 0.2)
ip_alpha.addEntry(1.0, 0.0)
self.smokeModel = smokeModel
# create Emitter
fireEmitter1 = spk.StraightEmitter.create(spk.Vector3D(0.0, 1.0, 0.0))
fireEmitter1.setZone(
spk.Sphere.create(spk.Vector3D(0.0, -1.0, 0.0), 0.5))
fireEmitter1.setFlow(40)
fireEmitter1.setForce(1.0, 2.5)
fireEmitter2 = spk.StraightEmitter.create(spk.Vector3D(1.0, 0.6, 0.0))
fireEmitter2.setZone(
spk.Sphere.create(spk.Vector3D(0.15, -1.2, 0.075), 0.1))
fireEmitter2.setFlow(15)
fireEmitter2.setForce(0.5, 1.5)
fireEmitter3 = spk.StraightEmitter.create(spk.Vector3D(
-0.6, 0.8, -0.8))
fireEmitter3.setZone(
spk.Sphere.create(spk.Vector3D(-0.375, -1.15, -0.375), 0.3))
fireEmitter3.setFlow(15)
fireEmitter3.setForce(0.5, 1.5)
fireEmitter4 = spk.StraightEmitter.create(spk.Vector3D(-0.8, 0.5, 0.2))
fireEmitter4.setZone(
spk.Sphere.create(spk.Vector3D(-0.255, -1.2, 0.225), 0.2))
fireEmitter4.setFlow(10)
fireEmitter4.setForce(0.5, 1.5)
fireEmitter5 = spk.StraightEmitter.create(spk.Vector3D(0.1, 0.8, -1.0))
fireEmitter5.setZone(
spk.Sphere.create(spk.Vector3D(-0.075, -1.2, -0.3), 0.2))
fireEmitter5.setFlow(10)
fireEmitter5.setForce(0.5, 1.5)
smokeEmitter = spk.SphericEmitter.create(spk.Vector3D(0.0, 1.0, 0.0),
0.0, 0.5 * math.pi)
smokeEmitter.setZone(spk.Sphere.create(spk.Vector3D(), 1.2))
smokeEmitter.setFlow(25)
smokeEmitter.setForce(0.5, 1.0)
# no Modifier
# create Group
fireGroup = spk.Group.create(fireModel, 135) # type: spk.Group
fireGroup.addEmitter(fireEmitter1)
fireGroup.addEmitter(fireEmitter2)
fireGroup.addEmitter(fireEmitter3)
fireGroup.addEmitter(fireEmitter4)
fireGroup.addEmitter(fireEmitter5)
fireGroup.setRenderer(fireRenderer)
fireGroup.setGravity(spk.Vector3D(0.0, 3.0, 0.0))
self.fireGroup = fireGroup
smokeGroup = spk.Group.create(smokeModel, 135) # type: spk.Group
smokeGroup.addEmitter(smokeEmitter)
smokeGroup.setRenderer(smokeRenderer)
smokeGroup.setGravity(spk.Vector3D(0.0, 0.4, 0.0))
self.smokeGroup = smokeGroup
# create System
system = spk.System.create() # type: spk.System
system.addGroup(fireGroup)
system.addGroup(smokeGroup)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.renderEnv = True
self.angleY = 30.0
self.angleX = 25.0
self.camPosZ = 12.0
self.smoke = True
self.lightTime = 0
self.nbParticles = ''
self.fps = ''
self.strSmoke = 'SMOKE: ON'
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Basic Demo", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load Texture
texture = loadTexture(b'res/point.bmp', gl.GL_ALPHA, gl.GL_CLAMP)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLPointRenderer.create(1.0) # type: GLPointRenderer
renderer.setType(
spk.POINT_SPRITE) # using Point Sprite(require >=OpenGL2.0)
renderer.setTexture(texture) # use the texture on drawing
renderer.setTextureBlending(gl.GL_MODULATE)
renderer.enableWorldSize(
True
) # true: unit is adjusted with the screen, false: unit is pixel(fixed)
GLPointRenderer.setPixelPerUnit(45.0 * math.pi / 180.0, self.height)
renderer.setSize(0.05)
renderer.setBlending(
spk.BLENDING_ADD
) # blending method between particles(additive blending)
renderer.enableRenderingHint(spk.DEPTH_WRITE,
False) # notifying not to use depth info
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA # use color channels(RGBA)
model = spk.Model.create(model_enable) # type: spk.Model
model.setParam(spk.PARAM_ALPHA,
1.0) # alpha is fixed(RGB are changed later)
model.setLifeTime(8.0, 8.0) # particle's life time is 8.0[sec]
self.model = model
# create Emitter
emit_dir = spk.Vector3D(0.0, 1.0, 0.0)
emit_center = spk.Vector3D(0.0, 0.015, 0.0)
minangle = 0.1 * math.pi # zenith angle(min)
maxangle = 0.1 * math.pi # zenith angle(max)
emitter = spk.SphericEmitter.create(
emit_dir, minangle, maxangle) # type: spk.SphericEmitter
emitter.setZone(
spk.Point.create(emit_center),
True) # particles are randomly placed in the specified zone
emitter.setFlow(1000) # max number of particles
emitter.setForce(1.5, 1.5) # emittion power
# create Modifier
groundplane = spk.Plane.create()
bouncing = 0.6 # bouncing ratio(coefficient of restitution)
friction = 1.0 # coefficient of friction
obstacle = spk.Obstacle.create(groundplane, spk.INTERSECT_ZONE,
bouncing, friction)
# create Group
maxparticle = 5000 # upper limit number of particles
group = spk.Group.create(model, maxparticle) # type: spk.Group
group.addEmitter(emitter)
group.addModifier(obstacle)
group.setRenderer(renderer)
group.setGravity(spk.Vector3D(0.0, -0.8, 0.0))
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleY = 0.0
self.angleX = 45.0
self.camPosZ = 5.0
self.nbParticles = ''
self.fps = ''
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height):
self.width = width
self.height = height
# init SDL
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1)
self.window = sdl2.SDL_CreateWindow(
b"SPARK(&pyspk) Collision Demo2", sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, width, height,
sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL)
sdl2.SDL_CaptureMouse(True)
# init OpenGL
self.context = sdl2.SDL_GL_CreateContext(self.window)
sdl2.SDL_GL_SetSwapInterval(0)
gl.glClearColor(0.0, 0.0, 0.0, 1.0)
surface = sdl2.SDL_GetWindowSurface(self.window)
gl.glViewport(0, 0, surface.contents.w, surface.contents.h)
# load Texture
texture = loadTexture(b'res/ball.bmp', gl.GL_RGBA, gl.GL_CLAMP)
# init FTGL
if not notext:
font = FTGL.TextureFont('res/font.ttf')
font.FaceSize(24)
self.font = font
# init SPARK(pyspk)
# step configuration
spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms
spk.System.useAdaptiveStep(
0.001,
0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps)
# create Renderer
renderer = GLPointRenderer.create(1.0) # type: GLPointRenderer
renderer.setType(
spk.POINT_SPRITE) # using Point Sprite(require >=OpenGL2.0)
renderer.setTexture(texture) # use the texture on drawing
renderer.enableWorldSize(
True
) # true: unit is adjusted with the screen, false: unit is pixel(fixed)
GLPointRenderer.setPixelPerUnit(45.0 * math.pi / 180.0, self.height)
renderer.setSize(0.15)
renderer.setBlending(
spk.BLENDING_NONE
) # blending method between particles(no blending)
renderer.enableRenderingHint(spk.ALPHA_TEST, True)
renderer.setAlphaTestThreshold(0.8)
self.renderer = renderer
self.basicRenderer = GLPointRenderer.create(
1.0) # bare renderer for comparison(F4)
# create Model
model_enable = spk.FLAG_RED | spk.FLAG_GREEN | spk.FLAG_BLUE | spk.FLAG_ALPHA # use color channels(RGBA)
model = spk.Model.create(model_enable) # type: spk.Model
model.setImmortal(True) # particle is immortal
self.model = model
# no Emitter
# create Modifier
self.sphere = spk.Sphere.create(spk.Vector3D(), 1.0 - 0.15 / 2.0)
self.cube = spk.AABox.create(spk.Vector3D(),
spk.Vector3D(1.2, 1.2, 1.2))
self.obstacle = spk.Obstacle.create(self.sphere, spk.EXIT_ZONE, 0.9,
0.9) # type: spk.Obstacle
self.obstacle.setZone(self.sphere)
collision = spk.Collision.create(0.15, 0.9)
# create Group
self.NB_PARTICLES = 250
group = spk.Group.create(model, self.NB_PARTICLES) # type: spk.Group
group.addModifier(self.obstacle)
group.addModifier(collision)
group.setRenderer(renderer)
group.setGravity(spk.Vector3D())
group.setFriction(0.1)
self.group = group
# create System
system = spk.System.create() # type: spk.System
system.addGroup(group)
self.system = system
print('SPARK FACTORY AFTER INIT :')
spk.Factory.getInstance().traceAll()
# init Variables
self.running = True
self.paused = False
self.deltaTime = 0
self.step = 0
self.text = 2
self.renderValue = 0
self.angleX = 0.0
self.angleZ = 0.0
self.camPosZ = 2.75
self.nbParticles = ''
self.fps = ''
self.strZone = 'ZONE: SPHERE'
self.frames = [sdl2.SDL_GetTicks() - 1]
self.lasttime = self.frames[-1]
def __init__(self, width, height, scale=1):
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
self.window = sdl2.SDL_CreateWindow(b"Subway Time", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED,
width * scale, height * scale, sdl2.SDL_WINDOW_SHOWN)
self.window_surface = sdl2.SDL_GetWindowSurface(self.window)
self.scale = scale
