class PhotosViewer(QGraphicsView):
afterLeftClick = pyqtSignal(float, float)
afterLeftClickReleased = pyqtSignal(float, float)
afterDoubleClick = pyqtSignal(float, float)
def __init__(self, selfwindow):
QGraphicsView.__init__(self)
self.selfwindow = selfwindow
self.panSelect = False
self.zoomSelect = False
self.zoom_data = []
self.scene = QGraphicsScene()
self.setScene(self.scene)
self.setMouseTracking(False)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setDragMode(QGraphicsView.NoDrag)
def mousePressEvent(self, event):
sc_pos = self.mapToScene(event.pos())
if self.panSelect:
self.setDragMode(QGraphicsView.ScrollHandDrag)
if self.zoomSelect:
self.setDragMode(QGraphicsView.RubberBandDrag)
self.afterLeftClick.emit(sc_pos.x(), sc_pos.y())
QGraphicsView.mousePressEvent(self, event)
def mouseDoubleClickEvent(self, event):
sc_pos = self.mapToScene(event.pos())
if self.zoomSelect or self.panSelect:
self.zoom_data = []
self.fitInView(self.sceneRect(), Qt.KeepAspectRatio)
self.afterDoubleClick.emit(sc_pos.x(), sc_pos.y())
QGraphicsView.mouseDoubleClickEvent(self, event)
def mouseReleaseEvent(self, event):
QGraphicsView.mouseReleaseEvent(self, event)
sc_pos = self.mapToScene(event.pos())
if self.zoomSelect:
view_bb = self.sceneRect()
if self.zoom_data:
view_bb = self.zoom_data
selection_bb = self.scene.selectionArea().boundingRect(
).intersected(view_bb)
self.scene.setSelectionArea(QPainterPath())
if selection_bb.isValid() and (selection_bb != view_bb):
self.zoom_data = selection_bb
self.fitInView(self.zoom_data, Qt.KeepAspectRatio)
self.setDragMode(QGraphicsView.NoDrag)
self.afterLeftClickReleased.emit(sc_pos.x(), sc_pos.y())
def resizeEvent(self, event):
self.fitInView(self.scene.sceneRect(), Qt.KeepAspectRatio)
def main():
app = QApplication(sys.argv)
grview = QGraphicsView()
scene = QGraphicsScene()
scene.setSceneRect(0, 0, 680, 459)
scene.addPixmap(QPixmap('01.png'))
grview.setScene(scene)
item = GraphicsRectItem(0, 0, 300, 150)
scene.addItem(item)
grview.fitInView(scene.sceneRect(), Qt.KeepAspectRatio)
grview.show()
sys.exit(app.exec_())
def btnConfirmClicked(self):
# check if PIN code corresponds to PIN code stored in database (use SHA-256 to hash passwords!)
cursor = self._mysqldb_connection.cursor()
query_str = "select * from tblUser where userID='" + self._rfid + "'"
cursor.execute(query_str)
if cursor.rowcount != 1:
self.lblWrongPINCode.setVisible(True)
cursor.close()
return
# fetch (only) matching row from DB
tblUser_row = cursor.fetchone()
# hash pin entered by user with salt string from DB
pincode_hash = SHA256.new(str(self.lnPINCode.text()) + str(tblUser_row[4])).hexdigest().upper()
#print pincode_hash
if pincode_hash == tblUser_row[3]:
# permit access to user and enable widgets accordingly
self.lblWrongPINCode.setVisible(False)
self.tabWidget.setTabEnabled(1, True)
self.tabWidget.setTabEnabled(2, True)
self.tabWidget.setTabEnabled(3, True)
self.tabWidget.setTabEnabled(4, True)
self.lblAuth.setEnabled(False)
self.lblPINCode.setEnabled(False)
self.lnPINCode.setEnabled(False)
self.btnConfirm.setEnabled(False)
self.lblHelloMsg.setVisible(True)
self.lblHelloMsg.setText("Welcome back, " + tblUser_row[2] + "!")
self.lblRemove.setVisible(True)
self.grProfilePicture.setVisible(True)
self.grProfilePicture.setEnabled(True)
scene = QGraphicsScene()
qimg = QtGui.QImage.fromData(tblUser_row[6])
pixmap = QGraphicsPixmapItem(QPixmap.fromImage(qimg), None, scene)
self.grProfilePicture.setScene(scene)
self.grProfilePicture.fitInView(scene.sceneRect(), Qt.KeepAspectRatio)
self.grProfilePicture.setVisible(True)
self._encourager.say("Welcome back, " + tblUser_row[2] + "!")
self._encourager.show_emotion("happy")
### HARDCODED: display different information depending on user connected ###
if self._rfid == "3BEA00008131FE450031C573C0014000900077":
self.slNbrBlocks.setValue(3)
self.spnNbrRepetitions.setValue(25)
self.chkQualitative.setChecked(False)
self.chkQuantitative.setChecked(True)
self.spnQuantEncRep.setEnabled(True)
self.cmbQualiEnc.setEnabled(False)
self.spnQuantEncRep.setValue(3)
else:
self.slNbrBlocks.setValue(2)
self.spnNbrRepetitions.setValue(15)
self.chkQualitative.setChecked(True)
self.chkQuantitative.setChecked(True)
self.spnQuantEncRep.setEnabled(True)
self.spnQuantEncRep.setValue(2)
self.cmbQualiEnc.setEnabled(True)
self.cmbQualiEnc.setCurrentIndex(1)
#launch_params = ['roslaunch', 'simple_image_cyphering', 'one_node_decryption.launch']
#self._decryption_node = Popen(launch_params)
else:
self.lblWrongPINCode.setVisible(True)
cursor.close()
def __init__(self):
super(QTRehaZenterGUI, self).__init__()
uic.loadUi(currentdir + '/ui_files/QTRehaZenterGUI.ui', self)
# connect to DB and create cursor object to perform queries
self._mysqldb_connection = MySQLdb.connect(host=self.mysql_hostname, user=self.mysql_user, passwd=self.mysql_password, db="iot")
# initialize custom object loader widget
self.defineNewColorWidget = DefineNewColor.UIDefineNewColorWidget(self)
# disable camera feed tab on startup (enabled later)
self.tabWidget.setTabEnabled(2, False)
# load logo images
uniLuLogoScene = QGraphicsScene()
imagePixmap_unilu = QGraphicsPixmapItem(QPixmap(QImage(currentdir + "/imgs/university_of_luxembourg_logo.png")), None, uniLuLogoScene)
self.grUniLuLogo.setScene(uniLuLogoScene)
self.grUniLuLogo.fitInView(uniLuLogoScene.sceneRect(), Qt.KeepAspectRatio)
luxAILogoScene = QGraphicsScene()
imagePixmap_luxai = QGraphicsPixmapItem(QPixmap(QImage(currentdir + "/imgs/luxai_logo.png")), None, luxAILogoScene)
self.grLuxAILogo.setScene(luxAILogoScene)
self.grLuxAILogo.fitInView(luxAILogoScene.sceneRect(), Qt.KeepAspectRatio)
# initialize calibration file selection dialog
self.dlgLoadCalibFile = QFileDialog()
self.dlgLoadCalibFile.setFileMode(QFileDialog.ExistingFile)
self.dlgLoadCalibFile.setFilter("Calibration files (*.clb)")
self.dlgLoadCalibFile.setAcceptMode(QFileDialog.AcceptOpen)
# initialize color file selection dialog
self.dlgLoadColorFile = QFileDialog()
self.dlgLoadColorFile.setFileMode(QFileDialog.ExistingFile)
self.dlgLoadColorFile.setFilter("Color files (*.clr)")
self.dlgLoadColorFile.setAcceptMode(QFileDialog.AcceptOpen)
# initialize calibration file save dialog
self.dlgSaveCalibFile = QFileDialog()
self.dlgSaveCalibFile.setFileMode(QFileDialog.AnyFile)
self.dlgSaveCalibFile.setFilter("Calibration files (*.clb)")
self.dlgSaveCalibFile.setAcceptMode(QFileDialog.AcceptSave)
# initialize rotation exercises warning message box
self.msgRotationExercises = QMessageBox()
self.msgRotationExercises.setIcon(QMessageBox.Warning)
self.msgRotationExercises.setText("Sorry, rotation exercises have not been implemented yet!")
self.msgRotationExercises.setInformativeText("Please choose one of the motion exercises instead until rotation exercises become available.")
self.msgRotationExercises.setWindowTitle("Rotation exercises warning")
self.msgRotationExercises.setStandardButtons(QMessageBox.Ok)
# initialize calibration fail message box
self.msgErrorWarning = QMessageBox()
self.msgErrorWarning.setIcon(QMessageBox.Warning)
self.msgErrorWarning.setStandardButtons(QMessageBox.Ok)
# initialize list of faces (in string form)
self._faces_list = ["sad", "happy", "crying", "neutral", "showing_smile", "surprise", "breathing_exercise", "breathing_exercise_nose", "smile", "happy_blinking", "calming_down", "random emotion"]
self.cmbFaces.addItems(self._faces_list)
# disable various labels and widgets on startup
self.lblPerRepetitions1.setEnabled(False)
self.lblPerRepetitions2.setEnabled(False)
self.spnQuantEncRep.setEnabled(False)
self.cmbQualiEnc.setEnabled(False)
self.btnDeleteLine.setEnabled(False)
self.spnFixedReps.setEnabled(False)
self.spnFrequencyReps.setEnabled(False)
self.btnAddLine.setEnabled(False)
self.lblAuth.setVisible(False)
self.lblPINCode.setVisible(False)
self.lnPINCode.setVisible(False)
self.btnConfirm.setVisible(False)
self.lblHelloMsg.setVisible(False)
self.lblRemove.setVisible(False)
self.grProfilePicture.setVisible(True)
self.tabWidget.setTabEnabled(1, False)
self.tabWidget.setTabEnabled(2, False)
self.tabWidget.setTabEnabled(3, False)
self.tabWidget.setTabEnabled(4, False)
self.lblWrongPINCode.setVisible(False)
self.grProfilePicture.setVisible(False)
# resize table columns to match their text size
header = self.tblEmotionalFeedback.horizontalHeader()
header.setResizeMode(0, QHeaderView.Stretch)
header.setResizeMode(1, QHeaderView.Stretch)
header.setResizeMode(2, QHeaderView.Stretch)
# initialize ROS publisher topics
rospy.init_node("reha_interface", anonymous=True)
self._exercise_request_pub = rospy.Publisher("exercise_request", ExerciseRequest, queue_size=1)
self._exercise_stop_pub = rospy.Publisher("exercise_stop", Bool, queue_size=1)
self._calibration_request_pub = rospy.Publisher("calibration_request", CalibrationRequest, queue_size=1)
rospy.Subscriber("exercise_reply", ExerciseReply, self._server_reply_callback)
rospy.Subscriber("calibration_reply", CalibrationReply, self._server_reply_callback)
rospy.Subscriber("/plain/image_modified/compressed", CompressedImage, self._img_received_callback)
rospy.Subscriber("/user_logging/initial_key", String, self._smartcard_detected_callback)
#self._decryption_node = None
# initialize some other necessary variables
self._is_calibrating = False
self._is_exercise_running = False
self._bridge = CvBridge()
# connect functions to widgets
self.btnInternalRotationExercise.clicked.connect(self.btnInternalRotationExerciseClicked)
self.btnExternalRotationExercise.clicked.connect(self.btnExternalRotationExerciseClicked)
self.btnAbductionMotionExercise.clicked.connect(self.btnAbductionMotionExerciseClicked)
self.btnFlexionMotionExercise.clicked.connect(self.btnFlexionMotionExerciseClicked)
self.btnBegin.clicked.connect(self.btnBeginClicked)
self.btnStop.clicked.connect(self.btnStopClicked)
self.btnDefineNewColor.clicked.connect(self.openDefineNewColorWidget)
self.slNbrBlocks.valueChanged.connect(self.slNbrBlocksValueChanged)
self.rdFixed.clicked.connect(self.rdFixedClicked)
self.rdFrequency.clicked.connect(self.rdFrequencyClicked)
self.btnAddLine.clicked.connect(self.btnAddLineClicked)
self.cmbFaces.currentIndexChanged.connect(self.cmbFacesCurrentIndexChanged)
self.actionQuit.triggered.connect(self.closeEvent)
self.btnDeleteLine.clicked.connect(self.btnDeleteLineClicked)
self.tblEmotionalFeedback.itemClicked.connect(self.tblEmotionalFeedbackItemClicked)
self.chkQualitative.clicked.connect(self.chkQualitativeClicked)
self.chkQuantitative.clicked.connect(self.chkQuantitativeClicked)
self.btnLoadColorFile.clicked.connect(self.btnLoadColorFileClicked)
self.btnLoadCalibFile.clicked.connect(self.btnLoadCalibFileClicked)
self.btnCalibrateNow.clicked.connect(self.btnCalibrateNowClicked)
self.robot_finished.connect(robot_finished_triggered)
self.img_received.connect(img_received_triggered)
self.smartcard_rosmsg_received.connect(smartcard_rosmsg_received_triggered)
self.logoff_signal_received.connect(logoff_signal_received_triggered)
self.btnConfirm.clicked.connect(self.btnConfirmClicked)
self.lnPINCode.textChanged.connect(self.disableErrorLabelOnEdit)
def img_received_triggered(gui, img):
scene = QGraphicsScene()
pixmap = QGraphicsPixmapItem(QPixmap(img), None, scene)
gui.grOriginalImage.setScene(scene)
gui.grOriginalImage.fitInView(scene.sceneRect(), Qt.KeepAspectRatio)
class ImageGrabber(object):
'''
classdocs
'''
_config = mrConfigParser()
_gui = GuiLoader()
_img = None
__sources = []
__grabTimer = QTimer()
__scene = None
__gview = None
def __init__(self, gui=None, config=None):
'''
Constructor
'''
self._gui = GuiLoader()
self._config = config
if gui != None:
self._gui = gui
self.__initGui()
def __initGui(self):
'''
Initiates gui listeners
'''
# initiate scene
self.__gview = self._gui.getObj("imgVideo")
self.__scene = QGraphicsScene()
self.__gview.setScene(self.__scene)
# add image size combobox items
cmb = self._gui.getObj("cmbImgSize")
cmb.addItem("320x240")
cmb.addItem("640x480")
cmb.addItem("800x600")
cmb.addItem("1024x768")
#cmb.addItem("1280x960") # not working with libdc1394 and avt stringray 125c
# add conversion combobox items
cmb = self._gui.getObj("cmbConversion")
cmb.addItem("None")
cmb.addItem("COLOR_BGR2RGB")
cmb.addItem("COLOR_GRAY2RGB")
cmb.addItem("COLOR_YUV2RGB")
cmb.addItem("COLOR_HLS2RGB")
# add listeners
self._gui.connect("cmdStartVideo", "clicked()", self.startVideo)
self._gui.connect("cmdStopVideo", "clicked()", self.stopVideo)
self._gui.connect("cmdAddSource", "clicked()", self.__addCamSource)
self._gui.connect("cmdAddFile", "clicked()", self.__addFileSource)
self._gui.connect("cmdDelSource", "clicked()",
self.__removeSourceFromList)
self._gui.connect("cmbImgSize", "currentIndexChanged(QString)",
self.__imageSizeChanged)
self._gui.connect("cmdSaveImg", "clicked()", self.saveImg)
def isActive(self):
'''
@return: True if image grabbing is active
'''
return self.__grabTimer.isActive()
def startVideo(self):
'''
Starts grabbing images
'''
if self.__grabTimer.isActive():
self.__grabTimer.stop()
self.__grabTimer = QTimer()
self.__grabTimer.timeout.connect(self.__grabImage)
self.__grabTimer.start(0)
self._gui.status("Video started")
def stopVideo(self):
'''
Stops grabbing video
'''
if self.__grabTimer.isActive():
self.__grabTimer.stop()
self.__scene.clear()
self.__gview.show()
self._gui.status("Video stopped")
sleep(1)
def getImage(self):
'''
Returns the last grabbed image
@return: Image
'''
return self._img
def saveImg(self):
'''
Saves image
'''
if self._img != None:
img = self._img
# stop video
active = self.isActive()
self.stopVideo()
# open file dialog
options = copy(self._gui.dialogOptionsDef)
options['type'] = self._gui.dialogTypes['FileSave']
options['filetypes'] = "JPG (*.jpg)"
options['title'] = "Save current frame as"
src = str(self._gui.dialog(options))
# check filepath and save
if len(src) > 0:
if not src.endswith(".jpg"):
src = src + ".jpg"
self._gui.status("write to " + src)
cvtColor(img, COLOR_BGR2RGB)
imwrite(src, img)
# reset video streaming
if active:
self.startVideo()
def __showImage(self):
'''
Shows image on graphics view
'''
if self._img != None:
self.__scene.clear()
self.__scene.addPixmap(imageToPixmap(self._img))
self.__gview.fitInView(self.__scene.sceneRect(),
Qt.KeepAspectRatio)
self.__gview.show()
def __grabImage(self):
'''
Graps image from sources
'''
images = []
# grab all images
for src in self.__sources:
assert isinstance(src, AbstractSourceGrabber)
images.append(src.getImg())
# join and convert images
img = self.__joinImages(images)
# convert image
convert = eval(str(self._gui.getObj("cmbConversion").currentText()))
if convert != None:
try:
img = cvtColor(img, convert)
except:
img = None
# show results
if type(img) == ndarray:
# add image as new image
self._img = img
self.__showImage()
else:
# show message
self.__scene.clear()
self.__scene.addText("NO VIDEO")
def __joinImages(self, images=[]):
'''
Joins images
'''
# TO-DO: Joining images
if len(images) > 0:
return images[0]
return False
def __imageSizeChanged(self, size="640x480"):
'''
Changes image size
'''
size = str(size).split("x")
w = int(size[0])
h = int(size[1])
# set size
for cam in self.__sources:
if type(cam) == CamGrabber:
assert isinstance(cam, CamGrabber)
cam.setImgSize(w, h)
def __addSourceToList(self, grabber=None):
'''
Adds source to source list
'''
assert isinstance(grabber, AbstractSourceGrabber)
if grabber != None:
# add grabber to list
self.__sources.append(grabber)
txt = None
# get type of grabber
if type(grabber) == CamGrabber:
txt = "cam [" + str(grabber.getSource()) + "]"
elif type(grabber) == FileGrabber:
txt = "file [" + str(grabber.getSource()) + "]"
# add text string to gui list
if txt != None:
self._gui.getObj("lstSources").addItem(txt)
def __removeSourceFromList(self):
'''
Removes selected source from list
'''
for item in self._gui.getObj("lstSources").selectedItems():
# get item informationen
txt = str(item.text())
if "[" in txt and "]" in txt:
data = txt.split("[")
iType = data[0].strip()
iSource = data[1].replace(']', '')
# search for grabber
for grabber in self.__sources:
assert isinstance(grabber, AbstractSourceGrabber)
if str(grabber.getSource()) == iSource:
if type(grabber) == CamGrabber and iType == "cam":
self.__sources.remove(grabber)
break
elif type(grabber) == FileGrabber and iType == "file":
self.__sources.remove(grabber)
break
# remove source from gui list
item = self._gui.getObj("lstSources").takeItem(
self._gui.getObj("lstSources").currentRow())
item = None
def __addCamSource(self):
'''
Adds camera as source
'''
obj = self._gui.getObj("txtSource")
source = int(obj.text())
grabber = CamGrabber(source)
if grabber.isOpened():
self.__addSourceToList(grabber)
self._gui.status("Added camera source [" + str(source) + "]")
else:
self._gui.status(
"Could not add camera source [" + str(source) + "]",
self._gui.msgTypes['ERROR'])
def __addFileSource(self):
'''
Adds file as source
'''
self.stopVideo()
options = copy(self._gui.dialogOptionsDef)
options['filetypes'] = "Images (*.jpg *jpeg *gif *png *bmp *tif)"
source = str(self._gui.dialog(options))
if len(source) > 0:
grabber = FileGrabber(source)
self.__addSourceToList(grabber)
self._gui.status("Added file source [" + str(source) + "]")
def reduce_speed(self, factor=0.9):
for particle in self.particles:
particle.reduce_speed(factor)
def increase_speed(self, factor=1.1):
for particle in self.particles:
particle.increase_speed(factor)
def set_color(self, color):
for particle in self.particles:
particle.set_color(color)
def recalculate_new_pos(self):
for particle in self.particles:
particle.instant_pos_change()
if __name__ == "__main__":
app = QApplication(sys.argv)
scene = QGraphicsScene()
scene.setSceneRect(-400, -400.0, 800.0, 800.0)
particle_background = ParticlesBackgroundDecoration(scene)
view = QGraphicsView(scene)
view.showMaximized()
scene.setSceneRect(
view.mapToScene(view.viewport().geometry()).boundingRect())
particle_background.generate_particles(200)
particle_background.reduce_speed(0.3)
print scene.sceneRect()
app.exec_()
class ElevationScene(object):
def __init__(self, dialog, view):
self.dialog = dialog
self.view = view
self.scene = None
self.line = None
self.path = None
self.zone = None
self.pts = {}
self.y_delta = {
PT1: 0.,
PT2: 0.
}
self.fresnel_visible = False
self.frequency = 2400
@staticmethod
def path_for(points):
path = QPainterPath(points[0])
for point in points[1:]:
path.lineTo(point)
path.lineTo(points[-1].x(), 0)
path.lineTo(points[0].x(), 0)
path.lineTo(points[0])
return path
@staticmethod
def overlay_for(pt1, pt2, frequency):
# Construct the line-geometry, we'll use this to construct the ellipsoid
line = QLineF(pt1, pt2)
# Determine the radius for the ellipsoid
radius = fresnel_radius(line.length(), frequency)
# Draw the ellipsoid
zone = QPainterPath()
zone.addEllipse(QPointF(0., 0.), line.length() / 2, radius)
# Rotate the ellipsoid - same angle as the line
transform = QTransform()
transform.rotate(-line.angle())
zone = transform.map(zone)
# Center the zone over the line
lc = QRectF(pt1, pt2).center()
zc = zone.boundingRect().center()
zone.translate(lc.x() - zc.x(), lc.y() - zc.y())
return line, zone
def initialize(self, points, show_fresnel, frequency):
self.pts = {
PT1: points[0],
PT2: points[-1]
}
self.fresnel_visible = show_fresnel
self.frequency = frequency
# Construct static geometry to be included in the scene
path = self.path_for(points)
height = path.boundingRect().height()
gradient = QLinearGradient(QPointF(0., height), QPointF(0., 0.))
gradient.setColorAt(0, QColor(0x00b300))
gradient.setColorAt(1, QColor(0x331a00))
# Create the scene
self.scene = QGraphicsScene(self.dialog)
# Add geometries to the scene, keeping a reference to each
self.path = self.scene.addPath(path, QPen(Qt.blue, 1), QBrush(gradient))
# Update the scene; i.e. correct pen-colours etc.
self.update_scene(add_geometries=True)
# Set up the view with the constructed scene
self.view.setScene(self.scene)
self.view.ensureVisible(self.scene.sceneRect())
self.view.scale(1., -1.)
def update_scene(self, add_geometries=False):
# Get new geometries
line, zone = self.overlay_for(
self.pts[PT1] + QPointF(0., self.y_delta[PT1]),
self.pts[PT2] + QPointF(0., self.y_delta[PT2]),
self.frequency
)
# And update the line geometry - this shall be reflected in the scene
if add_geometries:
self.line = self.scene.addLine(line)
self.zone = self.scene.addPath(zone)
else:
self.line.setLine(line)
self.zone.setPath(zone)
# Colour the line & zone as appropriate
for item in (self.line, self.zone):
item.setPen(RPEN if item.collidesWithItem(self.path) else GPEN)
# Show/hide the fresnel zone as requested
self.zone.setVisible(self.fresnel_visible)
def zoom_event(self, pos, delta):
# Save the scene pos
old_pos = self.view.mapToScene(pos)
# Zoom
zoom_factor = ZOOM_IN_FACTOR if delta > 0 else ZOOM_OUT_FACTOR
self.view.scale(zoom_factor, zoom_factor)
# Translate scene such that zoom appears to center on mouse pointer pos
new_pos = self.view.mapToScene(pos)
delta = new_pos - old_pos
self.view.translate(delta.x(), delta.y())
def slider_event(self, point, value):
self.y_delta[point] = value
self.update_scene()
def fresnel_event(self, show_fresnel, value):
self.fresnel_visible = show_fresnel
self.frequency = value
self.update_scene()
# needed to layout and draw edges
diagram.set_anchors()
layouter.apply(diagram)
# edges must be updated after nodes are updated and layouted
for edge in diagram.edges.values():
edge.update()
# this actually paints things, so must be invoked when everything is
# ready
for drawable in diagram.elements():
scene.addItem(drawable)
drawable.resize_scene_rect()
adj_scene_rect = scene.sceneRect().adjusted(-margin, -margin, margin, margin)
scene.setSceneRect(adj_scene_rect)
diagramsize = adj_scene_rect.toRect().size()
img = QImage(QSize(diagramsize.width() * scale, diagramsize.height() * scale), QImage.Format_ARGB32)
painter = QPainter(img)
print margin
absoluteRect = QRectF(0, 0, scene.sceneRect().width() * scale, scene.sceneRect().height() * scale)
painter.fillRect(absoluteRect, QBrush(QColor(255, 255, 255), Qt.SolidPattern))
painter.resetMatrix()
scene.render(painter)
painter.end()
ret = img.save(output)
print("Saved to " + output)
