def addVideo():
node.unlink(True)
videoNode = avg.VideoNode(parent=root, threaded=False, size=(96,96),
href="mpeg1-48x48.mov")
effect = avg.BlurFXNode()
effect.radius = 0
videoNode.setEffect(effect)
videoNode.play()
def testFXUpdate(self):
# This tests if the FX render-on-demand functionality doesn't forget updates.
def changeTexture():
node.href = "colorramp.png"
def addMaskTex():
node.maskhref = "mask4.png"
node.masksize = (32, 32)
def changeMaskTex():
node.maskhref = "mask2.png"
def changeMaskPos():
node.maskpos = (32, 32)
def changeFX():
effect.radius = 2
def addVideo():
node.unlink(True)
videoNode = avg.VideoNode(parent=root,
threaded=False,
size=(96, 96),
href="mpeg1-48x48.mov")
effect = avg.BlurFXNode()
effect.radius = 0
videoNode.setEffect(effect)
videoNode.play()
root = self.loadEmptyScene()
node = avg.ImageNode(parent=root, href="rgb24alpha-64x64.png")
effect = avg.BlurFXNode()
effect.radius = 0
player.setFakeFPS(25)
self.start(False, (
self.skipIfMinimalShader,
lambda: node.setEffect(effect),
changeTexture,
lambda: self.compareImage("testFXUpdateTex"),
addMaskTex,
lambda: self.compareImage("testFXUpdateMaskTex1"),
changeMaskTex,
lambda: self.compareImage("testFXUpdateMaskTex2"),
changeMaskPos,
lambda: self.compareImage("testFXUpdateMaskPos"),
changeFX,
lambda: self.compareImage("testFXUpdateFX"),
addVideo,
None,
lambda: self.compareImage("testFXUpdateVideo"),
))
def __init__(self, mediabase, shadowdiv, parent=None, **kwargs):
super(_Aircraft, self).__init__(**kwargs)
self.registerInstance(self, parent)
self.__alive = False
self.__aircraftVid = avg.VideoNode(href=mediabase+'.mov', loop=True, parent=self)
self.__aircraftVid.pause()
self.__destroyVid = avg.VideoNode(href='explosion.mov', active=False,
threaded=False, parent=self)
self.__destroyVid.pause()
self.__destroyVid.subscribe(avg.VideoNode.END_OF_FILE, self._hide)
self.__shadowImg = avg.ImageNode(href=mediabase+'.gif', opacity=0.5,
pos=self.pos + _Aircraft.__SHADOW_OFFSET, parent=shadowdiv)
self.__shadowImg.size *= _Aircraft.__SHADOW_SCALE
if not player.isUsingGLES():
self.__shadowImg.setEffect(avg.BlurFXNode(6.0))
self.size = self.__aircraftVid.size
def __init__(self,
id=id,
size=None,
parent=None,
colormap=None,
valuerangemin=None,
valuerangemax=None,
overlay_src=None,
blur_level=1,
**kwargs):
super(HeatMapNode, self).__init__(**kwargs)
self.div_node_wrapper = avg.DivNode(parent=parent,
size=size,
crop=True)
self.blur_canvas = player.createCanvas(id="blur_canvas_" + id,
autorender=True,
multisamplesamples=1,
size=size * (1 - BLUR_CROP_VAL))
self.blur_node = self.blur_canvas.getRootNode()
self.heatmap_node = heatmap.HeatMapNode(parent=self.blur_node,
size=size *
(1 + BLUR_CROP_VAL),
viewportrangemin=(0, 0),
viewportrangemax=(1, 1),
mapsize=(10, 10),
valuerangemin=valuerangemin,
valuerangemax=valuerangemax,
colormap=colormap)
self.blur_FX = avg.BlurFXNode(blur_level)
self.heatmap_node.setEffect(self.blur_FX)
self.img_node = avg.ImageNode(parent=self.div_node_wrapper,
href="canvas:blur_canvas_" + id,
pos=(-size.x * BLUR_CROP_VAL,
-size.y * BLUR_CROP_VAL),
size=size * (1 + BLUR_CROP_VAL))
if overlay_src:
self.overlay = avg.ImageNode(parent=self.div_node_wrapper,
href=overlay_src,
pos=(0, 0),
size=size)
def testBlurFX(self):
def setRadius(radius):
self.effect.radius = radius
def removeFX():
self.node.setEffect(None)
def reAddFX():
self.node.setEffect(self.effect)
def addNewFX():
effect = avg.BlurFXNode(8)
self.node.setEffect(effect)
def addNewFXKWARGS():
effect = avg.BlurFXNode(radius=8)
self.node.setEffect(effect)
root = self.loadEmptyScene()
self.node = avg.ImageNode(parent=root,
pos=(10, 10),
href="rgb24-64x64.png")
self.effect = avg.BlurFXNode()
self.start(False, (
self.skipIfMinimalShader,
lambda: self.node.setEffect(self.effect),
lambda: self.compareImage("testBlurFX1"),
lambda: setRadius(8),
lambda: self.compareImage("testBlurFX2"),
removeFX,
lambda: self.compareImage("testBlurFX3"),
reAddFX,
lambda: self.compareImage("testBlurFX2"),
removeFX,
addNewFX,
lambda: self.compareImage("testBlurFX2"),
removeFX,
addNewFXKWARGS,
lambda: self.compareImage("testBlurFX2"),
lambda: setRadius(300),
))
def setBlur(node):
node.setEffect(avg.BlurFXNode(3))
def __init__(self, session, vis_params, parent, mode="user", use_heatmap=True, label=None,
**kwargs):
"""
:param session: The session this panel is based on.
:type session: Session
:param vis_params:
:type vis_params:
:param mode: The mode that will be used for this panel. Either "user" for user data or "device" for device data.
:type mode: str
:param label: This can be set if a custom label for this view should be given.
:type label: str
:param parent: The parent of this Panel.
:type parent: avg.DivNode
:param kwargs: Other parameters for a VisPanel object.
"""
pos_range = pat_model.pos_range
view_extent = avg.Point2D(pos_range[1][0] - pos_range[0][0], 3.0)
aspect = view_extent.y/view_extent.x
label = label or "Floor {}".format(mode)
super(FloorPanel, self).__init__(label, vis_params, (60, 25), True, aspect, parent=parent, **kwargs)
self.__session_start_time = session.start_time
self.__session_time_offset = session.time_offset
self.__users = session.users
self.__mode = mode
self.__use_heatmap = use_heatmap
self._create_x_axis(
data_range=(pos_range[0][0], pos_range[1][0]),
unit="m",
top_axis=True
)
self._create_y_axis(
data_range=self.__VERTICAL_POS_RANGE,
tick_positions=[0,1,2,3],
unit="m",
hide_rims=True
)
self.__create_wall_rect()
self._create_data_div()
self.__user_nodes = []
self.__user_visibility = [True for _ in range(len(self.__users))]
self.__heatmap_nodes = []
self.__line_movement_nodes = []
for user in self.__users:
color = str(vis_params.get_user_color(user.getUserID()))
node = heatmap.HeatMapNode(
size=self._data_div.size,
viewportrangemin=(pos_range[0][0], self.__VERTICAL_POS_RANGE[0]),
viewportrangemax=(pos_range[1][0], self.__VERTICAL_POS_RANGE[1]),
mapsize=(50,25),
valuerangemin=0,
valuerangemax=6,
colormap=(color, color),
opacitymap=(0,1),
blendmode=global_values.BLEND_MODE,
parent=self._data_div
)
node.setEffect(avg.BlurFXNode(radius=1.2))
self.__heatmap_nodes.append(node)
# Create an empty poly line node.
line_node = avg.PolyLineNode(
parent=self._data_div,
color=color,
strokewidth=2,
opacity=0.45
)
self.__line_movement_nodes.append(line_node)
self.__time_interval = [None, None]
self.__timestamp_words_node = avg.WordsNode(
parent=self._data_div,
color=global_values.COLOR_FOREGROUND,
rawtextmode=True,
alignment="right",
fontsize=global_values.FONT_SIZE / 2,
pos=(self._data_div.width - 3, 3)
)
def addNewFXKWARGS():
effect = avg.BlurFXNode(radius=8)
self.node.setEffect(effect)
def addNewFX():
effect = avg.BlurFXNode(8)
self.node.setEffect(effect)
def __init__(self,
session,
vis_params,
parent,
mode="user",
use_heatmap=False,
label=None,
**kwargs):
"""
:param session: The session this panel is based on.
:type session: Session
:param vis_params:
:type vis_params:
:param mode: The mode that will be used for this panel. Either "user" for user data or "device" for device data.
:type mode: str
:param use_heatmap: Should the heat map for this view be used?
:type use_heatmap: bool
:param label: This can be set if a custom label for this view should be given.
:type label: str
:param parent: The parent of this Panel.
:type parent: avg.DivNode
:param kwargs: Other parameters for a VisPanel object.
"""
pos_range = pat_model.pos_range
view_extent = avg.Point2D(pos_range[1][0] - pos_range[0][0],
pos_range[1][1] - pos_range[0][1])
aspect = view_extent.y / view_extent.x
label = label or "Wall {}".format(mode)
super(WallPanel, self).__init__(label, vis_params, (60, 25), False,
aspect, parent, **kwargs)
self.__users = session.users
self.__mode = mode
self.__use_heatmap = use_heatmap
self._create_x_axis(data_range=(pos_range[0][0], pos_range[1][0]),
hide_rims=True,
unit="m")
self._create_y_axis(data_range=(pos_range[0][1], pos_range[1][1]),
unit="m",
tick_positions=[0, 1, 2],
hide_rims=True,
inverted=True)
# Calculate size of wall in pixels.
normalized_wall_pos = avg.Point2D(
(pat_model.x_wall_range[0] - pos_range[0][0]) / view_extent.x,
(pat_model.y_wall_range[1] - pos_range[0][1]) / view_extent.y)
wall_pos = avg.Point2D(
self._data_div.size.x * normalized_wall_pos.x,
self._data_div.size.y * (1 - normalized_wall_pos.y))
wall_size = avg.Point2D(
self._data_div.size.x * pat_model.x_wall_range[1] / view_extent.x,
self._data_div.size.y *
(1 - pat_model.y_wall_range[0] / view_extent.y))
avg.RectNode(pos=wall_pos,
size=wall_size,
color=global_values.COLOR_SECONDARY,
parent=self._data_div)
self.__plot_div = avg.DivNode(pos=wall_pos,
size=wall_size,
parent=self._data_div)
self._create_data_div()
self.__create_display_borders()
self.__touch_plots_norm = []
self.__touch_plots_inj = []
self.__heatmap_nodes = []
for user in self.__users:
color_norm = str(vis_params.get_user_color(user.getUserID()))
color_inj = str(
vis_params.get_user_color(user.getUserID(), offset_hue=20))
node = heatmap.HeatMapNode(
size=self.__plot_div.size,
viewportrangemin=(pat_model.x_wall_range[0],
pat_model.y_wall_range[0]),
viewportrangemax=(pat_model.x_wall_range[1],
pat_model.y_wall_range[1]),
mapsize=(50, 25),
valuerangemin=0,
valuerangemax=8,
colormap=(color_norm, color_norm),
opacitymap=(0, 1),
blendmode=global_values.BLEND_MODE,
parent=self.__plot_div)
node.setEffect(avg.BlurFXNode(radius=1))
self.__heatmap_nodes.append(node)
node = plots.ScatterPlotNode(
size=self.__plot_div.size,
viewportrangemax=pat_model.touch_range,
color=color_norm,
parent=self.__plot_div)
self.__touch_plots_norm.append(node)
node = plots.ScatterPlotNode(
size=self.__plot_div.size,
viewportrangemax=pat_model.touch_range,
color=color_inj,
parent=self.__plot_div)
self.__touch_plots_inj.append(node)
self.__time_interval = [None, None]
self.__user_visibility = [True for _ in range(len(self.__users))]
