Python QGraphicsScene.addWidget方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addWidget [as 别名]
class MainWindow(MainControlMixin, MainEventsMixin, QMainWindow):
    def __init__(self):
        logger.info('%s init', self.__class__.__qualname__)
        super().__init__()
        self._setupWindow()
        self._attachElements()
        self._setupContextMenu()

    @inject.params(gs=GState)
    def reloadState(self, chgs={}, gs=None):
        if gs.cfg:
            self.setupDynamic(gs.cfg)
        if gs.bud or gs.bReload['Window']:
            # self.scene.clear()
            # self.wdg = BudWidget(gs.bud, gs.cfg)
            # self.scene.addWidget(self.wdg)
            self.wdg.refreshBuds()
            self.centerOnCursor()
        if chgs.get('toggle', False):
            self.setVisible(not self.isVisible())

    def _attachElements(self):
        self.ipr = InputProcessor()
        self.wdg = BudWidget()
        self.scene = QGraphicsScene()
        self.scene.addWidget(self.wdg)
        self.view = MainView(self.scene)
        self.setCentralWidget(self.view)

    def _setupWindow(self):
        self.setAttribute(Qt.WA_TranslucentBackground)
        wflags = Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint | Qt.Tool
        self.setWindowFlags(self.windowFlags() | wflags)
        self.installEventFilter(self)
        self.setMouseTracking(True)

        self.setMinimumSize(10, 10)
        self.setWindowTitle("{} {}".format(
            piony.__appname__, piony.__version__))

    def _setupContextMenu(self):
        from PyQt5.QtWidgets import QAction
        # SEE: http://doc.qt.io/qt-5/qtwidgets-mainwindows-menus-example.html
        aQuit = QAction("E&xit", self, shortcut="Ctrl+Q",
                        shortcutContext=Qt.ApplicationShortcut,
                        triggered=qApp.quit)
        self.addAction(aQuit)
        # TODO: for release use Qt.NoContextMenu, enable only in edit-mode
        self.setContextMenuPolicy(Qt.ActionsContextMenu)

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addWidget [as 别名]
class Minimap2(QGraphicsView):

    '''
    Minimap
    '''

    def __init__(self, parent=0):
        '''
        Constructor
        '''

        super(Minimap2, self).__init__(parent)

        self._scene = QGraphicsScene()
        self.setRenderHint(QPainter.Antialiasing, True)
        self._text_browser = TextBrowser()
        self._scrollbar = None
        self.setAutoFillBackground(True)

#        try:
#            from PyQt5.QtWidgets import QOpenGLWidget
#            self.setViewport(QOpenGLWidget())
# except ImportError: # work around for pyQt 5.2
#            from PyQt5.QtOpenGL import QGLWidget
#            self.setViewport(QGLWidget())

        self.setScene(self._scene)
        self.setAlignment(Qt.AlignTop)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        # cursor:
        self._nav_cursor = Cursor()
        self._nav_cursor.graphics_view = self
        self._scene.addItem(self._nav_cursor)
        self._nav_cursor.setZValue(1)

        self._text_edit = None
        self._minimap_doc = None
        self._doc = None

        self._graphics_proxy_text_browser = self._scene.addWidget(
            self._text_browser)
        self._scale = 0.2
        self._graphics_proxy_text_browser.setScale(self._scale)

    def update_minimap_doc(self, position, charsRemoved, charsAdded):

        def select_blocks(first_block,  last_block):
            first_block_pos = first_block.position()
            doc_cursor.setPosition(first_block_pos)
            last_block_pos = last_block.position()
            doc_cursor.setPosition(last_block_pos,  QTextCursor.KeepAnchor)
            doc_cursor.movePosition(
                QTextCursor.EndOfBlock,  QTextCursor.KeepAnchor)
            print("selected text :",  doc_cursor.selectedText())
            return doc_cursor.selectedText()

        doc_cursor = QTextCursor(self._doc)
        minimap_cursor = QTextCursor(self._minimap_doc)

        # IF one same block is modified
        if self._minimap_doc.blockCount() == self._doc.blockCount():
            doc_cursor.setPosition(position)
            doc_cursor.select(QTextCursor.BlockUnderCursor)
            minimap_cursor.setPosition(position)
            minimap_cursor.select(QTextCursor.BlockUnderCursor)
            minimap_cursor.insertFragment(doc_cursor.selection())
        # TODO: if the doc is modified on more than one block but resulting in
        # the same count of blocks (right now only the first block would be
        # updated)
        else:
            # ELSE
            doc_cursor.select(QTextCursor.Document)
            minimap_cursor.select(QTextCursor.Document)
            minimap_cursor.insertFragment(doc_cursor.selection())

    @property
    def text_edit(self):
        return self._text_edit

    @text_edit.setter
    def text_edit(self, text_edit):
        if not isinstance(text_edit, QTextEdit):
            return
        self._text_edit = text_edit
        # self._text_edit.textChanged.connect(self.update)
        # self._scrollbar.valueChanged.connect(self._change_cursor_pos)

        self.setFixedWidth(self._text_edit.width() * self._scale)

        self._doc = self._text_edit.document()

        # connect scrollbar
        baseScrollBar = self._text_edit.verticalScrollBar()
        baseScrollBar.rangeChanged.connect(self._set_scrollBar_range)
        # baseScrollBar.valueChanged.connect(self._text_browser.verticalScrollBar().setValue)
        self._text_browser.verticalScrollBar().valueChanged.connect(
            baseScrollBar.setValue)
        self._text_browser.verticalScrollBar().hide()
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import addWidget [as 别名]
class GUI(Ui_MainWindow):
    def __init__(self):
        super().setupUi(MainWindow)
        self.initUI()
    #connect widgets with functions
    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)

    #function menubar-file-open: Open image and show it in view1
    def imageOpen(self):
#        filename,_ = QFileDialog.getOpenFileName(MainWindow,'Open a image',os.getenv('HOME'))
        filename,_ = QFileDialog.getOpenFileName(MainWindow,'Open a image','.',"Image Files(*.bmp *jpg *png *jpeg)")
#        filename="/home/lab105/git-sen/python_gui/lena512.bmp"
#        print(filename)
        pix=QtGui.QPixmap(filename)
        pix=pix.scaledToHeight(256)
        self.image=plt.imread(filename)
        Size=self.image.shape
        if (len(Size)==3):
            if (type(self.image[1,1,1]) is np.float32):
                self.image=misc.imread(filename) 
            self.image=self.image[:,:,1]
        self.image_temp=self.image
        self.scene1.addPixmap(QPixmap(pix))
        self.View1.setScene(self.scene1)
        self.clearall()

    #function mainwindow tab histogram-greylevel histogram: compute and show the greyvalue histogram in view 2
    def imageHistogram(self):
        greyimage=self.image
        #greyimage.dtype
        Height, Width=greyimage.shape
        x=np.zeros(Height*Width)
        for h in range(Height):
            for w in range(Width):
                x[h*Height+w]=greyimage[h,w]

        num_bins=255
        plt.figure(figsize=(256,256),dpi=1)
        n,self.bins,patches=plt.hist(x,num_bins,normed=1,facecolor='green',alpha=0.5)
        plt.axis("off")
        plt.gca().set_position([0,0,1,1])
        self.figure=plt.gcf()
        canvas2=FigureCanvas(self.figure)
        self.scene2.addWidget(canvas2)
        self.View2.setScene(self.scene2)


    def sliderval(self):
        Threshold=self.GrayvalueScrollBar.value()
        self.Binarization(Threshold)
#        self.label.setText(str(Threshold))

    #threshlod function 
    def Binarization(self,Threshold):
        #filename="/home/lab105/git-sen/python_gui/lena512.bmp"
        #img=misc.imread(filename)
        img=self.image
        BinaryArray= img >Threshold
        plt.close(3)
        plt.figure(num=3,figsize=(256,256),dpi=1)
        plt.axis("off")
        plt.gca().set_position([0,0,1,1]) 
        plt.imshow(BinaryArray,cmap='binary_r')
        figure3=plt.gcf()
        canvas3=FigureCanvas(figure3)
        self.scene3.clear()
        self.scene3.addWidget(canvas3)
        self.View3.setScene(self.scene3)
        self.label.setText(str(Threshold))

    def OTSUThreshold(self):
        img=self.image
        thresh=threshold_otsu(img)
        binary=img > thresh
        self.showView4(binary)

#.........这里部分代码省略.........