Python QGraphicsScene.setSceneRect方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        
        self.graphicsView = QGraphicsView()
        
        scene = QGraphicsScene(self.graphicsView)
        scene.setSceneRect(0, 0, MainWindow.WINDOW_WIDTH, MainWindow.WINDOW_HEIGHT)
         
        self.graphicsView.setScene(scene)
        self.screen = Screen(MainWindow.WINDOW_WIDTH, MainWindow.WINDOW_HEIGHT)
        
        scene.addItem(self.screen)

        mainLayout = QHBoxLayout()
        mainLayout.setAlignment(Qt.AlignTop)
        mainLayout.addWidget(self.graphicsView)

        self.setLayout(mainLayout)
        self.setWindowTitle("Coup")
        self.updating_rule = False
        self.show()
        
        # タイマースタート
        self.timer = QTimer()
        self.timer.setInterval(int(1000 / MainWindow.FPS))
        self.timer.timeout.connect(self.timeout)
        self.timer.start()

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
class PlotView(QGraphicsView):
    def __init__(self, clrs=colours, parent=None):
        QGraphicsView.__init__(self, parent)
        self.scene = QGraphicsScene(self)
        self.scene.setSceneRect(QtCore.QRectF(0, 0, 440, 340))
        self.setScene(self.scene)
        self.setBackgroundBrush(QtGui.QBrush(QtGui.QColor(0, 0, 0, 0)))
        self.setMinimumSize(100, 100)
        self.colours = clrs

    def setBackground(self, colour):
        self.setBackgroundBrush(QtGui.QBrush(colour))

    def addLinePlot(self):
        self.plot = LinePlot(self.colours)
        self.scene.addItem(self.plot)

    def addHHeaders(self, headers):
        self.plot.addHHeaders(headers)

    def addSeries(self, series, label):
        self.plot.plot(series, label)

    def clearPlotContents(self):
        self.plot.clearPlotContents()

    def addLimit(self, value):
        self.plot.addLimitLine(value)

    def resizeEvent(self, event):
        self.scene.setSceneRect(QtCore.QRectF(
            0, 0, event.size().width(), event.size().height()))
        if self.plot:
            self.plot.updatePlot()

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
def go():
    global graphic_view, status_label
    data_parent, data_child = Pipe(duplex=False)
    receiver = Process(target=generate_data, args=(data_child,))
    receiver.daemon = True
    receiver.start()

    scene = QGraphicsScene()
    graphic_view.setScene(scene)
    scene.setSceneRect(0, 0, 1024, 1024)

    x_pos = 0
    y_pos = 0
    t = time.time()
    while True:
        speed = time.time()
        data = data_parent.recv()
        spectrogram = Spectrogram(data)
        pixmap = QPixmap.fromImage(spectrogram.create_spectrogram_image(transpose=True))

        scene.setSceneRect(scene.sceneRect().adjusted(0, 0, 0, pixmap.height()))
        item = scene.addPixmap(pixmap)
        item.setPos(x_pos, y_pos)
        y_pos += pixmap.height()
        graphic_view.fitInView(scene.sceneRect())
        status_label.setText("Height: {0:.0f} // Speed: {1:.2f}  // Total Time: {2:.2f}".format(scene.sceneRect().height(),
                                                                                                1/(time.time()-speed),
                                                                                                time.time()-t))
        QApplication.instance().processEvents()

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
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

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
    def __init__(self):
        super(GraphWidget, self).__init__()

        self.timerId = 0

        scene = QGraphicsScene(self)
        scene.setItemIndexMethod(QGraphicsScene.NoIndex)
        scene.setSceneRect(-200, -200, 400, 400)
        self.setScene(scene)
        self.setCacheMode(QGraphicsView.CacheBackground)
        self.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
        self.setRenderHint(QPainter.Antialiasing)
        self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
        self.setResizeAnchor(QGraphicsView.AnchorViewCenter)

        node1 = Node(self)
        node2 = Node(self)
        node3 = Node(self)
        node4 = Node(self)
        self.centerNode = Node(self)
        node6 = Node(self)
        node7 = Node(self)
        node8 = Node(self)
        node9 = Node(self)
        scene.addItem(node1)
        scene.addItem(node2)
        scene.addItem(node3)
        scene.addItem(node4)
        scene.addItem(self.centerNode)
        scene.addItem(node6)
        scene.addItem(node7)
        scene.addItem(node8)
        scene.addItem(node9)
        scene.addItem(Edge(node1, node2))
        scene.addItem(Edge(node2, node3))
        scene.addItem(Edge(node2, self.centerNode))
        scene.addItem(Edge(node3, node6))
        scene.addItem(Edge(node4, node1))
        scene.addItem(Edge(node4, self.centerNode))
        scene.addItem(Edge(self.centerNode, node6))
        scene.addItem(Edge(self.centerNode, node8))
        scene.addItem(Edge(node6, node9))
        scene.addItem(Edge(node7, node4))
        scene.addItem(Edge(node8, node7))
        scene.addItem(Edge(node9, node8))

        node1.setPos(-50, -50)
        node2.setPos(0, -50)
        node3.setPos(50, -50)
        node4.setPos(-50, 0)
        self.centerNode.setPos(0, 0)
        node6.setPos(50, 0)
        node7.setPos(-50, 50)
        node8.setPos(0, 50)
        node9.setPos(50, 50)

        self.scale(0.8, 0.8)
        self.setMinimumSize(400, 400)
        self.setWindowTitle("Elastic Nodes")

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
 def __init__(self):
     super(MainWindow, self).__init__()
     scene = QGraphicsScene(self)
     self.tic_tac_toe = TicTacToe()
     scene.addItem(self.tic_tac_toe)
     scene.setSceneRect(0, 0, 300, 300)
     self.setScene(scene)
     self.setCacheMode(QGraphicsView.CacheBackground)
     self.setWindowTitle("Tic Tac Toe")

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
 def generateData(self, canvas, lines, params):
     scene = QGraphicsScene()
     scene.setSceneRect(canvas)
     group = scene.createItemGroup([])
     for line in lines:
         clone = QGraphicsLineItem(line)
         clone.setLine(line.line())
         clone.setPen(line.pen())
         scene.addItem(clone)
         group.addToGroup(clone)
     pixmaps = []
     for i in xrange(params.count):
         pixmaps.append(self.generateRandom(scene, group, canvas, params))
     return pixmaps

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
def main():

    app = QApplication(sys.argv)

    grview = QGraphicsView()
    scene = QGraphicsScene()
    scene.setSceneRect(0, 0, 680, 459)

    scene.addPixmap(QPixmap('../images/phototest.tif'))
    grview.setScene(scene)

    item = AreaItem(0, 0, 300, 150)
    item.areaColor = QColor(155, 155, 0, 75)
    scene.addItem(item)

    grview.fitInView(scene.sceneRect(), Qt.KeepAspectRatio)
    grview.show()
    sys.exit(app.exec_())

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()

        self.scene = QGraphicsScene()
        self.scene.setSceneRect(QRectF(0, 0, 1000, 1000))

        item = FlumeObject("source", "r1")
        self.scene.addItem(item.pictogram)
        item.pictogram.setPos(200, 200)

        layout = QHBoxLayout()
        self.view = QGraphicsView(self.scene)
        layout.addWidget(self.view)
        self.view.setAlignment(Qt.AlignLeft | Qt.AlignTop)  # FIXME doesn't work as needed

        self.widget = QWidget()
        self.widget.setLayout(layout)

        self.setCentralWidget(self.widget)
        self.setWindowTitle("The Flume Illustrator")

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
    def addItem(self, graphicsView: QGraphicsView, item: CharItem) -> QGraphicsScene:
        """ Add Item to one of the 2 windows

            Args:
                graphicsView (QGraphicsView): The graphics view to put the item in
                item         (CharItem)     : The char item to put in the view

            Returns:
                QGraphicsScene  : The graphics scene created for the view
        """

        scene = QGraphicsScene()
        graphicsView.setScene(scene)
        newItem = CharItem(QRectF(0, 0, mainItemWidth, mainItemHeight), QPointF(mainItemPadding, mainItemPadding))
        copiedItem = QByteArray()
        stream = QDataStream(copiedItem, QIODevice.WriteOnly)
        item.save(stream, item.filename)
        stream = QDataStream(copiedItem, QIODevice.ReadOnly)
        newItem.load(stream, item.filename)
        scene.addItem(newItem)
        scene.setSceneRect(0, 0, mainItemWidth + 2 * mainItemPadding + 6, mainItemHeight + 2 * mainItemPadding)
        return scene

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
    def init_ui(self):

        scene = QGraphicsScene()
        scene.setBackgroundBrush(QColor(100, 100, 100))
        scene.setItemIndexMethod(QGraphicsScene.BspTreeIndex)

        scene.setSceneRect(scene.itemsBoundingRect())

        self.setDragMode(QGraphicsView.RubberBandDrag)
        self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
        self.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)

        self.frame_item = QGraphicsPixmapItem()

        self.text_item_offset = 0
        self.rect_item_array = []
        self.text_item_array = []
        for i in range(0, 5):
            rect_item = QGraphicsRectItem()
            rect_item.setVisible(False)
            rect_item.setZValue(20.0)
            rect_item.setPen(QPen(Qt.red, 5))
            rect_item.setRect(20, 20, 20, 20)
            scene.addItem(rect_item)
            self.rect_item_array.append(rect_item)
            text_item = QGraphicsSimpleTextItem("")
            text_item.setBrush(QBrush(Qt.red))
            text_item.setZValue(20.0)
            text_item.setPos(10, 50)
            text_item.setFont(QFont("黑体", 24))
            text_item.setVisible(False)
            scene.addItem(text_item)
            self.text_item_array.append(text_item)

        scene.addItem(self.frame_item)

        self.curr_factor = 1.0

        self.setScene(scene)

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
	def init(self):
		self.window = loadUi(os.path.join(get_ui_path(),"splash.ui"))
		self.window.setWindowFlags(Qt.FramelessWindowHint|Qt.WindowStaysOnTopHint)
		self.center()
		self.window.li.setText(notice()+"\n"+version())
		self.window.setModal(Qt.WindowModal)
		self.window.image.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
		self.window.image.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

		window_h=self.window.height()
		window_w=self.window.width()
		r=random.randint(2, 3)
		image=QPixmap(os.path.join(get_image_file_path(),"splash"+str(r)+".png"))
		image.scaledToHeight(window_h)

		w=image.width()
		h=image.height()
		x_max=w-window_h-window_w/2

		hour=float(time.strftime("%H"))*60
		m=float(time.strftime("%m"))
		tot=hour+m
		my_max=float(24*60)

		value=tot/my_max

		xpos=int(x_max*value)+window_w/2
		print("xpos=",xpos)
		scene=QGraphicsScene();
		scene.setSceneRect(xpos, 0, 0, h)
		self.window.image.setScene(scene)

		self.window.show()

		scene.addPixmap(image);

		QTimer.singleShot(1500, self.callback_destroy)

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
class BTreeInstanceVM(object):
    def __init__(self, model, parent, file_name):
        self.file_name = file_name
        self.file_path = os.path.abspath(file_name)
        self.modified = False
        self.model = model
        self.parent = parent
        self.current_graphics_node = None

        self.init_view()
        self.sub_window = parent.mdi.addSubWindow(self.btree_view)
        self.sub_window.instance = self
        self.sub_window.setAttribute(Qt.WA_DeleteOnClose)
        self.update_title()
        self.btree_view.closeEvent = self.close_handler
        parent.add_instance(self)
        self.sub_window.show()

        self.vm.refresh()

    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 = NodeEditorVM(self.model, self.btree_view, self.btree_scene, self)

    def set_dirty(self):
        self.set_modified(True)

    def set_modified(self, b):
        self.modified = b
        self.sub_window.setWindowModified(b)

    def update_title(self):
        self.sub_window.setWindowTitle(self.file_path + "[*]")

    def close_handler(self, ev):

        if self.modified:
            ret = QMessageBox().question(
                self.btree_view, "Confirm",
                "close without saving?",
                QMessageBox.Yes | QMessageBox.No)
            if ret == QMessageBox.No:
                ev.ignore()
                return
        self.parent.remove_instance(self)

    def activation_handler(self):
        #print("%s about to be activated" % self)
        pass

    def deactivation_handler(self):
        #print("%s about to be deactivated" % self)
        self.vm.cancel_selection()

    def focus_on(self, node_id):
        self.parent.mdi.setActiveSubWindow(self.sub_window)
        node = self.model.get_node(node_id)
        if node is None:
            return False
        self.vm.selected_node = node
        self.vm.refresh()
        return True

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
    import sys

    app = QApplication(sys.argv)

    scene = QGraphicsScene()
    scene.setStickyFocus(True)

    for y in range(10):
        for x in range(10):
            proxy = CustomProxy(None, Qt.Window)
            proxy.setWidget(EmbeddedDialog())

            rect = proxy.boundingRect()

            proxy.setPos( x * rect.width()*1.05, y*rect.height()*1.05 )
            proxy.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
            scene.addItem(proxy)

    scene.setSceneRect(scene.itemsBoundingRect())

    view = QGraphicsView(scene)
    view.scale(0.5, 0.5)
    view.setRenderHints(view.renderHints() | QPainter.Antialiasing  | QPainter.SmoothPixmapTransform)
    view.setBackgroundBrush(QBrush(QPixmap(':/No-Ones-Laughing-3.jpg')))
    view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
    view.show()
    view.setWindowTitle("Embedded Dialogs Demo")

    sys.exit(app.exec_())

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import setSceneRect [as 别名]
class BoardGUI(QWidget):
    """cointain the graphical representation of the Board"""

    # ratio of bordersize compared to the size of one base square
    borderRatio = 0.8
    baseRectRatio = 14/15  # 12/13 for normal ratio but looks weird
    stoneScale = 0.46

    # siganl
    stoneClicked = pyqtSignal(tuple)

    def __init__(self, parent, game):
        super().__init__()

        self.initUI(game)

    def initUI(self, game):
        self.board = game.currentBoard
        self.game = game

        self.showCoords = True
        self.scene = QGraphicsScene()

        # grid containing coordinates for the scene
        self.grid = []
        self.drawGrid()

        # initialize and set layout + view
        self.view = QGraphicsView(self.scene)
        self.view.setMouseTracking(True)
        self.view.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
        self.setMouseTracking(True)
        box = QHBoxLayout()
        box.addWidget(self.view)
        self.setLayout(box)

        # stones for all positions are created and listed in self.pos dict
        self.createPosition()
        self.makeCoords()  # has to be called after drawGrid!

    def resizeEvent(self, e):
        self.view.fitInView(self.view.scene().sceneRect(), Qt.KeepAspectRatio)

    def boardWidth(self):
        """returns the max width fitting into widget"""
        width = self.contentsRect().width()*0.95
        height = self.contentsRect().height()*0.95

        return min(width, height*self.baseRectRatio)

    def boardHeight(self):
        """returns the max width fitting into widget """
        return self.boardWidth()*(1/self.baseRectRatio)

    def makeGrid(self):
        """
        returns coords [[(x, y)]] for the Grid according
         to current window mesures
        """
        # set scenesize to window size
        self.scene.setSceneRect(0, 0, self.boardWidth(), self.boardHeight())
        denom = self.board.size + 2*self.borderRatio
        baseWidth = self.boardWidth() / denom
        baseHeight = self.boardHeight() / denom

        leftOffset = 0.5*baseWidth  # (self.contentsRect().width()-self.boardWidth())/2
        topOffset = 0  # (self.contentsRect().height()-self.boardHeight())/2

        partionWidth = [leftOffset+(self.borderRatio+x)*baseWidth
                        for x in range(self.board.size)]
        partionHeight = [topOffset+(self.borderRatio+x)*baseHeight
                         for x in range(self.board.size)]

        grid = [[(x, y) for x in partionWidth] for y in partionHeight]
        self.grid = grid
        self.baseWidth = baseWidth

    def drawGrid(self):
        """draws the background grid"""
        self.makeGrid()
        for line in self.grid:
            self.scene.addLine(*line[0], *line[-1])
        for (pointT, pointB) in zip(self.grid[0], self.grid[-1]):
            self.scene.addLine(*pointT, *pointB)
        self.drawHoshis()

    def makeCoords(self):
        """ draws Coordinates """
        xLabels = "ABCDEFGHIKLMNOPQRSTUVWXYZ"
        yLabels = list(range(1, 26))
        botGrid = []
        leftGrid = []
        # generate pixel coordinates grids
        for n in range(self.board.size):
            (xBot, yBot) = self.grid[self.board.size-1][n]
            yBot += self.baseWidth*0.4/self.baseRectRatio
            xBot -= self.baseWidth*0.1
            botGrid.append((xBot, yBot))
            (xLeft, yLeft) = self.grid[n][0]
            xLeft -= self.baseWidth*1.2
#.........这里部分代码省略.........