def testKeyEvents(self):
def onKeyDown(event):
if event.keystring == 'A' and event.keycode == 65 and event.unicode == 65:
self.keyDownCalled = True
def onKeyUp(event):
if event.keystring == 'A' and event.keycode == 65 and event.unicode == 65:
self.keyUpCalled = True
def onSubscribeKeyDown(event):
self.subscribeKeyDownCalled = True
def onSubscribeKeyUp(event):
self.subscribeKeyUpCalled = True
root = self.loadEmptyScene()
root.setEventHandler(avg.Event.KEY_DOWN, avg.Event.NONE, onKeyDown)
root.setEventHandler(avg.Event.KEY_UP, avg.Event.NONE, onKeyUp)
player.subscribe(avg.Player.KEY_DOWN, onSubscribeKeyDown)
player.subscribe(avg.Player.KEY_UP, onSubscribeKeyUp)
self.start(False,
(lambda: Helper.fakeKeyEvent(avg.Event.KEY_DOWN, 65, 65, "A", 65,
avg.KEYMOD_NONE),
lambda: self.assert_(self.keyDownCalled and self.subscribeKeyDownCalled),
lambda: Helper.fakeKeyEvent(avg.Event.KEY_UP, 65, 65, "A", 65,
avg.KEYMOD_NONE),
lambda: self.assert_(self.keyUpCalled and self.subscribeKeyUpCalled)
))
def onInit(self):
self.mediadir = getMediaDir(__file__)
self.game = None
self.text_size = 20
self.text_line = Point2D(0, self.text_size)
self.margin = Point2D(20, 20)
self.background = create_node(self, 'rect',
size=self.size, fillcolor='000000', fillopacity=1)
self.game_node = create_node(self, 'div',
pos=self.margin + self.text_line/2,
size=self.size - self.margin*2 - self.text_line/2)
self.create_button(
self, self.show_about_box, 'About', 1,
self.margin - self.text_line/2, 'left')
exit_button_pos = avg.Point2D(self.size.x/2,
self.margin.y-self.text_line.y/2)
self.create_button(self, self.__stop, 'Exit', 1, exit_button_pos,
'center')
self.level_button_nodes = []
self.game_over_box = self.create_game_over_box()
self.about_box = self.create_about_box()
player.subscribe(player.KEY_DOWN, self.__onKeyDown)
self.start_game()
def goGreen():
self.__greenSound.play()
self.__countdownNode.fillcolor = '00FF00'
avg.LinearAnim(self.__countdownNode, 'fillopacity', 1000, 1, 0).start()
for c in self.__controllers:
c.start()
player.subscribe(player.ON_FRAME, self.__onGameFrame)
def testPublisher(self):
def onDown(event):
self.assert_(event.type == avg.Event.CURSOR_DOWN)
curEvent = player.getCurrentEvent()
self.assert_(curEvent.type == avg.Event.CURSOR_DOWN)
self.assert_(curEvent.when == event.when)
self.downCalled = True
def unsubscribe():
self.assert_(self.img.isSubscribed(avg.Node.CURSOR_DOWN, onDown))
self.img.unsubscribe(avg.Node.CURSOR_DOWN, onDown)
self.assert_(not(self.img.isSubscribed(avg.Node.CURSOR_DOWN, onDown)))
self.assert_(self.img.getNumSubscribers(avg.Node.CURSOR_DOWN) == 0)
self.downCalled = False
self.assertException(
lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, onDown))
def initUnsubscribeInEvent(useMessageID):
self.subscriberID = self.img.subscribe(avg.Node.CURSOR_DOWN,
lambda event: onDownUnsubscribe(event, useMessageID))
def onDownUnsubscribe(event, useMessageID):
if useMessageID:
self.img.unsubscribe(avg.Node.CURSOR_DOWN, self.subscriberID)
self.assertException(lambda:
self.img.unsubscribe(avg.Node.CURSOR_DOWN, self.subscriberID))
else:
self.img.unsubscribe(self.subscriberID)
self.assertException(lambda: self.img.unsubscribe(self.subscriberID))
self.downCalled = True
def onFrame():
self.onFrameCalled = True
self.downCalled = False
self.onFrameCalled = False
root = self.loadEmptyScene()
player.subscribe(player.ON_FRAME, onFrame)
self.img = avg.ImageNode(pos=(0,0), href="rgb24-65x65.png", parent=root)
self.img.subscribe(avg.Node.CURSOR_DOWN, onDown)
self.assertException(lambda: self.img.subscribe(23, onDown))
self.assertException(lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, 23))
self.start(False,
(lambda: self.fakeClick(10,10),
lambda: self.assert_(self.downCalled),
lambda: self.assert_(self.onFrameCalled),
unsubscribe,
lambda: self.fakeClick(10,10),
lambda: self.assert_(not(self.downCalled)),
lambda: initUnsubscribeInEvent(True),
lambda: self.fakeClick(10,10),
lambda: self.assert_(self.downCalled),
lambda: initUnsubscribeInEvent(False),
lambda: self.fakeClick(10,10),
lambda: self.assert_(self.downCalled),
))
def testLoop(self):
def onEOF():
self.eof = True
def onFrame():
if self.eof:
if not threaded:
self.compareImage("testVideoLoop")
player.stop()
for audio, threaded in [(False, False), (False, True), (True, True)]:
self.eof = False
if audio:
player.setFakeFPS(-1)
else:
player.setFakeFPS(25)
root = self.loadEmptyScene()
if audio:
node = avg.SoundNode(parent=root, loop=True,
href="48kHz_16bit_mono.wav")
else:
node = avg.VideoNode(parent=root, loop=True, fps=25, size=(96,96),
threaded=threaded, href="mpeg1-48x48.mov")
node.subscribe(avg.Node.END_OF_FILE, onEOF)
node.play()
player.subscribe(player.ON_FRAME, onFrame)
player.play()
def onInit(self):
self.mediadir = getMediaDir(__file__)
self.__gameMusic = avg.SoundNode(href='Fire_Birds.mp3', loop=True,
volume=0.75, parent=self)
self.__scrollingBg = ScrollingBackground(self)
self.__shadowDiv = avg.DivNode(parent=self)
self.__gameDiv = avg.DivNode(size=self.size, parent=self)
self.__guiDiv = avg.DivNode(parent=self)
bg = avg.ImageNode(href='gui_frame.png', parent=self.__guiDiv)
self.__guiDiv.pos = (0, self.height - bg.height)
self.__lifeCounter = LifeCounter(pos=(8, 12), parent=self.__guiDiv)
gunCtrl = GunControl(pos=(300, 54), parent=self.__guiDiv)
self.__scoreCounter = ScoreCounter(pos=(1142, 54), parent=self.__guiDiv)
self.__enemies = []
for i in xrange(2):
self.__createEnemy()
self.__player = PlayerAircraft(self.__shadowDiv, gunCtrl, parent=self.__gameDiv)
enemyMask = avg.Bitmap(self.mediadir + '/enemy.gif')
self.__playerCollisionDetector = collisiondetector.CollisionDetector(
enemyMask, avg.Bitmap(self.mediadir + '/spitfire.gif'))
self.__bulletCollisionDetector = collisiondetector.CollisionDetector(
enemyMask, avg.Bitmap(self.mediadir + '/bullet.gif'))
self.__keyStates = dict.fromkeys(PlayerAircraft.ACTION_KEYS, False)
self.__frameHandlerId = None
self.__spawnTimeoutId = None
self.__gameMusic.play()
self.__start()
player.subscribe(player.KEY_DOWN, self.__onKeyDown)
player.subscribe(player.KEY_UP, self.__onKeyUp)
def setup(self, onKeyDownCb, onKeyUpCb):
player.subscribe(avg.Player.KEY_DOWN, self.__onKeyDown)
player.subscribe(avg.Player.KEY_UP, self.__onKeyUp)
self.__onKeyDownCb = onKeyDownCb
self.__onKeyUpCb = onKeyUpCb
self.__keyCaptionsNode = KeysCaptionNode(pos=(5,5), parent=player.getRootNode())
def _initNodes(self):
self._setSizeFromBmp(self._bmp)
self._positionNodes(self.size)
if player.isPlaying():
self._renderImages()
else:
player.subscribe(avg.Player.PLAYBACK_START, self._renderImages)
def __startIdleDemo(self):
self.__idleTimeoutID = None
avg.fadeOut(self.__gameDiv, 200)
self.__ctrlDiv.sensitive = False
for p in self.__idlePlayers:
p.setReady()
self.__demoDownHandlerID = self.__gameDiv.subscribe(avg.Node.CURSOR_DOWN,
lambda e:self.__stopIdleDemo())
player.subscribe(player.ON_FRAME, self.__onIdleFrame)
def init(self):
self.node = avg.VideoNode(href=args[0], loop=True, accelerated=not (options.disableAccel))
self.node.play()
if self.node.hasAlpha():
self.__makeAlphaBackground()
self._parentNode.appendChild(self.node)
self.curFrameWords = avg.WordsNode(parent=self._parentNode, pos=(10, 10), fontsize=10)
self.curTimeWords = avg.WordsNode(parent=self._parentNode, pos=(10, 22), fontsize=10)
self.framesQueuedWords = avg.WordsNode(parent=self._parentNode, pos=(10, 34), fontsize=10)
player.subscribe(player.ON_FRAME, self.onFrame)
def testRun(self, onFrameHandlersList=[], mainDiv=None, runtimeOptions={}):
assert type(onFrameHandlersList) == list
self.__onFrameHandlersList = onFrameHandlersList
player.subscribe(player.ON_FRAME, self.__onFrame)
player.setFramerate(10000)
player.assumePixelsPerMM(1)
for k, v in self.CUSTOM_SETTINGS.iteritems():
self.settings.set(k, v)
if mainDiv is None:
mainDiv = libavg.app.MainDiv()
self.run(mainDiv, **runtimeOptions)
def start(self, warnOnImageDiff, actions):
self.__setupPlayer()
self.__dumpTestFrames = (os.getenv("AVG_DUMP_TEST_FRAMES") is not None)
self.__delaying = False
self.__warnOnImageDiff = warnOnImageDiff
self.assert_(player.isPlaying() == 0)
self.actions = flatten(actions)
self.curFrame = 0
player.subscribe(player.ON_FRAME, self.__nextAction)
player.setFramerate(10000)
player.assumePixelsPerMM(1)
player.play()
self.assert_(player.isPlaying() == 0)
def init(self):
'''
Create placeholders for the example. A single ImageNode is used to show
the pictures.
'''
self.__imageNode = libavg.avg.ImageNode(pos=(10, 20), parent=self._parentNode)
self.__spinner = libavg.avg.RectNode(color='222222',
fillopacity=1, size=(40, 40), active=False,
pos=(10, self._parentNode.size.y - 50), parent=self._parentNode)
self.__infoNode = libavg.avg.WordsNode(text='Press space to load the first image',
fontsize=11, pos=(10, 5), parent=self._parentNode)
self.__pics = sys.argv[1:]
self.__currentPic = -1
player.subscribe(player.ON_FRAME, self.__onFrame)
def _setup(self):
self.__frameHandlerID = player.subscribe(avg.Player.ON_FRAME,
self._nextFrameTimeSample)
self._numSamples = 0
self._lastCurUsage = 0
self._maxFrameTime = 0
self._values = []
def onInit(self):
'''
Create placeholders for the example. A single ImageNode is used to show
the pictures.
'''
self.__imageNode = avg.ImageNode(pos=(10, 20), parent=self)
self.__spinner = avg.RectNode(color='222222', fillopacity=1, size=(40, 40),
active=False, pos=(10, self.size.y - 50), parent=self)
self.__infoNode = avg.WordsNode(text='Press space to load the first image',
fontsize=11, pos=(10, 5), parent=self)
self.__pics = sys.argv[1:]
self.__currentPic = -1
player.subscribe(player.ON_FRAME, self.__onFrame)
app.keyboardmanager.bindKeyDown(keyname="Space",
handler=self.__requestNextBitmap, help="Request next bitmap")
def _enter(self):
g_KbManager.push()
g_KbManager.bindKey('d', self.__trackerSetDebugImages, 'tracker set debug images')
g_KbManager.bindKey('b', self.__bigCamImage, 'big cam image')
g_KbManager.bindKey('up', self.__keyFuncUP, 'select parameter up')
g_KbManager.bindKey('down', self.__keyFuncDOWN, 'select parameter down')
g_KbManager.bindKey('left', self.__keyFuncLEFT, 'value up')
g_KbManager.bindKey('right', self.__keyFuncRIGHT, 'value down')
g_KbManager.bindKey('page up', self.__keyFuncPAGEUp, 'value up * 10')
g_KbManager.bindKey('page down', self.__keyFuncPAGEDown, 'value down * 10')
g_KbManager.bindKey('s', self.__trackerSaveConfig, 'save configuration')
g_KbManager.bindKey('g', self.__toggleGUI, 'toggle GUI')
g_KbManager.bindKey('c', self.__startCoordCalibration,
'start geometry calibration')
g_KbManager.bindKey('w', self.__saveTrackerIMG, 'SAVE trager image')
g_KbManager.bindKey('h', self.appStarter.tracker.resetHistory, 'RESET history')
self.appStarter.showTrackerImage()
self.mainNode.active=True
self.tracker.setDebugImages(True, True)
avg.fadeIn(self.mainNode, 400, 1)
Bitmap = self.tracker.getImage(avg.IMG_DISTORTED) # Why is this needed?
self.__onFrameID = player.subscribe(player.ON_FRAME, self.__onFrame)
#grandparent = self.parentNode.getParent()
#if grandparent:
# grandparent.reorderChild(grandparent.indexOf(self.parentNode), grandparent.getNumChildren()-1)
self.displayParams()
if self.hideMainNodeTimeout:
player.clearInterval(self.hideMainNodeTimeout)
def __start(self):
assert(not self.__frameHandlerId and not self.__spawnTimeoutId)
self.__lifeCounter.reset()
self.__scoreCounter.reset()
self.__player.reset()
self.__frameHandlerId = player.subscribe(player.ON_FRAME, self.__onFrame)
self.__spawnTimeoutId = player.setInterval(self.ENEMY_SPAWN_TIMEOUT,
self.__spawnEnemy)
def showTrackerImage(self):
if self.__showTrackerImage:
return
self.__showTrackerImage = True
self.__updateTrackerImageInterval = \
player.subscribe(player.ON_FRAME, self.__updateTrackerImage)
self.__trackerImageNode.opacity = 1
self.tracker.setDebugImages(False, True)
def onInit(self):
self.__setupMultitouch()
avg.WordsNode.addFontDir(libavg.utils.getMediaDir(__file__, 'fonts'))
self.mediadir = libavg.utils.getMediaDir(__file__)
self.__elapsedTime = 0
self.__pointer = None
self.sequencer = Sequencer(self)
norm.setSize(self.size)
self.createGame()
player.subscribe(player.KEY_DOWN, self.sequencer.propagateKeyDown)
player.subscribe(player.KEY_UP, self.sequencer.propagateKeyUp)
self.subscribe(self.CURSOR_DOWN, self.onCursorDown)
self.subscribe(self.CURSOR_MOTION, self.onCursorMotion)
def __init__(self, friction, moveHandler, stopHandler):
self.__friction = friction
self.__moveHandler = moveHandler
self.__stopHandler = stopHandler
self.__transVel = avg.Point2D(0, 0)
self.__curPivot = avg.Point2D(0, 0)
self.__angVel = 0
self.__sizeVel = avg.Point2D(0, 0)
self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onDragFrame)
def __onDown(self, event):
if self.__contact is None:
self.__contact = event.contact
event.contact.subscribe(avg.Contact.CURSOR_UP, self.__onUp)
self.__rawContactCircle.opacity = 1
self.__filteredContactCircle.opacity = 1
self.__filters = [
filter.OneEuroFilter(self.__minCutoff,self.__cutoffSlope),
filter.OneEuroFilter(self.__minCutoff,self.__cutoffSlope)]
self.__onFrame = player.subscribe(player.ON_FRAME, self.__moveContact)
def __init__(self, src, endsExtent, orientation=Orientation.HORIZONTAL,
minExtent=-1, parent=None, **kwargs):
super(AccordionNode, self).__init__(**kwargs)
self.registerInstance(self, parent)
if endsExtent < 0:
raise RuntimeError(
"Illegal value for endsExtent: %i. Must be >= 0"%endsExtent)
elif endsExtent == 0:
# 1 has same effect as 0 - we just create one-pixel wide start and end images.
endsExtent = 1
self.__bmp = avg.Bitmap(src)
self._orientation = orientation
# XXX: Check if bmp is smaller than min size
self.__startImg = self.__createImageNode(self.__bmp, endsExtent)
self.__centerImg = self.__createImageNode(self.__bmp, 1)
self.__endImg = self.__createImageNode(self.__bmp, endsExtent)
self.__endsExtent = endsExtent
if minExtent == -1:
self.__minExtent = self.__endsExtent*2+1
else:
self.__minExtent = minExtent
if orientation == Orientation.HORIZONTAL:
if self.__baseSize.x != 0:
self.__baseWidth = self.__baseSize.x
if self.__baseSize.y == 0:
self.__baseHeight = self.__startImg.height
else:
if self.__baseSize.y != 0:
self.__baseHeight = self.__baseSize.y
if self.__baseSize.x == 0:
self.__baseWidth = self.__startImg.width
self.__positionNodes(self.__baseSize)
if player.isPlaying():
self.__renderImages()
else:
player.subscribe(avg.Player.PLAYBACK_START, self.__renderImages)
def __init__(self, friction, moveHandler, stopHandler):
self.__friction = friction
self.__moveHandler = moveHandler
self.__stopHandler = stopHandler
self.__transVel = avg.Point2D(0, 0)
self.__curPivot = avg.Point2D(0, 0)
self.__angVel = 0
self.__sizeVel = avg.Point2D(0, 0)
self.__frameHandlerID = player.subscribe(player.ON_FRAME,
self.__onDragFrame)
def testVideoLoop(self):
def onEOF():
self.eof = True
def onFrame():
if self.eof:
if not(threaded):
self.compareImage("testVideoLoop")
player.stop()
for threaded in [False, True]:
self.eof = False
player.setFakeFPS(25)
root = self.loadEmptyScene()
videoNode = avg.VideoNode(parent=root, loop=True, fps=25, size=(96,96),
threaded=threaded, href="mpeg1-48x48.mov")
videoNode.subscribe(avg.Node.END_OF_FILE, onEOF)
videoNode.play()
player.subscribe(player.ON_FRAME, onFrame)
player.play()
def testVideoLoop(self):
def onEOF():
self.eof = True
def onFrame():
if self.eof:
if not(threaded):
self.compareImage("testVideoLoop")
player.stop()
for threaded in [False, True]:
self.eof = False
player.setFakeFPS(25)
root = self.loadEmptyScene()
videoNode = avg.VideoNode(parent=root, loop=True, fps=25, size=(96,96),
threaded=threaded, href="mpeg1-48x48.mpg")
videoNode.subscribe(avg.Node.END_OF_FILE, onEOF)
videoNode.play()
player.subscribe(player.ON_FRAME, onFrame)
player.play()
def init(self):
self.curFrame = 0
global g_options
self.optdict = {}
for attr in dir(g_options):
if attr[0] != "_":
self.optdict[attr] = eval("g_options.%s" % attr)
avg.logger.info("Creating camera:")
avg.logger.info("driver=%(driver)s device=%(device)s" % self.optdict)
avg.logger.info("width=%(width)d height=%(height)d pixelformat=%(pixelFormat)s" % self.optdict)
avg.logger.info("unit=%(unit)d framerate=%(framerate)d fw800=%(fw800)s" % self.optdict)
self.camNode = avg.CameraNode(
driver=g_options.driver,
device=g_options.device,
unit=g_options.unit,
fw800=g_options.fw800,
framerate=g_options.framerate,
capturewidth=g_options.width,
captureheight=g_options.height,
pixelformat=g_options.pixelFormat,
)
player.getRootNode().appendChild(self.camNode)
if not g_options.noinfo:
self.infoText = (
"Driver=%(driver)s (dev=%(device)s unit=%(unit)d) %(width)dx%(height)d@%(framerate)f" % self.optdict
)
avg.WordsNode(
text=self.infoText,
color="ff3333",
pos=(5, 5),
fontsize=14,
rawtextmode=True,
parent=player.getRootNode(),
)
frameText = avg.WordsNode(color="ff3333", pos=(5, 25), fontsize=14, parent=player.getRootNode())
player.subscribe(player.ON_FRAME, lambda: self.updateFrameDisplay(frameText))
def __onDown(self, event):
nodeGone = self._handleNodeGone()
if not(nodeGone):
if self.__maxContacts == None or len(self._contacts) < self.__maxContacts:
event.contact.subscribe(avg.Contact.CURSOR_MOTION, self.__onMotion)
event.contact.subscribe(avg.Contact.CURSOR_UP, self.__onUp)
self._contacts.add(event.contact)
if len(self._contacts) == 1:
self.__frameHandlerID = player.subscribe(player.ON_FRAME,
self._onFrame)
self.__dirty = True
return self._handleDown(event)
def __onDown(self, event):
if self.__contact is None:
self.__contact = event.contact
event.contact.subscribe(avg.Contact.CURSOR_UP, self.__onUp)
self.__rawContactCircle.opacity = 1
self.__filteredContactCircle.opacity = 1
self.__filters = [
filter.OneEuroFilter(self.__minCutoff, self.__cutoffSlope),
filter.OneEuroFilter(self.__minCutoff, self.__cutoffSlope)
]
self.__onFrame = player.subscribe(player.ON_FRAME,
self.__moveContact)
def onInit(self):
self.mediadir = getMediaDir(__file__)
self.__gameMusic = avg.SoundNode(href='Fire_Birds.mp3',
loop=True,
volume=0.75,
parent=self)
self.__scrollingBg = ScrollingBackground(self)
self.__shadowDiv = avg.DivNode(parent=self)
self.__gameDiv = avg.DivNode(size=self.size, parent=self)
self.__guiDiv = avg.DivNode(parent=self)
bg = avg.ImageNode(href='gui_frame.png', parent=self.__guiDiv)
self.__guiDiv.pos = (0, self.height - bg.height)
self.__lifeCounter = LifeCounter(pos=(8, 12), parent=self.__guiDiv)
gunCtrl = GunControl(pos=(300, 54), parent=self.__guiDiv)
self.__scoreCounter = ScoreCounter(pos=(1142, 54),
parent=self.__guiDiv)
self.__enemies = []
for i in xrange(2):
self.__createEnemy()
self.__player = PlayerAircraft(self.__shadowDiv,
gunCtrl,
parent=self.__gameDiv)
enemyMask = avg.Bitmap(self.mediadir + '/enemy.gif')
self.__playerCollisionDetector = collisiondetector.CollisionDetector(
enemyMask, avg.Bitmap(self.mediadir + '/spitfire.gif'))
self.__bulletCollisionDetector = collisiondetector.CollisionDetector(
enemyMask, avg.Bitmap(self.mediadir + '/bullet.gif'))
self.__keyStates = dict.fromkeys(PlayerAircraft.ACTION_KEYS, False)
self.__frameHandlerId = None
self.__spawnTimeoutId = None
self.__gameMusic.play()
self.__start()
player.subscribe(player.KEY_DOWN, self.__onKeyDown)
player.subscribe(player.KEY_UP, self.__onKeyUp)
def __onDown(self, event):
nodeGone = self._handleNodeGone()
if event.contact and not (nodeGone):
if (self.__maxContacts == None
or len(self._contacts) < self.__maxContacts):
event.contact.subscribe(avg.Contact.CURSOR_MOTION,
self.__onMotion)
event.contact.subscribe(avg.Contact.CURSOR_UP, self.__onUp)
self._contacts.add(event.contact)
if len(self._contacts) == 1:
self.__frameHandlerID = player.subscribe(
player.ON_FRAME, self._onFrame)
self.__dirty = True
return self._handleDown(event)
def __init__(self, keyDef, downBmp, feedbackBmp, sticky=False, parent=None,
**kwargs):
self.__keyCode = keyDef[0]
if not(isinstance(self.__keyCode, tuple)):
self.__keyCode = (self.__keyCode,)
kwargs['pos'] = avg.Point2D(keyDef[1])
kwargs['size'] = avg.Point2D(keyDef[2])
if len(keyDef) == 4:
self.__isCommand = keyDef[3]
else:
self.__isCommand = False
super(Key, self).__init__(**kwargs)
self.registerInstance(self, parent)
self.__sticky = sticky
self.__stickyIsDown = False
self.__cursorID = None
if downBmp:
if player.isPlaying():
self.__createImages(downBmp, feedbackBmp)
else:
player.subscribe(avg.Player.PLAYBACK_START,
lambda: self.__createImages(downBmp, feedbackBmp))
def onInit(self):
'''
Create placeholders for the example. A single ImageNode is used to show
the pictures.
'''
self.__imageNode = avg.ImageNode(pos=(10, 20), parent=self)
self.__spinner = avg.RectNode(color='222222',
fillopacity=1,
size=(40, 40),
active=False,
pos=(10, self.size.y - 50),
parent=self)
self.__infoNode = avg.WordsNode(
text='Press space to load the first image',
fontsize=11,
pos=(10, 5),
parent=self)
self.__pics = sys.argv[1:]
self.__currentPic = -1
player.subscribe(player.ON_FRAME, self.__onFrame)
app.keyboardmanager.bindKeyDown(keyname="Space",
handler=self.__requestNextBitmap,
help="Request next bitmap")
def _handleDown(self, event):
self.__startTime = player.getFrameTime()
if self.__stateMachine.state == "IDLE":
self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onFrame)
self.__stateMachine.changeState("DOWN1")
self.__startPos = event.pos
self._setPossible(event)
elif self.__stateMachine.state == "UP1":
if ((event.pos - self.__startPos).getNorm() >
self.__maxDist*player.getPixelsPerMM()):
self.__stateMachine.changeState("IDLE")
self._setFail(event)
else:
self.__stateMachine.changeState("DOWN2")
else:
assert(False), self.__stateMachine.state
def _handleDown(self, event):
self.__startTime = player.getFrameTime()
if self.__stateMachine.state == "IDLE":
self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onFrame)
self.__stateMachine.changeState("DOWN1")
self.__startPos = event.pos
self._setPossible(event)
elif self.__stateMachine.state == "UP1":
if ((event.pos - self.__startPos).getNorm() >
self.__maxDist*player.getPixelsPerMM()):
self.__stateMachine.changeState("IDLE")
self._setFail(event)
else:
self.__stateMachine.changeState("DOWN2")
else:
assert(False), self.__stateMachine.state
def testTimeoutOnFrameHandling(self):
def onTimeOut():
self.callCount += 1
def onFrame():
player.clearInterval(self.longTimeoutId)
self.longTimeoutId = None
player.setTimeout(0, onTimeOut)
player.unsubscribe(player.ON_FRAME, self.onFrameID)
self.initDefaultImageScene()
self.callCount = 0
# long running dummy timeout. Will be removed before the timer elapses.
self.longTimeoutId = player.setTimeout(10000, lambda: None)
self.onFrameID = player.subscribe(player.ON_FRAME, onFrame)
self.start(False, (None, None, None, lambda: self.assert_(self.callCount == 1)))
def _handleDown(self, event):
numContacts = len(self._contacts)
self.__newPhase()
if self.__isFiltered():
self.__filters[event.contact] = [
filter.OneEuroFilter(mincutoff=TransformRecognizer.FILTER_MIN_CUTOFF,
beta=TransformRecognizer.FILTER_BETA),
filter.OneEuroFilter(mincutoff=TransformRecognizer.FILTER_MIN_CUTOFF,
beta=TransformRecognizer.FILTER_BETA)]
if numContacts == 1:
if self.__inertiaHandler:
self.__inertiaHandler.abort()
self._setEnd(event)
self._setDetected(event)
self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onFrame)
if self.__friction != -1:
self.__inertiaHandler = InertiaHandler(self.__friction,
self.__onInertiaMove, self.__onInertiaStop)
def _handleDown(self, event):
numContacts = len(self._contacts)
self.__newPhase()
if self.__isFiltered():
self.__filters[event.contact] = [
filter.OneEuroFilter(mincutoff=TransformRecognizer.FILTER_MIN_CUTOFF,
beta=TransformRecognizer.FILTER_BETA),
filter.OneEuroFilter(mincutoff=TransformRecognizer.FILTER_MIN_CUTOFF,
beta=TransformRecognizer.FILTER_BETA)]
if numContacts == 1:
if self.__inertiaHandler:
self.__inertiaHandler.abort()
self._setEnd(event)
self._setDetected(event)
self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onFrame)
if self.__friction != -1:
self.__inertiaHandler = InertiaHandler(self.__friction,
self.__onInertiaMove, self.__onInertiaStop)
def testTimeoutOnFrameHandling(self):
def onTimeOut():
self.callCount += 1
def onFrame():
player.clearInterval(self.longTimeoutId)
self.longTimeoutId = None
player.setTimeout(0, onTimeOut)
player.unsubscribe(player.ON_FRAME, self.onFrameID)
self.initDefaultImageScene()
self.callCount = 0
# long running dummy timeout. Will be removed before the timer elapses.
self.longTimeoutId = player.setTimeout(10000, lambda: None)
self.onFrameID = player.subscribe(player.ON_FRAME, onFrame)
self.start(False, (
None,
None,
None,
lambda: self.assert_(self.callCount == 1),
))
def init(g_avg, catchKeyboard=True, repeatDelay=0.2, charDelay=0.1):
"""
Initialization routine for the module
This method should be called immediately after avg file
load (Player.loadFile())
@param g_avg: avg package
@param catchKeyboard: boolean, if true events from keyboard are catched
@param repeatDelay: wait time (seconds) before starting to repeat a key which
is held down
@param charDelay: delay among character repetition (of an steadily pressed key)
"""
global avg, g_RepeatDelay, g_CharDelay
avg = g_avg
g_RepeatDelay = repeatDelay
g_CharDelay = charDelay
player.subscribe(player.ON_FRAME, _onFrame)
if catchKeyboard:
player.subscribe(avg.Player.KEY_DOWN, _onKeyDown)
player.subscribe(avg.Player.KEY_UP, _onKeyUp)
def init(g_avg, catchKeyboard=True, repeatDelay=0.2, charDelay=0.1):
"""
Initialization routine for the module
This method should be called immediately after avg file
load (Player.loadFile())
@param g_avg: avg package
@param catchKeyboard: boolean, if true events from keyboard are catched
@param repeatDelay: wait time (seconds) before starting to repeat a key which
is held down
@param charDelay: delay among character repetition (of an steadily pressed key)
"""
global avg, g_RepeatDelay, g_CharDelay
avg = g_avg
g_RepeatDelay = repeatDelay
g_CharDelay = charDelay
player.subscribe(player.ON_FRAME, _onFrame)
if catchKeyboard:
player.subscribe(avg.Player.KEY_DOWN, _onKeyDown)
player.subscribe(avg.Player.KEY_UP, _onKeyUp)
def onInit(self):
if self.argvoptions.fake == 'True':
config_app.fake_data_mode = True
config_app.data_mode_string = 'fake'
if self.argvoptions.session != '-1':
config_app.SESSION = int(self.argvoptions.session)
self.__key_messages = {}
self._study_handler = None
if config_app.study_mode:
with open("assets/study_preparations/key_messages.json") as f:
self.__key_messages = json.load(f)
self._study_handler = StudyHandler(
block_question_file=config_app.study_tasks_file,
study_order_file=config_app.study_order_file,
session_id=config_app.SESSION)
add_aid_lines_to_factory()
add_intersections_methods_to_method_holder()
add_selection_methods_to_method_holder()
add_snapping_methods_to_method_holder()
self.__grid_groups = [
[0, 1, 2, 3],
[4, 5, 6, 7, 8, 9, 10],
[11],
[12],
[13],
[16],
[17],
[22],
[23],
[24],
[25],
[26],
[27],
[32],
[33],
[34],
[35],
[36],
[37],
[38],
[39],
[40],
[41],
[42],
[43],
[44, 45, 46, 47, 48],
[49, 50, 51, 52, 53],
[54],
]
self.__grid_labels = {}
sql = SqlInterface(
sql_db_path=config_app.db_filename[config_app.data_mode_string],
table_mapper_method=table_name_to_query,
query_file="examples/data/crime_data.queries")
if len(self.__grid_labels) == 0:
for grid_group in self.__grid_groups:
for grid_id in grid_group:
self.__grid_labels[grid_id] = T.tl(
msg=sql.get_query_label(str(grid_id)),
lang=config_app.default_language)
self.__grid_labels[grid_id] += " [{}]".format(
grid_id) if not config_app.study_mode else ""
self.__grid_labels[21] = T.tl(
msg="Weapons <--> Types", lang=config_app.default_language) + (
" [21]" if not config_app.study_mode else "")
self.__grid_labels[15] = T.tl(
msg="Map of Crimes/Neighborhood",
lang=config_app.default_language) + (
" [15]" if not config_app.study_mode else "")
if not os.path.exists(config_app.sql_result_dump_filename[
config_app.data_mode_string]) or config_app.force_sql_reload:
start_time = time.time()
last_time = start_time
sql_results = {}
for grid_group in self.__grid_groups:
for grid_id in grid_group:
sql_results[str(grid_id)] = sql.get_query_results(
str(grid_id))
now = time.time()
print "Duration:", now - last_time, "| loaded chart for query ", self.__grid_labels[
grid_id]
last_time = now
for query_name in [
"map data from neighborhoods",
"districts per neighborhood",
"crime types per neighborhood", "crime type names",
"highest weapon usage per neighborhood"
]:
sql_results[query_name] = sql.get_query_results(query_name)
now = time.time()
print "Duration:", now - last_time, "| loaded chart for map"
print "The complete creation needed ", time.time() - start_time
# dumping sql results for later use
try:
if not os.path.exists("tmp"):
os.makedirs("tmp")
with open(
config_app.sql_result_dump_filename[
config_app.data_mode_string], 'wb') as f:
pickle.dump(sql_results, f, 0)
print 'Saved sql results locally!'
except IOError:
print 'Error: Failed to save sql results locally!'
self.__wall_divico = None
self.__touch_test_view = None
self.__touch_visualization_overlay = None
self.__task_text_view = None
self.__task_text_view_canvas = None
self.__task_text_view_image_bottom = None
self.__task_text_view_image_top = None
self.__phase_block_label = None
self.__interaction_activation_label = None
if config_app.show_test_touch_view and config_app.study_mode:
self.__draw_pre_view()
else:
self.__draw_main_view()
player.subscribe(player.KEY_DOWN, self.__on_key_down)
def onInit(self):
player.subscribe(player.KEY_DOWN, self.onKey)
player.subscribe(player.KEY_UP, self.onKey)
def onEOF():
node.seekToTime(0)
player.subscribe(avg.Player.ON_FRAME, onFrame)
def init():
player.subscribe(player.KEY_DOWN, _onKeyDown)
player.subscribe(player.KEY_UP, _onKeyUp)
avg.logger.debug('Keyboardmanager initialized', LOGCAT)
def onUp(self):
player.unsubscribe(player.ON_FRAME, self.__frameHandlerID)
self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onInertiaFrame)
self.__onInertiaFrame()
def init(self):
self.singleKeyPress('s')
self.singleKeyPress('s')
self.timeStarted = time.time()
self.timerId = player.subscribe(player.ON_FRAME, self.onFrame)
def testPublisher(self):
def onDown(event):
self.assert_(event.type == avg.Event.CURSOR_DOWN)
curEvent = player.getCurrentEvent()
self.assert_(curEvent.type == avg.Event.CURSOR_DOWN)
self.assert_(curEvent.when == event.when)
self.downCalled = True
def unsubscribe():
self.assert_(self.img.isSubscribed(avg.Node.CURSOR_DOWN, onDown))
self.img.unsubscribe(avg.Node.CURSOR_DOWN, onDown)
self.assert_(not(self.img.isSubscribed(avg.Node.CURSOR_DOWN, onDown)))
self.assert_(self.img.getNumSubscribers(avg.Node.CURSOR_DOWN) == 0)
self.downCalled = False
self.assertRaises(avg.Exception,
lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, onDown))
def initUnsubscribeInEvent(useMessageID):
self.subscriberID = self.img.subscribe(avg.Node.CURSOR_DOWN,
lambda event: onDownUnsubscribe(event, useMessageID))
def onDownUnsubscribe(event, useMessageID):
if useMessageID:
self.img.unsubscribe(avg.Node.CURSOR_DOWN, self.subscriberID)
self.assertRaises(avg.Exception, lambda:
self.img.unsubscribe(avg.Node.CURSOR_DOWN, self.subscriberID))
else:
self.img.unsubscribe(self.subscriberID)
self.assertRaises(avg.Exception,
lambda: self.img.unsubscribe(self.subscriberID))
self.downCalled = True
def onFrame():
self.onFrameCalled = True
self.downCalled = False
self.onFrameCalled = False
root = self.loadEmptyScene()
player.subscribe(player.ON_FRAME, onFrame)
self.img = avg.ImageNode(pos=(0,0), href="rgb24-65x65.png", parent=root)
self.img.subscribe(avg.Node.CURSOR_DOWN, onDown)
self.assertRaises(Exception, lambda: self.img.subscribe(23, onDown))
self.assertRaises(avg.Exception,
lambda: self.img.subscribe(avg.Node.CURSOR_DOWN, 23))
self.assertRaises(avg.Exception,
lambda: self.img.unsubscribe(avg.Node.CURSOR_DOWN, 23))
self.start(False,
(lambda: self.fakeClick(10,10),
lambda: self.assert_(self.downCalled),
lambda: self.assert_(self.onFrameCalled),
unsubscribe,
lambda: self.fakeClick(10,10),
lambda: self.assert_(not(self.downCalled)),
lambda: initUnsubscribeInEvent(True),
lambda: self.fakeClick(10,10),
lambda: self.assert_(self.downCalled),
lambda: initUnsubscribeInEvent(False),
lambda: self.fakeClick(10,10),
lambda: self.assert_(self.downCalled),
))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from libavg import avg, player
def moveText():
global node
if node.x < 200:
node.x += 1
canvas = player.createMainCanvas(size=(640, 480))
rootNode = canvas.getRootNode()
node = avg.WordsNode(pos=(10, 10), text="Hello World", parent=rootNode)
player.subscribe(player.ON_FRAME, moveText)
player.play()
def play(self):
if not self.__playing:
self.__playing = True
self.__frameHandlerID = player.subscribe(player.ON_FRAME,
self.__onFrame)
