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)