RemoteRenderingEventReplay.py

Go to the documentation of this file.

#
# Copyright 2013, MeVis Medical Solutions AG
#
# The user may use this file in accordance with the license agreement provided with
# the Software or, alternatively, in accordance with the terms contained in a
# written agreement between the user and MeVis Medical Solutions AG.
#
# For further information use the contact form at https://www.mevislab.de/contact
#
 
from TestSupport import Base, Logging
from TestSupport.Macros import EXPECT_TRUE
from mevis import MLAB, MLABFileManager
from PythonQt import QtCore
import json
import time
import os.path
 
 
# A helper class to replay events recorded by the RemoteRenderingEventRecorder
class EventReplay:
 
    # init the replay with a given remote rendering slave and a *.events filename
    def __init__(self, slave, filename, resizeHandler=None):
        self._baseName = os.path.splitext(os.path.basename(filename))[0]
        self._slave = slave
        f = open(filename, "rb")
        self._events = json.load(f)
        f.close()
        self.screenshotCount = 0
        self.sceneHasChanged = False
        self.resizeHandler = resizeHandler
        self._slave.sceneChanged.connect(self.sceneChangedsceneChanged)
 
    # create an additional screenshot
    def createScreenshot(self):
        self._slave.imageReceived.connect(self.imageReceivedimageReceived)
        self._slave.sendRenderRequest(self._slave.PNG)
        self._slave.imageReceived.disconnect(self.imageReceivedimageReceived)
 
    # notice if the scene has changed
    def sceneChanged(self):
        self.sceneHasChanged = True
 
    # handle the receiving of an image
    def imageReceived(self, img):
        name = self._baseName + str(self.screenshotCount)
        filename = Base.getResultDirectory() + "/" + name + ".png"
        EXPECT_TRUE(img.save(filename))
 
        referenceImage = Base.getDataDirectory() + "/" + name + ".png"
        if not MLABFileManager.exists(referenceImage):
            EXPECT_TRUE(img.save(referenceImage))
 
        Logging.showImage(name + " (reference image on the right)", filename, referenceImage)
        self.screenshotCount += 1
 
    def doPause(self, delay):
        start_time = time.time()
        while time.time() - start_time < delay / 1000.0:
            MLAB.msleep(10)
            MLAB.processEvents()
 
    # replay all events
    def replay(self, redrawAfterResize=False, redrawAfterSceneChanged=False):
        for event in self._events:
            shouldRedraw = False
            eventType = event["event"]
            hasPosition = "x" in event and "y" in event
            if eventType == "Resize":
                w = event["width"]
                h = event["height"]
                if self.resizeHandler:
                    self.resizeHandler(w, h)
                self._slave.resize(w, h)
                if redrawAfterResize:
                    shouldRedraw = True
            elif eventType == "Pause":
                self.doPause(event["delay"])
            elif eventType == "Enter":
                self._slave.enter()
            elif eventType == "Leave":
                self._slave.leave()
            elif eventType == "MouseMove":
                self._slave.mouseMoveTo(event["x"], event["y"])
            elif eventType == "MouseButtonPress":
                if hasPosition:
                    self._slave.mousePress(event["button"], event["x"], event["y"])
                else:
                    self._slave.mousePress(event["button"])
            elif eventType == "MouseButtonRelease":
                if hasPosition:
                    self._slave.mouseRelease(event["button"], event["x"], event["y"])
                else:
                    self._slave.mouseRelease(event["button"])
            elif eventType == "MouseButtonDblClick":
                if hasPosition:
                    self._slave.mouseDoubleClickPress(event["button"], event["x"], event["y"])
                else:
                    self._slave.mouseDoubleClickPress(event["button"])
            elif eventType == "Wheel":
                if hasPosition:
                    self._slave.mouseWheel(event["delta"], event["x"], event["y"])
                else:
                    self._slave.mouseWheel(event["delta"])
            elif eventType == "KeyPress":
                self._slave.keyPress(event["key"])
            elif eventType == "KeyRelease":
                self._slave.keyRelease(event["key"])
            elif eventType == "Screenshot":
                self.createScreenshot()
            else:
                MLAB.logWarning("Unknown event: " + event)
 
            # it was required to use QCoreApplication.processEvents instead of MLAB.processEvent()
            # so that events are reliably delivered to QGraphicsView/RemotePanelRendering:
            QtCore.QCoreApplication.processEvents()
 
            if redrawAfterSceneChanged and self.sceneHasChanged:
                shouldRedraw = True
                self.sceneHasChanged = False
            if shouldRedraw:
                self._slave.sendRenderRequest(self._slave.PNG)
                MLAB.processEvents()