Python QtWidgets.QGraphicsScene类代码示例

    def __init__(self, *args):
        super(Demo, self).__init__(*args)
  
        loadUi('MainWindow.ui', self)
        scene = QGraphicsScene()

        rectItem = QGraphicsRectItem(QRectF(0, 0, 320, 240))
        rectItem.setBrush(Qt.red)
        #rectItem.setPen(Qt.NoPen)
        rectItem.setFlag(QGraphicsItem.ItemIsMovable)
        scene.addItem(rectItem)

        ellipseItem = QGraphicsEllipseItem(QRectF(0, 0, 200, 200))
        ellipseItem.setBrush(Qt.blue)
        #ellipseItem.setPen(Qt.NoPen)
        ellipseItem.setFlag(QGraphicsItem.ItemIsMovable)
        scene.addItem(ellipseItem)

        rectSizeGripItem = SizeGripItem(SimpleResizer(rectItem), rectItem)
        ellipseSizeGripItem = SizeGripItem(SimpleResizer(ellipseItem), ellipseItem)

        graphicsView = QGraphicsView(self)
        graphicsView.setScene(scene)

        self.setCentralWidget(graphicsView)

 def __init__(self, conf, defeat):
     self.config = conf
     super().__init__()
     self.setWindowTitle(conf.get_text('victory'))
     self.setFixedSize(QSize(640, 480))
     self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.WindowTitleHint | Qt.FramelessWindowHint)
     button = QPushButton(conf.get_text('close'), self)
     button.setCheckable(True)
     button.setFixedSize(QSize(640, 30))
     button.move(0, 450)
     # noinspection PyUnresolvedReferences
     button.clicked.connect(self.close)
     result_output = QTextEdit(self)
     result_output.setReadOnly(True)
     result_output.setFixedSize(QSize(640, 200))
     result_output.move(0, 250)
     result_output.setLineWrapMode(QTextEdit.NoWrap)
     result_output.insertHtml(self.generate_result_text())
     gview = QGraphicsView(self)
     scene = QGraphicsScene()
     if defeat:
         img = conf.theme_selected.get_defeat_pixmap()
         text = conf.get_text('defeat')
     else:
         img = conf.theme_selected.get_victory_pixmap()
         text = conf.get_text('victory')
     scene.addPixmap(img.scaled(QSize(640, 220)))
     gview.move(0, 30)
     gview.setScene(scene)
     label_title = QLabel(self)
     label_title.setText(text)
     label_title.setFixedSize(QSize(640, 30))
     label_title.setAlignment(Qt.AlignCenter)
     label_title.setFont(self.get_font_title())

    def __init__(self):
        super(VideoSortApp, self).__init__()
        self.setupUi(self)
        self.filename = None
        self.directory = None
        self.sort.setEnabled(False)
        self.fileOpen.clicked.connect(self.fileDialog)
        self.dirOpen.clicked.connect(self.folderDialog)
        self.sort.clicked.connect(self.sortVideo)
        self.results.setViewMode(self.results.IconMode)
        self.results.setResizeMode(self.results.Adjust)
        self.features = []
        self.sorted = None

        #player properties
        self.player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
        self.playlist = QMediaPlaylist(self.player)
        self.videoItem = QGraphicsVideoItem()
        self.videoItem.setSize(QtCore.QSizeF(640, 480))
        scene = QGraphicsScene(self)
        scene.addItem(self.videoItem)
        self.graphicsView.setScene(scene)
        self.player.setVideoOutput(self.videoItem)
        self.graphicsView.resize(640,480)
        self.graphicsView.show()
        self.results.itemDoubleClicked.connect(self.seekVideo)
        self.videoLoaded = False

class GraphInstanceVM(BTreeInstanceVM):
    @classmethod
    def get_full_path(cls, file_name):
        file_path = os.path.join(config.src_path, file_name)
        return file_path

    @classmethod
    def get_model(cls, full_path):
        if os.path.exists(full_path):
            model = BTreeModel.load_file(full_path)
            return model
        else:
            return None

    def init_view(self):
        self.btree_scene = QGraphicsScene()
        self.btree_view = NodeEditorView(self.btree_scene)
        self.btree_view.setAttribute(Qt.WA_DeleteOnClose)
        self.btree_scene.setSceneRect(AREA)
        self.vm = NodeObserverVM(self.model, self.btree_view, self.btree_scene, self)

    def close_handler(self, ev):
        self.parent.remove_instance(self)

    def set_dirty(self):
        pass

 def __init__(self, *args):
   QGraphicsScene.__init__(self, *args)
   
   # Add a graphic item, not responsive to gestures??
   text = QGraphicsTextItem("Test")
   text.setTextInteractionFlags(Qt.TextEditorInteraction)
   self.addItem(text)

	def update_package_view(self):

		package = self.current_package

		try:
			mod = importlib.import_module('packages.{}'.format(package['type']))
		except ImportError:
			return

		# Draw package
#		f = tempfile.NamedTemporaryFile()
		f = open('tmp.svg', 'wb')
		import target_svg
		target = target_svg.get_target()
		target.add_package(package)

		process = {	'F': TolLen(0, 0.05, 1),
					'P': TolLen(0, 0.05, 1) }
		pac = mod.get_package(package['values'], 'IPC7351-B', process)
		pac.gen(target)

		target.output(f)
		f.flush()

		# Draw SVG output
		svg = QGraphicsSvgItem(f.name)
		scene = QGraphicsScene()
		scene.addItem(svg)

		self.package_ui.graphicsView.setScene(scene)

		f.close()

    def showogrenci(self):
        try:
            ogrenci = OgrenciGoster(self.parent)
            self.parent.mdi.addSubWindow(ogrenci)
            ogrenci.show()
            data = self.sender().data

            ogrenci.ad.setText(data[1])
            ogrenci.soyad.setText(data[2])
            ogrenci.anneadi.setText(data[4])
            ogrenci.babaadi.setText(data[5])

            gp = QGraphicsScene(self)
            ogrenci.graphicsView.setScene(gp)
            ogrenci.graphicsView.setFixedHeight(100)
            ogrenci.graphicsView.setFixedWidth(100)
            if data[8] is not None:
                gp.addPixmap(QPixmap("db/%s" % data[8]))
                ogrenci.graphicsView.show()

            nots = self.parent.db.getNot(data[0])
            ogrenci.tableWidget.setRowCount(len(nots))
            ogrenci.tableWidget.setColumnCount(1)
            ogrenci.tableWidget.setHorizontalHeaderLabels(["Notlar"])
            z = 0
            for i in nots:

                ogrenci.tableWidget.setItem(z,0,QTableWidgetItem(i[2]))
                z +=1

        except Exception as e:
            print(e)

class ImageView(QGraphicsView):

    def __init__(self, width=200, height=300):
        super().__init__()
        self.setFixedSize(QSize(width, height))
        self.image = None
        self.scene = QGraphicsScene()
        self.setScene(self.scene)

    """ファイル名より取得した画像表示"""
    def setImage(self, imageName):
        self.setCvImage(cv2.imread(imageName))

    """numpy配列より取得した画像表示"""
    def setCvImage(self, cvImage):
        cvImage = cv2.cvtColor(cvImage, cv2.COLOR_BGR2RGB)
        height, width, channel = cvImage.shape
        bytesPerLine = width * channel
        self.image = QImage(cvImage.data, width, height,
                            bytesPerLine, QImage.Format_RGB888)
        item = QGraphicsPixmapItem(QPixmap.fromImage(self.image))
        self.scene = QGraphicsScene()
        self.scene.addItem(item)
        self.setScene(self.scene)

    """ビューワクリア処理"""
    def clear(self):
        self.scene.clear()

    def mouseMoveEvent(self, event):
        QGraphicsScene.mouseMoveEvent(self, event)
        self.mousePos = event.scenePos()
        if not (any((key.pressed for key in self.piano_keys))):
            m_pos = event.scenePos()
            if self.insert_mode and self.place_ghost: #placing a note
                m_width = self.ghost_rect.x() + self.ghost_rect_orig_width
                if m_pos.x() > m_width:
                    m_new_x = self.snap(m_pos.x())
                    self.ghost_rect.setRight(m_new_x)
                    self.ghost_note.setRect(self.ghost_rect)
                #self.adjust_note_vel(event)
            else:
                m_pos = self.enforce_bounds(m_pos)

                if self.insert_mode: #ghostnote follows mouse around
                    (m_new_x, m_new_y) = self.snap(m_pos.x(), m_pos.y())
                    self.ghost_rect.moveTo(m_new_x, m_new_y)
                    try:
                        self.ghost_note.setRect(self.ghost_rect)
                    except RuntimeError:
                        self.ghost_note = None
                        self.makeGhostNote(m_new_x, m_new_y)

                elif self.marquee_select:
                    marquee_orig_pos = event.buttonDownScenePos(Qt.LeftButton)
                    if marquee_orig_pos.x() < m_pos.x() and marquee_orig_pos.y() < m_pos.y():
                        self.marquee_rect.setBottomRight(m_pos)
                    elif marquee_orig_pos.x() < m_pos.x() and marquee_orig_pos.y() > m_pos.y():
                        self.marquee_rect.setTopRight(m_pos)
                    elif marquee_orig_pos.x() > m_pos.x() and marquee_orig_pos.y() < m_pos.y():
                        self.marquee_rect.setBottomLeft(m_pos)
                    elif marquee_orig_pos.x() > m_pos.x() and marquee_orig_pos.y() > m_pos.y():
                        self.marquee_rect.setTopLeft(m_pos)
                    self.marquee.setRect(self.marquee_rect)
                    self.selected_notes = []
                    for item in self.collidingItems(self.marquee):
                        if item in self.notes:
                            self.selected_notes.append(item)

                    for note in self.notes:
                        if note in self.selected_notes: note.setSelected(True)
                        else: note.setSelected(False)

                elif self.velocity_mode:
                    if Qt.LeftButton == event.buttons():
                        for note in self.selected_notes:
                            note.updateVelocity(event)

                elif not self.marquee_select: #move selected
                    if Qt.LeftButton == event.buttons():
                        x = y = False
                        if any(note.back.stretch for note in self.selected_notes):
                            x = True
                        elif any(note.front.stretch for note in self.selected_notes):
                            y = True
                        for note in self.selected_notes:
                            note.back.stretch = x
                            note.front.stretch = y
                            note.moveEvent(event)

    def initialize_loading_page(self):
        svg_container = QGraphicsScene(self.window().loading_svg_view)
        svg_item = QGraphicsSvgItem()

        svg = QSvgRenderer(get_image_path("loading_animation.svg"))
        svg.repaintNeeded.connect(svg_item.update)
        svg_item.setSharedRenderer(svg)
        svg_container.addItem(svg_item)

        self.window().loading_svg_view.setScene(svg_container)
        self.window().core_manager.events_manager.upgrader_tick.connect(self.set_loading_text)
        self.window().core_manager.events_manager.upgrader_started.connect(
            lambda: self.set_loading_text("Upgrading..."))
        self.window().core_manager.events_manager.upgrader_finished.connect(lambda: self.loading_label.hide())

        # Create a loading label that displays the status during upgrading
        self.loading_label = QLabel(self)
        self.loading_label.setStyleSheet("color: #ddd; font-size: 22px;")
        self.loading_label.setAlignment(Qt.AlignCenter)

        self.on_window_resize()
        self.loading_label.hide()

        # Hide the force shutdown button initially. Should be triggered by shutdown timer from main window.
        self.window().force_shutdown_btn.hide()

class OverlaidGraphicsView(QGraphicsView):
    def __init__(self, parent=None):
        super(OverlaidGraphicsView, self).__init__(parent)
        self.m_overlayScene = QGraphicsScene()

    def setOverlayScene(self, scene):
        if scene is self.m_overlayScene:
            return

        self.m_overlayScene = scene
        scene.changed.connect(self.overlayChanged)
        self.update()

    def overlayScene(self):
        return self.m_overlayScene

    def paintEvent(self, ev):
        super(OverlaidGraphicsView, self).paintEvent(ev)
        if self.m_overlayScene is not None:
            self.paintOverlay()

    def paintOverlay(self):
        p = QPainter(self.viewport())
        p.setRenderHints(self.renderHints())

        sourceRect = self.scene().sceneRect()
        targetRect = self.mapFromScene(sourceRect).boundingRect()

        self.m_overlayScene.render(p, QRectF(targetRect), QRectF(sourceRect), QtCore.Qt.IgnoreAspectRatio)

    @pyqtSlot()
    def overlayChanged(self):
        self.update()

    def set_signal(self):
        indx = self.ui.combobox_signals.currentIndex()
        if indx != 0:
            self.ui.inpt.setReadOnly(True)
        else:
            self.ui.inpt.setReadOnly(False)
            self.ui.inpt.setText("10010110")
            self.decoder_update()
            return

        signal = self.signals[indx - 1]
        pa = ProtocolAnalyzer(signal)
        pa.get_protocol_from_signal()
        self.ui.inpt.setText("".join(pa.decoded_proto_bits_str))

        tmp_scene = QGraphicsScene()
        tmp_scene.addText(self.tr("Loading Signal..."))
        QApplication.instance().setOverrideCursor(Qt.WaitCursor)
        self.ui.graphicsView_signal.setScene(tmp_scene)

        if signal is not None:
            last_message = pa.messages[-1]
            lookup = {i: msg.bit_sample_pos for i, msg in enumerate(pa.messages)}

            plot_data = signal.qad[lookup[0][0]:lookup[pa.num_messages - 1][len(last_message) - 1]]
            self.ui.graphicsView_signal.plot_data(plot_data)

        self.ui.graphicsView_signal.centerOn(0, 0)
        QApplication.instance().restoreOverrideCursor()

    def imgInit(self):
        self.cv_img = cv2.imread(os.path.join(sampleDataPath,"color_filter_test.png"))


        self.frameBuffer = Queue()
        self.frameBufferItemGroup = QGraphicsItemGroup()
        self.frameBufferItemGroup.hide()
        self.inputPixmapRenderScene = QGraphicsScene()
        self.inputPixmapRenderScene.addItem(self.frameBufferItemGroup)

        self.inputScene = QGraphicsScene()
        self.inputGraphicsView.setScene(self.inputScene)
        self.inputGraphicsView.resizeEvent = self.graphicsViewResized
        # self.inputScene.addItem(self.frameBufferItemGroup)

        qimg = misc.cvMatToQImage(self.cv_img)
        self.inputPixmap = QPixmap.fromImage(qimg)
        self.inputPixmapItem = QGraphicsPixmapItem(self.inputPixmap)
        self.inputScene.addItem(self.inputPixmapItem)

        self.rubberBand = QtWidgets.QRubberBand(QtWidgets.QRubberBand.Rectangle, self.inputGraphicsView)
        self.inputGraphicsView.mousePressEvent = self.inputGraphicsViewMousePressEvent
        self.inputGraphicsView.mouseMoveEvent = self.inputGraphicsViewMouseMoveEvent
        self.inputGraphicsView.mouseReleaseEvent = self.inputGraphicsViewMouseReleaseEvent

        self.inputGraphicsView.viewport().installEventFilter(self)

        self.inputGraphicsView.setMouseTracking(True)
        self.overlayScene = QGraphicsScene()
        self.inputGraphicsView.setOverlayScene(self.overlayScene)

        self.zoomedGraphicsView.setScene(self.inputScene)
        self.zoomedGraphicsView.setOverlayScene(self.overlayScene)

    def __init__(self, map, *args):
        super().__init__(*args)
        self.map = map
        self.position = map.center

        self.providers = deque([
            'osm', 'stamen-terrain', 'stamen-toner-lite', 'stamen-toner',
            'stamen-watercolor', 'ms-aerial', 'ms-hybrid', 'ms-road',
            'bluemarble',
        ])

        self.refresh_map = asyncio.Event()

        scene = QGraphicsScene()
        self.scene = scene
        self.setScene(scene)
        self.map_layer = QGraphicsPixmapItem()
        scene.addItem(self.map_layer)

        self.circle = QGraphicsEllipseItem(0, 0, 20, 20)
        pen = QPen(QColor(255, 0, 0, 128))
        pen.setWidth(2)
        self.circle.setPen(pen)
        scene.addItem(self.circle)

        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)

 def initUI(self):
     self.scene1=QGraphicsScene()
     self.scene2=QGraphicsScene()
     self.scene3=QGraphicsScene()
     self.scene4=QGraphicsScene()
     self.actionOpen.triggered.connect(self.imageOpen)
     self.histogram.clicked.connect(self.imageHistogram)
     self.GrayvalueScrollBar.valueChanged.connect(self.sliderval)
     self.OTSU.clicked.connect(self.OTSUThreshold)
     self.MedianFilter.clicked.connect(self.medianfilter)
     self.MeanFilter.clicked.connect(self.meanfilter)
     self.GaussianFilter.clicked.connect(self.gaussianfilter)
     self.CoustomizedFilter.clicked.connect(self.coustomizefilter)
     self.BinaryErosion.clicked.connect(self.binaryerosion)
     self.BinaryDilation.clicked.connect(self.binarydilation)
     self.actionClear_All.triggered.connect(self.clearall)
     self.DistanceTransform.clicked.connect(self.distancetransform)
     self.Skeleton.clicked.connect(self.skeleton)
     self.SkeletonRestoration.clicked.connect(self.skeletonrestoration)
     self.GrayErosion.clicked.connect(self.grayerosion)
     self.GrayDilation.clicked.connect(self.graydilation)
     self.EdgeDetection.clicked.connect(self.edgedetection)
     self.Gradient.clicked.connect(self.gradient)
     self.Reconstraction_Binary.clicked.connect(self.reconstruction_binary)
     self.Reconstraction_Gray.clicked.connect(self.reconstruction_gray)