def onInit(self):
if not os.path.isdir(self._imagesDir):
avg.logger.error('Directory [%s] not found' % self._imagesDir)
exit(1)
avg.logger.info('Scanning directory [%s] ...' % self._imagesDir)
imgExts = tuple(IMAGE_EXTENSIONS + [ext.upper() for ext in IMAGE_EXTENSIONS])
self.__imgFiles = [os.path.join(self._imagesDir, imgFile) for imgFile in
filter(lambda f: f.endswith(imgExts), os.listdir(self._imagesDir))]
if not self.__imgFiles:
avg.logger.error('No image files found, '
'scanned file extensions:\n%s' % (', '.join(imgExts)))
exit(1)
l = len(self.__imgFiles)
avg.logger.info('%d image file%s found' % (l, 's' if l > 1 else ''))
shuffle(self.__imgFiles)
self.__slidesDiv = avg.DivNode(size=self.size, parent=self)
# ping-pong two slides for cross-fade transition
self.__newSlide = Slide(parent=self.__slidesDiv)
self.__oldSlide = Slide(href=self.__imgFiles[0], parent=self.__slidesDiv)
# HIDE_DONE notifications will trigger asynchronous pre-loading of the next image
self.__newSlide.subscribe(Slide.HIDE_DONE, self.__asyncPreload)
self.__oldSlide.subscribe(Slide.HIDE_DONE, self.__asyncPreload)
self.__currentIdx = 0
self.__changeSlide()
player.setInterval(CHANGE_INTERVAL, self.__changeSlide)
def onInit(self):
if not os.path.isdir(self._imagesDir):
avg.logger.error('Directory [%s] not found' % self._imagesDir)
exit(1)
avg.logger.info('Scanning directory [%s] ...' % self._imagesDir)
imgExts = tuple(IMAGE_EXTENSIONS +
[ext.upper() for ext in IMAGE_EXTENSIONS])
self.__imgFiles = [
os.path.join(self._imagesDir, imgFile) for imgFile in filter(
lambda f: f.endswith(imgExts), os.listdir(self._imagesDir))
]
if not self.__imgFiles:
avg.logger.error('No image files found, '
'scanned file extensions:\n%s' %
(', '.join(imgExts)))
exit(1)
l = len(self.__imgFiles)
avg.logger.info('%d image file%s found' % (l, 's' if l > 1 else ''))
shuffle(self.__imgFiles)
self.__slidesDiv = avg.DivNode(size=self.size, parent=self)
# ping-pong two slides for cross-fade transition
self.__newSlide = Slide(parent=self.__slidesDiv)
self.__oldSlide = Slide(href=self.__imgFiles[0],
parent=self.__slidesDiv)
# HIDE_DONE notifications will trigger asynchronous pre-loading of the next image
self.__newSlide.subscribe(Slide.HIDE_DONE, self.__asyncPreload)
self.__oldSlide.subscribe(Slide.HIDE_DONE, self.__asyncPreload)
self.__currentIdx = 0
self.__changeSlide()
player.setInterval(CHANGE_INTERVAL, self.__changeSlide)
def __init__(self, name, all_joints=True, speed_in_ms=None):
self.__body_tracking_log = logging.getLogger(name)
if all_joints:
self.__joint_types = {
OSCKinectJoint.OKS_SPINE_BASE: 0,
OSCKinectJoint.OKS_SPINE_MID: 1,
OSCKinectJoint.OKS_SPINE_SHOULDER: 20,
OSCKinectJoint.OKS_NECK: 2,
OSCKinectJoint.OKS_HEAD: 3,
OSCKinectJoint.OKS_SHOULDER_RIGHT: 8,
OSCKinectJoint.OKS_SHOULDER_LEFT: 4,
OSCKinectJoint.OKS_ELBOW_RIGHT: 9,
OSCKinectJoint.OKS_ELBOW_LEFT: 5,
OSCKinectJoint.OKS_WRIST_RIGHT: 10,
OSCKinectJoint.OKS_WRIST_LEFT: 6,
OSCKinectJoint.OKS_HAND_RIGHT: 11,
OSCKinectJoint.OKS_HAND_LEFT: 7,
OSCKinectJoint.OKS_THUMB_RIGHT: 24,
OSCKinectJoint.OKS_THUMB_LEFT: 22,
OSCKinectJoint.OKS_HAND_TIP_RIGHT: 23,
OSCKinectJoint.OKS_HAND_TIP_LEFT: 21,
OSCKinectJoint.OKS_HIP_RIGHT: 16,
OSCKinectJoint.OKS_HIP_LEFT: 12,
OSCKinectJoint.OKS_KNEE_RIGHT: 17,
OSCKinectJoint.OKS_KNEE_LEFT: 13,
OSCKinectJoint.OKS_ANKLE_RIGHT: 18,
OSCKinectJoint.OKS_ANKLE_LEFT: 14,
OSCKinectJoint.OKS_FOOT_RIGHT: 19,
OSCKinectJoint.OKS_FOOT_LEFT: 15
}
# else:
# self.__joint_types = [
# OSCKinectJoint.OKS_HEAD,
# OSCKinectJoint.OKS_SPINE_MID,
# OSCKinectJoint.OKS_HAND_LEFT,
# OSCKinectJoint.OKS_HAND_RIGHT,
# OSCKinectJoint.OKS_ELBOW_RIGHT,
# OSCKinectJoint.OKS_ELBOW_LEFT
# ]
# handling of body tracking
self.__skeleton_manager = SkeletonManager(kinect_data_ip)
if speed_in_ms is None:
self.__skeleton_manager.start_listening(
skeleton_added=self.__log_skeleton_added,
skeleton_updated=self.__log_skeleton_moved,
skeleton_removed=self.__log_skeleton_removed)
else:
player.setInterval(speed_in_ms, self.__log_on_time)
def _setup(self):
self._interval = player.setInterval(1000, self._nextMemSample)
self.__numSamples = 0
self._usage = [0]
self._maxUsage = [0]
self._minutesUsage = [0]
self._minutesMaxUsage = [0]
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 _setup(self):
self.__interval = player.setInterval(1000, self._nextMemSample)
self.__numSamples = 0
self._usage = [0]
self._maxUsage = [0]
self._minutesUsage = [0]
self._minutesMaxUsage = [0]
self._nextMemSample()
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 __init__(self, pos, icon, waitTime):
if (self.__class__ in self.spawnTimestamp and
player.getFrameTime() - self.spawnTimestamp[self.__class__] < waitTime):
return
else:
self.spawnTimestamp[self.__class__] = player.getFrameTime()
self._state = self.STATE_BUSY
self._tmr = player.setInterval(100, self.__tick)
self._remainingTicks = consts.BONUS_AVAILABILITY_TICKS
self._node = widgets.RIImage(href=icon, pos=pos, parent=self.layer)
diman = avg.LinearAnim(self._node, 'size', self.TRANSITION_TIME,
self._node.getMediaSize() * self.TRANSITION_ZOOM,
self._node.getMediaSize())
opaan = avg.LinearAnim(self._node, 'opacity',
self.TRANSITION_TIME, 0, self.OPACITY)
offsan = avg.LinearAnim(self._node, 'pos', self.TRANSITION_TIME,
Point2D(pos) - self._node.getMediaSize() * self.TRANSITION_ZOOM / 2, pos)
self._anim = avg.ParallelAnim((diman, opaan, offsan), None, self.__ready)
self._anim.start()
self.__cursorid = None
engine.SoundManager.play('bonus_alert.ogg')
def __init__(self, disableMouseFocus=False,
moveCoursorOnTouch=True, textBackgroundNode=None, loupeBackgroundNode=None,
parent=None, **kwargs):
"""
@param parent: parent of the node
@param disableMouseFocus: boolean, prevents that mouse can set focus for
this instance
@param moveCoursorOnTouch: boolean, activate the coursor motion on touch events
"""
super(TextArea, self).__init__(**kwargs)
self.registerInstance(self, parent)
self.__blurOpacity = DEFAULT_BLUR_OPACITY
self.__border = 0
self.__data = []
self.__cursorPosition = 0
textNode = avg.WordsNode(rawtextmode=True)
if textBackgroundNode is not None:
self.appendChild(textBackgroundNode)
if not disableMouseFocus:
self.setEventHandler(avg.Event.CURSOR_UP, avg.Event.MOUSE, self.__onClick)
self.setEventHandler(avg.Event.CURSOR_UP, avg.Event.TOUCH, self.__onClick)
self.appendChild(textNode)
cursorContainer = avg.DivNode()
cursorNode = avg.LineNode(color='000000')
self.appendChild(cursorContainer)
cursorContainer.appendChild(cursorNode)
self.__flashingCursor = False
self.__cursorContainer = cursorContainer
self.__cursorNode = cursorNode
self.__textNode = textNode
self.__loupe = None
self.setFocus(True)
player.setInterval(CURSOR_FLASHING_DELAY, self.__tickFlashCursor)
self.__lastActivity = 0
if moveCoursorOnTouch:
self.__recognizer = gesture.DragRecognizer(eventNode=self, friction=-1,
moveHandler=self.__moveHandler,
detectedHandler=self.__detectedHandler,
upHandler=self.__upHandler)
self.__loupeZoomFactor = 0.5
self.__loupe = avg.DivNode(parent=self, crop=True)
if loupeBackgroundNode is not None:
self.__loupe.appendChild(loupeBackgroundNode)
self.__loupe.size = loupeBackgroundNode.size
else:
self.__loupe.size = (50,50)
avg.RectNode(fillopacity=1, fillcolor="f5f5f5", color="ffffff",
size=self.__loupe.size, parent=self.__loupe)
self.__loupeOffset = (self.__loupe.size[0]/2.0, self.__loupe.size[1]+20)
self.__loupe.unlink()
self.__zoomedImage = avg.DivNode(parent=self.__loupe)
self.__loupeTextNode = avg.WordsNode(rawtextmode=True,
parent=self.__zoomedImage)
self.__loupeCursorContainer = avg.DivNode(parent=self.__zoomedImage)
self.__loupeCursorNode = avg.LineNode(color='000000',
parent=self.__loupeCursorContainer)
self.setStyle()
def __init__(
self,
disableMouseFocus=False,
moveCoursorOnTouch=True,
textBackgroundNode=None,
loupeBackgroundNode=None,
parent=None,
**kwargs
):
"""
@param parent: parent of the node
@param disableMouseFocus: boolean, prevents that mouse can set focus for
this instance
@param moveCoursorOnTouch: boolean, activate the coursor motion on touch events
"""
super(TextArea, self).__init__(**kwargs)
self.registerInstance(self, parent)
self.__blurOpacity = DEFAULT_BLUR_OPACITY
self.__border = 0
self.__data = []
self.__cursorPosition = 0
textNode = avg.WordsNode(rawtextmode=True)
if textBackgroundNode is not None:
self.appendChild(textBackgroundNode)
if not disableMouseFocus:
self.setEventHandler(avg.Event.CURSOR_UP, avg.Event.MOUSE, self.__onClick)
self.setEventHandler(avg.Event.CURSOR_UP, avg.Event.TOUCH, self.__onClick)
self.appendChild(textNode)
cursorContainer = avg.DivNode()
cursorNode = avg.LineNode(color="000000")
self.appendChild(cursorContainer)
cursorContainer.appendChild(cursorNode)
self.__flashingCursor = False
self.__cursorContainer = cursorContainer
self.__cursorNode = cursorNode
self.__textNode = textNode
self.__loupe = None
self.setFocus(True)
player.setInterval(CURSOR_FLASHING_DELAY, self.__tickFlashCursor)
self.__lastActivity = 0
if moveCoursorOnTouch:
self.__recognizer = gesture.DragRecognizer(
eventNode=self,
friction=-1,
moveHandler=self.__moveHandler,
detectedHandler=self.__detectedHandler,
upHandler=self.__upHandler,
)
self.__loupeZoomFactor = 0.5
self.__loupe = avg.DivNode(parent=self, crop=True)
if loupeBackgroundNode is not None:
self.__loupe.appendChild(loupeBackgroundNode)
self.__loupe.size = loupeBackgroundNode.size
else:
self.__loupe.size = (50, 50)
avg.RectNode(
fillopacity=1, fillcolor="f5f5f5", color="ffffff", size=self.__loupe.size, parent=self.__loupe
)
self.__loupeOffset = (self.__loupe.size[0] / 2.0, self.__loupe.size[1] + 20)
self.__loupe.unlink()
self.__zoomedImage = avg.DivNode(parent=self.__loupe)
self.__loupeTextNode = avg.WordsNode(rawtextmode=True, parent=self.__zoomedImage)
self.__loupeCursorContainer = avg.DivNode(parent=self.__zoomedImage)
self.__loupeCursorNode = avg.LineNode(color="000000", parent=self.__loupeCursorContainer)
self.setStyle()
def __init__(self):
session_id = config_app.SESSION
# init loggers: GENERAL EVENTS
self.__general_event_log = logging.getLogger('general')
self.__general_event_log.setLevel(logging.INFO)
# init loggers: BODY TRACKING
name_body_tracking = 'body_tracking'
self.__body_tracking_log = logging.getLogger(name_body_tracking)
self.__body_tracking = BodyTrackingLog(
name_body_tracking,
speed_in_ms=LoggingDefaults.LOG_SPEED_SKELETON_TRACKING)
self.__body_tracking_log.setLevel(logging.INFO)
# init loggers: DEVICE POSITION
self.__devices = {}
self.__device_position_log = logging.getLogger('device_position')
self.__device_position_log.setLevel(logging.INFO)
# init loggers: DEVICE CANVAS TOUCH EVENT
self.__devices_canvas_event_log = logging.getLogger('device_event')
self.__devices_canvas_event_log.setLevel(logging.INFO)
# init loggers: TOUCH
self.__touch_log = logging.getLogger('touch')
self.__touch_log.setLevel(logging.INFO)
# init loggers: TOUCH INJECTION
self.__touch_injection_log = logging.getLogger('touch_injection')
self.__touch_injection_log.setLevel(logging.INFO)
# init format
csv_formatter = logging.Formatter("%(asctime)s.%(msecs)d, %(message)s",
"%Y-%m-%d, %H:%M:%S")
# add general event logging to console
console = logging.StreamHandler()
self.__general_event_log.addHandler(console)
if not config_app.study_mode:
return
# init files and # connect logger and file and formatter
task_file = LogFileHandlerWithHeader(
filename=str('study_logs/session_' + str(session_id) +
'_task.csv'),
header='%s, %s, %s' % ('day, time', 'event_name', 'arguments'))
task_file.setFormatter(csv_formatter)
self.__general_event_log.addHandler(task_file)
body_tracking_file = LogFileHandlerWithHeader(
filename='study_logs/session_' + str(session_id) +
'_body_tracking.csv',
header=self.__body_tracking.get_header_str())
body_tracking_file.setFormatter(csv_formatter)
self.__body_tracking_log.addHandler(body_tracking_file)
device_position_file = LogFileHandlerWithHeader(
filename='study_logs/session_' + str(session_id) +
'_device_position.csv',
header='%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s' %
('day, time', 'device_id', 'rui-proxy_name', 'screen_pos_x_in_px',
'screen_pos_y_in_px', 'space_pos_x_in_m', 'space_pos_y_in_m',
'space_pos_z_in_m', 'yaw_in_rad', 'pitch_in_rad', 'roll_in_rad'))
device_position_file.setFormatter(csv_formatter)
self.__device_position_log.addHandler(device_position_file)
touch_file = LogFileHandlerWithHeader(
filename='study_logs/session_' + str(session_id) + '_touch.csv',
header='%s, %s, %s, %s, %s' %
('day, time', 'pos_x_in_px', 'pos_y_in_px', 'user_id_str',
'event_type_str'))
touch_file.setFormatter(csv_formatter)
self.__touch_log.addHandler(touch_file)
touch_injection_file = LogFileHandlerWithHeader(
filename='study_logs/session_' + str(session_id) +
'_touch_injection.csv',
header='%s, %s, %s, %s, %s' %
('day, time', 'pos_x_in_px', 'pos_y_in_px', 'user_id_str',
'event_type_str'))
touch_injection_file.setFormatter(csv_formatter)
self.__touch_injection_log.addHandler(touch_injection_file)
device_event_file = LogFileHandlerWithHeader(
filename=str('study_logs/session_' + str(session_id) +
'_device_event.csv'),
header=', '.join([
'day, time', 'device_id', 'rui-proxy_name', 'event_type',
'canvas_pos_x_in_px', 'canvas_pos_y_in_px', 'cursor_id'
]))
device_event_file.setFormatter(csv_formatter)
self.__devices_canvas_event_log.addHandler(device_event_file)
# handle logging speed if set in config
if LoggingDefaults.LOG_SPEED_DEVICE_POSITION is not None:
player.setInterval(LoggingDefaults.LOG_SPEED_DEVICE_POSITION,
self.__write_device_on_timeout)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from libavg import avg, player
def moveText():
global node
if node.x < 200:
node.x += 20
else:
player.clearInterval(timer)
canvas = player.createMainCanvas(size=(640,480))
rootNode = canvas.getRootNode()
node = avg.WordsNode(pos=(10,10), text="Hello World", parent=rootNode)
timer = player.setInterval(200, moveText)
player.play()
