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()