def testRenderPipeline(self):
sys.stderr.write("\n")
for useSrcCanvas in (False, True):
for useDestCanvas in (False, True):
for useFX in (False, True):
for useColorConv in (False, True):
sys.stderr.write(" " + str(useSrcCanvas) + " " +
str(useDestCanvas) + " " +
str(useFX) + " " + str(useColorConv) +
"\n")
root = self.loadEmptyScene()
if useSrcCanvas:
srcCanvas = player.createCanvas(id="src",
size=(160, 120),
mediadir="media")
avg.ImageNode(href="rgb24alpha-64x64.png",
parent=srcCanvas.getRootNode())
srcImg = avg.ImageNode(href="canvas:src")
else:
srcImg = avg.ImageNode(href="rgb24alpha-64x64.png")
if useFX:
srcImg.setEffect(avg.NullFXNode())
if useColorConv:
srcImg.contrast = (1.01, 1.0, 1.0)
if useDestCanvas:
destCanvas = player.createCanvas(id="dest",
size=(160, 120),
mediadir="media")
destCanvas.getRootNode().appendChild(srcImg)
avg.ImageNode(href="canvas:dest", parent=root)
else:
root.appendChild(srcImg)
self.start(False, (
lambda: self.compareImage("testRenderPipeline"), ))
def testRenderPipeline(self):
sys.stderr.write("\n")
for useSrcCanvas in (False, True):
for useDestCanvas in (False, True):
for useFX in (False, True):
for useColorConv in (False, True):
sys.stderr.write(" "+str(useSrcCanvas)+" "+str(useDestCanvas)+
" "+str(useFX)+" "+str(useColorConv)+"\n")
root = self.loadEmptyScene()
if useSrcCanvas:
srcCanvas = player.createCanvas(id="src", size=(160,120),
mediadir="media")
avg.ImageNode(href="rgb24alpha-64x64.png",
parent=srcCanvas.getRootNode())
srcImg = avg.ImageNode(href="canvas:src")
else:
srcImg = avg.ImageNode(href="rgb24alpha-64x64.png")
if useFX:
srcImg.setEffect(avg.NullFXNode())
if useColorConv:
srcImg.contrast = (1.01, 1.0, 1.0)
if useDestCanvas:
destCanvas = player.createCanvas(id="dest",
size=(160,120), mediadir="media")
destCanvas.getRootNode().appendChild(srcImg)
avg.ImageNode(href="canvas:dest", parent=root)
else:
root.appendChild(srcImg)
self.start(False,
(lambda: self.compareImage("testRenderPipeline"),
))
def testCanvasErrors(self):
self.loadEmptyScene()
# Missing size
self.assertException(lambda: player.createCanvas(id="foo"))
# Duplicate canvas id
player.createCanvas(id="foo", size=(160, 120))
self.assertException(
lambda: player.createCanvas(id="foo", size=(160, 120)))
def testCanvasErrors(self):
self.loadEmptyScene()
# Missing size
self.assertRaises(avg.Exception,
lambda: player.createCanvas(id="foo"))
# Duplicate canvas id
player.createCanvas(id="foo", size=(160, 120))
self.assertRaises(avg.Exception,
lambda: player.createCanvas(id="foo", size=(160, 120)))
def onInit(self):
# white background
avg.RectNode(parent=self, size=self.size, fillopacity=1.0)
# foreground image
self._fg = avg.ImageNode(parent=self,
href='rgb24-64x64.png',
size=self.size,
masksize=self.size)
# mask drawing canvas
self._maskCanvas = player.createCanvas(id='mask',
size=self.size,
handleevents=False,
autorender=False)
# image to put the canvas on-screen (invisible)
self._maskImage = avg.ImageNode(parent=self,
href='canvas:mask',
opacity=0.0)
# black mask on start (full transparency)
avg.RectNode(parent=self._maskCanvas.getRootNode(),
size=self.size,
color='000000',
fillcolor='000000',
fillopacity=1.0)
# poly line to draw white on black mask (adding opacity)
self._drawLine = None
self._updateMask()
self._maskImage.subscribe(self._maskImage.CURSOR_DOWN, self._onDown)
self._maskImage.subscribe(self._maskImage.CURSOR_MOTION,
self._onMotion)
self._maskImage.subscribe(self._maskImage.CURSOR_UP, self._onUp)
def _renderImage(self, srcBmp, node, pos, size):
canvas = player.createCanvas(id="stretch_canvas", size=size)
img = avg.ImageNode(pos=pos, parent=canvas.getRootNode())
img.setBitmap(srcBmp)
canvas.render()
node.setBitmap(canvas.screenshot())
player.deleteCanvas("stretch_canvas")
def createBaseCanvas():
canvas = player.createCanvas(id="testcanvas",
size=(64, 64),
mediadir="media")
avg.ImageNode(href="rgb24alpha-64x64.png",
parent=canvas.getRootNode())
return canvas
def _renderImage(self, srcBmp, node, pos, size):
canvas = player.createCanvas(id="stretch_canvas", size=size)
img = avg.ImageNode(pos=pos, parent=canvas.getRootNode())
img.setBitmap(srcBmp)
canvas.render()
node.setBitmap(canvas.screenshot())
player.deleteCanvas("stretch_canvas")
def __createImage(self, node, bmp, sizeFactor):
canvas = player.createCanvas(id="keycanvas", size=self.size*sizeFactor)
canvasImage = avg.ImageNode(pos=-self.pos*sizeFactor, parent=canvas.getRootNode())
canvasImage.setBitmap(bmp)
canvas.render()
node.setBitmap(canvas.screenshot())
player.deleteCanvas('keycanvas')
def onInit(self):
# avg.VideoWriter requires a canvas as source
# (can be the main canvas returned by player.getMainCanvas())
canvas = player.createCanvas(id='source_canvas', size=self.size)
root = canvas.getRootNode()
# some nodes in source canvas
self._text = avg.WordsNode(parent=root, text='000000', fontsize=42)
self._text.pos = (self.size - self._text.size) / 2
self._rect = avg.RectNode(parent=root, size=(200, 200))
self._rect.pos = (self.size - self._rect.size) / 2
# show source canvas on screen (not required for video recording)
avg.ImageNode(parent=self, href='canvas:source_canvas')
# start writing source canvas to video file
fps = int(player.getFramerate())
self._video_writer = avg.VideoWriter(canvas, 'video_writer.avi', fps)
self._writing = True
# these nodes are not included in the video (outside source canvas)
avg.WordsNode(parent=self,
text='writing to "%s"' % self._video_writer.filename)
self._btn = widget.TextButton(parent=self,
pos=(0, 20),
size=(100, 25),
text='PAUSE')
self._btn.subscribe(widget.Button.CLICKED, self._onButton)
def testImageMaskCanvas(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(64,64), mediadir="media")
avg.ImageNode(href="rgb24-64x64.png", parent=canvas.getRootNode())
avg.RectNode(size=(160,120), fillcolor="FFFFFF", fillopacity=1, parent=root)
avg.ImageNode(href="canvas:testcanvas", maskhref="mask4.png", parent=root)
self.start(False,
(lambda: self.compareImage("testImgMaskCanvas"),))
def onInit(self):
self.offscreenCanvas = player.createCanvas(id="foo", size=(640, 480),
handleevents=True)
self.img=avg.ImageNode(href="volcano.jpg", pos=(160,120), size=(320,240),
parent=self.offscreenCanvas.getRootNode())
avg.ImageNode(href="canvas:foo", parent=self, pos=(160,120), size=(320,240))
self.img.subscribe(self.img.CURSOR_DOWN, self.onDown)
def testImageMaskCanvas(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(64,64), mediadir="media")
avg.ImageNode(href="rgb24-64x64.png", parent=canvas.getRootNode())
avg.RectNode(size=(160,120), fillcolor="FFFFFF", fillopacity=1, parent=root)
avg.ImageNode(href="canvas:testcanvas", maskhref="mask.png", parent=root)
self.start(False,
(lambda: self.compareImage("testImgMaskCanvas"),))
def createCanvas():
canvas = player.createCanvas(id="testcanvas",
size=(160, 120),
mediadir="media",
autorender=False)
avg.ImageNode(id="test",
href="rgb24-65x65.png",
parent=canvas.getRootNode())
return canvas
def __createOffscreenCanvas(self, canvasName, handleEvents):
canvas = player.createCanvas(id=canvasName,
size=(160, 120),
handleevents=handleEvents)
canvas.getRootNode().mediadir = "media"
avg.ImageNode(id="test1",
href="rgb24-65x65.png",
parent=canvas.getRootNode())
return canvas
def testCanvasCrop(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(160,120),
mediadir="media")
div = avg.DivNode(pos=(40,30), size=(80,60), crop=True,
parent=canvas.getRootNode())
avg.ImageNode(id="test1", pos=(-32, -32), href="rgb24-65x65.png", parent=div)
avg.ImageNode(parent=root, href="canvas:testcanvas")
self.start(False, (lambda: self.compareImage("testCanvasCrop"),))
def __createImage(self, node, bmp, sizeFactor):
canvas = player.createCanvas(id="keycanvas",
size=self.size * sizeFactor)
canvasImage = avg.ImageNode(pos=-self.pos * sizeFactor,
parent=canvas.getRootNode())
canvasImage.setBitmap(bmp)
canvas.render()
node.setBitmap(canvas.screenshot())
player.deleteCanvas('keycanvas')
def testCanvasCrop(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(160,120),
mediadir="media")
div = avg.DivNode(pos=(40,30), size=(80,60), crop=True,
parent=canvas.getRootNode())
avg.ImageNode(id="test1", pos=(-32, -32), href="rgb24-65x65.png", parent=div)
avg.ImageNode(parent=root, href="canvas:testcanvas")
self.start(False, (lambda: self.compareImage("testCanvasCrop"),))
def testCanvasAlpha(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(80,120), mediadir="media")
avg.ImageNode(id="test1", href="rgb24alpha-64x64.png",
parent=canvas.getRootNode())
avg.RectNode(parent=root, fillcolor="FFFFFF",
pos=(0.5, 0.5), size=(160, 48), fillopacity=1)
avg.ImageNode(parent=root, href="canvas:testcanvas")
avg.ImageNode(parent=root, x=64, href="rgb24alpha-64x64.png")
self.start(False, (lambda: self.compareImage("testCanvasAlpha"),))
def testCanvasAlpha(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(80,120), mediadir="media")
avg.ImageNode(id="test1", href="rgb24alpha-64x64.png",
parent=canvas.getRootNode())
avg.RectNode(parent=root, fillcolor="FFFFFF",
pos=(0.5, 0.5), size=(160, 48), fillopacity=1)
avg.ImageNode(parent=root, href="canvas:testcanvas")
avg.ImageNode(parent=root, x=64, href="rgb24alpha-64x64.png")
self.start(False, (lambda: self.compareImage("testCanvasAlpha"),))
def testCanvasBackface(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(80, 120))
avg.ImageNode(parent=root, pos=(80, 0), href="canvas:testcanvas")
for parentNode in canvas.getRootNode(), root:
avg.MeshNode(vertexcoords=((0, 0), (80, 0), (80, 120), (0, 120)),
texcoords=((0, 0), (1, 0), (1, 1), (0, 1)),
triangles=((1, 0, 3), (1, 2, 3)),
parent=parentNode,
backfacecull=True)
self.start(False, (lambda: self.compareImage("testCanvasBackface"), ))
def __createOffscreenCanvas(self):
canvas = player.createCanvas(id="offscreen",
size=(160, 120),
mediadir="media")
root = canvas.getRootNode()
avg.ImageNode(href="rgb24-32x32.png", parent=root)
avg.ImageNode(id="test",
pos=(32, 0),
href="rgb24alpha-32x32.png",
parent=root)
return canvas
def testCanvasBackface(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(80,120))
avg.ImageNode(parent=root, pos=(80,0), href="canvas:testcanvas")
for parentNode in canvas.getRootNode(), root:
avg.MeshNode(vertexcoords=((0,0), (80,0), (80,120), (0,120)),
texcoords=((0,0), (1,0), (1,1), (0,1)),
triangles=((1,0,3), (1,2,3)),
parent=parentNode,
backfacecull=True)
self.start(False, (lambda: self.compareImage("testCanvasBackface"),))
def __renderImage(self, srcBmp, node, offset):
if self._orientation == Orientation.HORIZONTAL:
pos = (-offset,0)
else:
pos = (0, -offset)
canvas = player.createCanvas(id="accordion_canvas", size=node.size)
img = avg.ImageNode(pos=pos, parent=canvas.getRootNode())
img.setBitmap(srcBmp)
canvas.render()
node.setBitmap(canvas.screenshot())
player.deleteCanvas("accordion_canvas")
def onInit(self):
self.curFrame = 0
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.canvas = player.createCanvas(id="canvas", size=self.size)
self.camNode = avg.CameraNode(driver=self.optdict["driver"],
device=self.optdict["device"],
unit=self.optdict["unit"],
fw800=self.optdict["fw800"],
framerate=self.optdict["framerate"],
capturewidth=self.optdict["width"],
captureheight=self.optdict["height"],
pixelformat=self.optdict["pixelFormat"],
parent=self.canvas.getRootNode())
if not self.optdict["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=self.canvas.getRootNode())
self.frameText = avg.WordsNode(color="ff3333",
pos=(5, 25),
fontsize=14,
parent=self.canvas.getRootNode())
else:
self.frameText = None
self.canvasImage = avg.ImageNode(href="canvas:canvas",
size=self.size,
parent=self)
if self.capture:
self.videoWriter = avg.VideoWriter(self.canvas, "camera.mov", 60,
3, 5, True)
self.setupKeys()
self.camNode.play()
player.setTimeout(100, self.checkCamera)
def testCanvasMipmap(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(80,120), mediadir="media",
mipmap=True)
avg.ImageNode(id="test1", href="rgb24alpha-64x64.png",
parent=canvas.getRootNode())
avg.ImageNode(parent=root, size=(40, 30), href="canvas:testcanvas")
try:
self.start(False, (lambda: self.compareImage("testCanvasMipmap"),))
except avg.Exception:
self.skip("Offscreen mipmap init failed.")
return
def createCanvas(isFirst, canvasName, x):
canvas = self.__createOffscreenCanvas(canvasName, False)
canvas.getElementByID("test1").x = x
node = avg.ImageNode(parent=root, id="imagenode")
node.href="canvas:"+canvasName
if isFirst:
self.assertEqual(canvas.getNumDependentCanvases(), 0)
self.canvas1 = canvas
else:
self.assertEqual(canvas.getNumDependentCanvases(), 1)
self.canvas2 = canvas
self.assertRaises(avg.Exception,
lambda: player.createCanvas(id="negativesize", size=(-42,120)))
def createCanvas(isFirst, canvasName, x):
canvas = self.__createOffscreenCanvas(canvasName, False)
canvas.getElementByID("test1").x = x
node = avg.ImageNode(parent=root, id="imagenode")
node.href="canvas:"+canvasName
if isFirst:
self.assertEqual(canvas.getNumDependentCanvases(), 0)
self.canvas1 = canvas
else:
self.assertEqual(canvas.getNumDependentCanvases(), 1)
self.canvas2 = canvas
self.assertRaises(avg.Exception,
lambda: player.createCanvas(id="negativesize", size=(-42,120)))
def testCanvasMipmap(self):
root = self.loadEmptyScene()
canvas = player.createCanvas(id="testcanvas", size=(80,120), mediadir="media",
mipmap=True)
avg.ImageNode(id="test1", href="rgb24alpha-64x64.png",
parent=canvas.getRootNode())
avg.ImageNode(parent=root, size=(40, 30), href="canvas:testcanvas")
try:
self.start(False, (lambda: self.compareImage("testCanvasMipmap"),))
except RuntimeError:
self.skip("Offscreen mipmap init failed.")
return
def onInit(self):
self.offscreenCanvas = player.createCanvas(id="foo",
size=(640, 480),
handleevents=True)
self.img = avg.ImageNode(href="volcano.jpg",
pos=(160, 120),
size=(320, 240),
parent=self.offscreenCanvas.getRootNode())
avg.ImageNode(href="canvas:foo",
parent=self,
pos=(160, 120),
size=(320, 240))
self.img.subscribe(self.img.CURSOR_DOWN, self.onDown)
def testMultiWindowManualCanvas(self):
def renderCanvas():
canvas.render()
bmp = canvas.screenshot()
self.compareBitmapToFile(bmp, "testMultiWindowManualCanvas")
self.loadEmptyScene()
player.setWindowConfig("avgwindowconfig.xml")
canvas = player.createCanvas(id="canvas", size=(160,120), autorender=False)
avg.ImageNode(pos=(0,0), href="media/rgb24-64x64.png",
parent=canvas.getRootNode())
self.start(False,
(renderCanvas,
))
def testMultiWindowManualCanvas(self):
def renderCanvas():
canvas.render()
bmp = canvas.screenshot()
self.compareBitmapToFile(bmp, "testMultiWindowManualCanvas")
self.loadEmptyScene()
player.setWindowConfig("avgwindowconfig.xml")
canvas = player.createCanvas(id="canvas", size=(160,120), autorender=False)
avg.ImageNode(pos=(0,0), href="media/rgb24-64x64.png",
parent=canvas.getRootNode())
self.start(False,
(renderCanvas,
))
def createCanvas():
if not(avg.OffscreenCanvas.isMultisampleSupported()):
self.skip("Offscreen multisampling not supported")
player.stop()
return
try:
self.canvas = player.createCanvas(id="testcanvas", size=(160,120),
mediadir="media", multisamplesamples=2)
avg.ImageNode(id="test1", href="rgb24-65x65.png", angle=0.1,
parent=self.canvas.getRootNode())
except avg.Exception:
self.skip("Offscreen multisampling init failed")
player.stop()
return
self.assertEqual(self.canvas.multisamplesamples, 2)
avg.ImageNode(parent=root, href="canvas:testcanvas")
def createCanvas():
if not(avg.OffscreenCanvas.isMultisampleSupported()):
self.skip("Offscreen multisampling not supported")
player.stop()
return
try:
self.canvas = player.createCanvas(id="testcanvas", size=(160,120),
mediadir="media", multisamplesamples=2)
avg.ImageNode(id="test1", href="rgb24-65x65.png", angle=0.1,
parent=self.canvas.getRootNode())
except RuntimeError:
self.skip("Offscreen multisampling init failed")
player.stop()
return
self.assertEqual(self.canvas.multisamplesamples, 2)
avg.ImageNode(parent=root, href="canvas:testcanvas")
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 get_circle_canvas_from_color(color, radius=__radius, stroke_width=1.0, stroke_color=avg.Color("c0c0c0"),
fake_opacity=1.0):
if color is None:
raise ValueError("CanvasManager.get_circle_canvas_from_color: color for canvas cannot be None.")
if isinstance(color, str):
color = avg.Color(color)
if not isinstance(color, avg.Color):
raise ValueError("CanvasManager.get_circle_canvas_from_color: color for canvas must be type avg.Color.")
# TODO: Fix the problem with the wrong stroke color string.
canvas_id = "circle_%d-%d-%d_%d_%s_%d" % (color.r, color.g, color.b, stroke_width, "c0c0c0", fake_opacity)
# check if color in already existing canvases
if canvas_id in CanvasManager.__circle_canvases:
return "canvas:%s" % canvas_id # CanvasManager.__circle_canvases[color]
# create canvas and add to circle canvases
size = avg.Point2D(CanvasManager.__radius, CanvasManager.__radius) * 2 + (2, 2)
canvas = player.createCanvas(id=canvas_id, autorender=False, multisamplesamples=8, size=size)
if fake_opacity != 1.0:
avg.CircleNode(
pos=(size / 2) + (1, 1),
r=CanvasManager.__radius,
strokewidth=0.0,
fillopacity=1.0,
fillcolor='fff',
parent=canvas.getRootNode()
)
avg.CircleNode(
pos=(size / 2) + (1, 1),
r=CanvasManager.__radius,
color=stroke_color,
strokewidth=stroke_width,
fillopacity=fake_opacity,
fillcolor=color,
parent=canvas.getRootNode()
)
canvas.render()
CanvasManager.__circle_canvases.append(canvas_id)
return "canvas:%s" % canvas_id
def onInit(self):
self.curFrame = 0
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.canvas = player.createCanvas(id="canvas", size=self.size)
self.camNode = avg.CameraNode(driver=self.optdict["driver"],
device=self.optdict["device"], unit=self.optdict["unit"],
fw800=self.optdict["fw800"], framerate=self.optdict["framerate"],
capturewidth=self.optdict["width"], captureheight=self.optdict["height"],
pixelformat=self.optdict["pixelFormat"], parent=self.canvas.getRootNode())
if not self.optdict["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=self.canvas.getRootNode())
self.frameText = avg.WordsNode(color="ff3333", pos=(5,25), fontsize=14,
parent=self.canvas.getRootNode())
else:
self.frameText = None
self.canvasImage = avg.ImageNode(href="canvas:canvas", size=self.size,
parent=self)
if self.capture:
self.videoWriter = avg.VideoWriter(self.canvas, "camera.mov", 60, 3, 5, True)
self.setupKeys()
self.camNode.play()
player.setTimeout(100, self.checkCamera)
def testMultiWindowCanvas(self):
def deleteCanvas():
img1.unlink(True)
img2.unlink(True)
player.deleteCanvas("canvas")
def canvasScreenshot():
bmp = canvas.screenshot()
self.compareBitmapToFile(bmp, "testMultiWindowCanvas2")
root = self.loadEmptyScene()
player.setWindowConfig("avgwindowconfig.xml")
canvas = player.createCanvas(id="canvas", size=(160, 120))
avg.ImageNode(pos=(0, 0),
href="media/rgb24-64x64.png",
parent=canvas.getRootNode())
img1 = avg.ImageNode(pos=(0, 0), href="canvas:canvas", parent=root)
img2 = avg.ImageNode(pos=(80, 0), href="canvas:canvas", parent=root)
self.start(False, (
lambda: self.compareImage("testMultiWindowCanvas1"),
canvasScreenshot,
deleteCanvas,
))
def testMultiWindowCanvas(self):
def deleteCanvas():
img1.unlink(True)
img2.unlink(True)
player.deleteCanvas("canvas")
def canvasScreenshot():
bmp = canvas.screenshot()
self.compareBitmapToFile(bmp, "testMultiWindowCanvas2")
root = self.loadEmptyScene()
player.setWindowConfig("avgwindowconfig.xml")
canvas = player.createCanvas(id="canvas", size=(160,120))
avg.ImageNode(pos=(0,0), href="media/rgb24-64x64.png",
parent=canvas.getRootNode())
img1 = avg.ImageNode(pos=(0,0), href="canvas:canvas", parent=root)
img2 = avg.ImageNode(pos=(80,0), href="canvas:canvas", parent=root)
self.start(False,
(lambda: self.compareImage("testMultiWindowCanvas1"),
canvasScreenshot,
deleteCanvas,
))
def onInit(self):
# white background
avg.RectNode(parent=self, size=self.size, fillopacity=1.0)
# foreground image
self._fg = avg.ImageNode(parent=self, href='rgb24-64x64.png',
size=self.size, masksize=self.size)
# mask drawing canvas
self._maskCanvas = player.createCanvas(id='mask', size=self.size,
handleevents=False, autorender=False)
# image to put the canvas on-screen (invisible)
self._maskImage = avg.ImageNode(parent=self, href='canvas:mask',
opacity=0.0)
# black mask on start (full transparency)
avg.RectNode(parent=self._maskCanvas.getRootNode(), size=self.size,
color='000000', fillcolor='000000', fillopacity=1.0)
# poly line to draw white on black mask (adding opacity)
self._drawLine = None
self._updateMask()
self._maskImage.subscribe(self._maskImage.CURSOR_DOWN, self._onDown)
self._maskImage.subscribe(self._maskImage.CURSOR_MOTION, self._onMotion)
self._maskImage.subscribe(self._maskImage.CURSOR_UP, self._onUp)
def __draw_main_view(self, fake=False):
"""
Draws the main vis view.
:param fake: Should the fake or the original data set be loaded?
:type fake: bool
"""
if self.__touch_test_view:
self.__touch_test_view.unlink(True)
self.__touch_test_view = None
self.__wall_divico = WallDivico(
parent=self,
size=self.size,
map_image_info=config_app.maps_images[config_app.map_image],
data_file=config_app.sql_result_dump_filename[
config_app.data_mode_string],
grid_groups=self.__grid_groups,
grid_labels=self.__grid_labels)
self.__task_text_view_canvas = player.createCanvas(
id="task_text_view",
autorender=True,
multisamplesamples=8,
size=(self.size[0], self.size[1] / 12))
text = [
"{} ({})".format(self._study_handler.current_block_name,
self._study_handler.current_phase)
] if self._study_handler else []
self.__task_text_view = TextView2(
text_elements=text,
alignment="center",
font_size=42,
element_size=900,
parent=self.__task_text_view_canvas.getRootNode(),
size=(self.size[0], self.size[1] / 12),
padding_top=20,
padding_bottom=20,
element_offset=50,
# elementoutlinecolor="f00"
)
self.__task_text_view_image_top = avg.ImageNode(
parent=self,
size=(self.size[0], self.size[1] / 12),
href="canvas:task_text_view")
self.__task_text_view_image_bottom = avg.ImageNode(
parent=self,
pos=(0, self.size[1] * 11 / 12),
size=(self.size[0], self.size[1] / 12),
href="canvas:task_text_view")
self.__phase_block_label = avg.WordsNode(
parent=self,
pos=(3, self.size[1] - 20),
fontsize=15,
color="555",
alignment="left",
variant="bold",
rawtextmode=True,
text="#{} - {}: {}".format(config_app.SESSION,
self._study_handler.current_phase,
self._study_handler.current_block_name)
if self._study_handler else "")
self.__interaction_activation_label = avg.WordsNode(parent=self,
pos=(3, 3),
fontsize=15,
color="555",
alignment="left",
variant="bold",
rawtextmode=True,
text="")
self.__create_touch_vis_view()
# initialize StudyLogging
if config_app.study_mode:
StudyLog.get_instance().write_event_log(
"initialized view and divico control")
self.subscribe(
avg.Node.CURSOR_DOWN, lambda event: self.__log_touch(
event, event_type="CURSOR_DOWN"))
self.subscribe(
avg.Node.CURSOR_MOTION,
lambda event: self.__log_touch(event,
event_type="CURSOR_MOTION"))
self.subscribe(
avg.Node.CURSOR_UP,
lambda event: self.__log_touch(event, event_type="CURSOR_UP"))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from libavg import avg, player
offscreenCanvas = player.createCanvas(id="londoncalling", size=(320,240))
avg.WordsNode(pos=(10,10), text="London Calling",
parent=offscreenCanvas.getRootNode())
mainCanvas = player.createMainCanvas(size=(640,480))
rootNode = mainCanvas.getRootNode()
avg.ImageNode(href="canvas:londoncalling", parent=rootNode)
player.play()
def testVideoWriter(self):
def startWriter(fps, syncToPlayback):
self.videoWriter = avg.VideoWriter(canvas, "test.mov", fps, 3, 5,
syncToPlayback)
self.assertEqual(self.videoWriter.filename, "test.mov")
self.assertEqual(self.videoWriter.framerate, fps)
self.assertEqual(self.videoWriter.qmin, 3)
self.assertEqual(self.videoWriter.qmax, 5)
self.assertEqual(self.videoWriter.synctoplayback, syncToPlayback)
def stopWriter():
self.videoWriter.stop()
def killWriter():
self.videoWriter = None
def pauseWriter():
self.videoWriter.pause()
def playWriter():
self.videoWriter.play()
def hideVideo():
videoNode.opacity = 0
def showVideo():
videoNode.opacity = 1
def checkVideo(numFrames):
savedVideoNode = avg.VideoNode(href="../test.mov", pos=(48,0),
threaded=False, parent=root)
savedVideoNode.pause()
self.assertEqual(savedVideoNode.getVideoCodec(), "mjpeg")
self.assertEqual(savedVideoNode.getNumFrames(), numFrames)
self.assertEqual(savedVideoNode.getStreamPixelFormat(), "yuvj420p")
def testCreateException():
self.assertRaises(avg.Exception,
lambda: avg.VideoWriter(player.getMainCanvas(),
"nonexistentdir/test.mov", 30))
if not(self._isCurrentDirWriteable()):
self.skip("Current dir not writeable.")
return
if player.isUsingGLES():
self.skip("VideoWriter not supported under GLES.")
return
self.assertRaises(avg.Exception, lambda:
avg.VideoWriter(player.getMainCanvas(), "test.mov", 30, 3, 5, False))
for useCanvas in (False, True):
player.setFakeFPS(30)
root = self.loadEmptyScene()
videoNode = avg.VideoNode(href="mpeg1-48x48.mov", threaded=False)
if useCanvas:
canvas = player.createCanvas(id="canvas", size=(48,48),
mediadir="media")
canvas.getRootNode().appendChild(videoNode)
avg.ImageNode(parent=root, href="canvas:canvas")
testImageName = "testVideoWriterCanvas"
else:
root.appendChild(videoNode)
canvas = player.getMainCanvas()
testImageName = "testVideoWriter"
self.start(False,
(videoNode.play,
lambda: startWriter(30, True),
lambda: self.delay(100),
stopWriter,
killWriter,
lambda: checkVideo(4),
hideVideo,
lambda: self.compareImage(testImageName+"1"),
showVideo,
testCreateException,
lambda: startWriter(15, False),
lambda: self.delay(150),
stopWriter,
killWriter,
lambda: checkVideo(2),
lambda: startWriter(30, False),
pauseWriter,
lambda: self.delay(200),
playWriter,
stopWriter,
killWriter,
lambda: checkVideo(1),
lambda: startWriter(30, False),
killWriter,
lambda: checkVideo(1),
))
os.remove("test.mov")
def loadCanvasDepString():
player.createCanvas(id="canvas1", size=(160, 120))
canvas2 = player.createCanvas(id="canvas2", size=(160, 120))
avg.ImageNode(href="canvas:canvas1", parent=canvas2.getRootNode())
player.deleteCanvas('canvas2')
player.deleteCanvas('canvas1')
def __createOffscreenCanvas(self):
canvas = player.createCanvas(id="offscreen", size=(160,120), mediadir="media")
root = canvas.getRootNode()
avg.ImageNode(href="rgb24-32x32.png", parent=root)
avg.ImageNode(id="test", pos=(32,0), href="rgb24alpha-32x32.png", parent=root)
return canvas
def createCanvas():
canvas = player.createCanvas(id="testcanvas", size=(160,120),
mediadir="media", autorender=False)
avg.ImageNode(id="test", href="rgb24-65x65.png", parent=canvas.getRootNode())
return canvas
def createBaseCanvas():
canvas = player.createCanvas(id="testcanvas", size=(64,64),
mediadir="media")
avg.ImageNode(href="rgb24alpha-64x64.png", parent=canvas.getRootNode())
return canvas
def loadCanvasDepString():
player.createCanvas(id="canvas1", size=(160, 120))
canvas2 = player.createCanvas(id="canvas2", size=(160, 120))
avg.ImageNode(href="canvas:canvas1", parent=canvas2.getRootNode())
player.deleteCanvas('canvas2')
player.deleteCanvas('canvas1')
def testIllegalSamples(numSamples):
self.canvas = player.createCanvas(id="brokencanvas",
size=(160, 120),
multisamplesamples=numSamples)
def testIllegalSamples(numSamples):
self.canvas = player.createCanvas(id="brokencanvas", size=(160,120),
multisamplesamples=numSamples)
def testVideoWriter(self):
def startWriter(fps, syncToPlayback):
self.videoWriter = avg.VideoWriter(canvas, "test.mov", fps, 3, 5,
syncToPlayback)
def stopWriter():
self.videoWriter.stop()
def killWriter():
self.videoWriter = None
def pauseWriter():
self.videoWriter.pause()
def playWriter():
self.videoWriter.play()
def hideVideo():
videoNode.opacity = 0
def showVideo():
videoNode.opacity = 1
def checkVideo(numFrames):
savedVideoNode = avg.VideoNode(href="../test.mov", pos=(48,0),
threaded=False, parent=root)
savedVideoNode.pause()
self.assertEqual(savedVideoNode.getVideoCodec(), "mjpeg")
self.assertEqual(savedVideoNode.getNumFrames(), numFrames)
self.assertEqual(savedVideoNode.getStreamPixelFormat(), "yuvj420p")
def testCreateException():
self.assertRaises(avg.Exception,
lambda: avg.VideoWriter(player.getMainCanvas(),
"nonexistentdir/test.mov", 30))
if not(self._isCurrentDirWriteable()):
self.skip("Current dir not writeable.")
return
if player.isUsingGLES():
self.skip("VideoWriter not supported under GLES.")
return
self.assertRaises(avg.Exception, lambda:
avg.VideoWriter(player.getMainCanvas(), "test.mov", 30, 3, 5, False))
for useCanvas in (False, True):
player.setFakeFPS(30)
root = self.loadEmptyScene()
videoNode = avg.VideoNode(href="mpeg1-48x48.mov", threaded=False)
if useCanvas:
canvas = player.createCanvas(id="canvas", size=(48,48),
mediadir="media")
canvas.getRootNode().appendChild(videoNode)
avg.ImageNode(parent=root, href="canvas:canvas")
testImageName = "testVideoWriterCanvas"
else:
root.appendChild(videoNode)
canvas = player.getMainCanvas()
testImageName = "testVideoWriter"
self.start(False,
(videoNode.play,
lambda: startWriter(30, True),
lambda: self.delay(100),
stopWriter,
killWriter,
lambda: checkVideo(4),
hideVideo,
lambda: self.compareImage(testImageName+"1"),
showVideo,
testCreateException,
lambda: startWriter(15, False),
lambda: self.delay(150),
stopWriter,
killWriter,
lambda: checkVideo(2),
lambda: startWriter(30, False),
pauseWriter,
lambda: self.delay(200),
playWriter,
stopWriter,
killWriter,
lambda: checkVideo(1),
lambda: startWriter(30, False),
killWriter,
lambda: checkVideo(1),
))
os.remove("test.mov")
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from libavg import avg, player
offscreenCanvas = player.createCanvas(id="londoncalling", size=(320, 240))
avg.WordsNode(pos=(10, 10),
text="London Calling",
parent=offscreenCanvas.getRootNode())
mainCanvas = player.createMainCanvas(size=(640, 480))
rootNode = mainCanvas.getRootNode()
avg.ImageNode(href="canvas:londoncalling", parent=rootNode)
player.play()
def __createOffscreenCanvas(self, canvasName, handleEvents):
canvas = player.createCanvas(id=canvasName, size=(160,120),
handleevents=handleEvents)
canvas.getRootNode().mediadir = "media"
avg.ImageNode(id="test1", href="rgb24-65x65.png", parent=canvas.getRootNode())
return canvas
