Python QGraphicsScene.removeItem方法代码示例

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

#.........这里部分代码省略.........
        -----
        This is a central function. It updates the cursor, then updates
        the traces, the scores, and the power spectrum. In other words, this
        function is responsible for keep track of the changes every time
        the start time of the window changes.
        """
        if new_position is not None:
            lg.debug('Updating position to {}'.format(new_position))
            self.parent.value('window_start', new_position)
            self.idx_current.setPos(new_position, 0)

            current_time = (self.start_time +
                            timedelta(seconds=new_position))
            msg = 'Current time: ' + current_time.strftime('%H:%M:%S')
            self.parent.statusBar().showMessage(msg)
        else:
            lg.debug('Updating position at {}'
                     ''.format(self.parent.value('window_start')))

        if self.parent.info.dataset is not None:
            self.parent.traces.read_data()
            if self.parent.traces.data is not None:
                self.parent.traces.display()
                self.parent.spectrum.display_window()

        if self.parent.notes.annot is not None:
            self.parent.notes.set_stage_index()

        self.display_current()

    def display_current(self):
        """Create a rectangle showing the current window."""
        if self.idx_current in self.scene.items():
            self.scene.removeItem(self.idx_current)

        item = QGraphicsRectItem(0,
                                 CURR['pos0'],
                                 self.parent.value('window_length'),
                                 CURR['pos1'])
        # it's necessary to create rect first, and then move it
        item.setPos(self.parent.value('window_start'), 0)
        item.setPen(QPen(Qt.lightGray))
        item.setBrush(QBrush(Qt.lightGray))
        item.setZValue(-10)
        self.scene.addItem(item)
        self.idx_current = item

    def display_markers(self):
        """Mark all the markers, from the dataset.

        This function should be called only when we load the dataset or when
        we change the settings.
        """
        for rect in self.idx_markers:
            self.scene.removeItem(rect)
        self.idx_markers = []

        markers = []
        if self.parent.info.markers is not None:
            if self.parent.value('marker_show'):
                markers = self.parent.info.markers

        for mrk in markers:
            rect = QGraphicsRectItem(mrk['start'],
                                     BARS['markers']['pos0'],
                                     mrk['end'] - mrk['start'],

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

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

        self.mainSceneRoot = QGraphicsWidget()
        self.scene.addItem(self.mainSceneRoot)

        self.companyLogo = ImageItem(QImage(':/images/trolltech-logo.png'),
                1000, 1000, None, True, 0.5)
        self.qtLogo = ImageItem(QImage(':/images/qtlogo_small.png'), 1000,
                1000, None, True, 0.5)
        self.companyLogo.setZValue(100)
        self.qtLogo.setZValue(100)
        self.pausedLabel = DemoTextItem("PAUSED", Colors.buttonFont(),
                Qt.white, -1, None)
        self.pausedLabel.setZValue(100)
        fm = QFontMetricsF(Colors.buttonFont())
        self.pausedLabel.setPos(Colors.stageWidth - fm.width("PAUSED"),
                590 - fm.height())
        self.pausedLabel.setRecursiveVisible(False)

    def checkAdapt(self):
        if self.doneAdapt or Colors.noTimerUpdate or self.demoStartTime.elapsed() < 2000:
            return

        self.doneAdapt = True
        self.forceFpsMedianCalculation()
        Colors.benchmarkFps = self.fpsMedian
        Colors.debug("- benchmark: %d FPS" % int(Colors.benchmarkFps))

        if Colors.noAdapt:
            return

        if self.fpsMedian < 30:
            ticker = MenuManager.instance().ticker
            if ticker and ticker.scene():
                self.scene.removeItem(ticker)
                Colors.noTimerUpdate = True
                self.switchTimerOnOff(False)

                if self.fpsLabel:
                    self.fpsLabel.setText("FPS: (%d)" % int(self.fpsMedian))

                Colors.debug("- benchmark adaption: removed ticker (fps < 30)")

            if self.fpsMedian < 20:
                Colors.noAnimations = True
                Colors.debug("- benchmark adaption: animations switched off (fps < 20)")

            Colors.adapted = True

    def drawBackgroundToPixmap(self):
        r = self.scene.sceneRect()
        self.background = QPixmap(qRound(r.width()), qRound(r.height()))
        self.background.fill(Qt.black)
        painter = QPainter(self.background)

        bg = QImage(':/images/demobg.png')
        painter.drawImage(0, 0, bg)

    def drawBackground(self, painter, rect):
        painter.drawPixmap(QPoint(0, 0), self.background)

    def toggleFullscreen(self):
        if self.isFullScreen():
            self.enableMask(True)
            self.showNormal()
            if MenuManager.instance().ticker:
                MenuManager.instance().ticker.pause(False)

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

#.........这里部分代码省略.........
                row += 1

                self.chan.append(chan_name)
                self.chan_scale.append(one_grp['scale'])
                self.chan_pos.append(chan_pos)

    def display_grid(self):
        """Display grid on x-axis and y-axis."""
        window_start = self.parent.value('window_start')
        window_length = self.parent.value('window_length')
        window_end = window_start + window_length

        if self.parent.value('grid_x'):
            x_tick = self.parent.value('grid_xtick')
            x_ticks = arange(window_start, window_end + x_tick, x_tick)
            for x in x_ticks:
                x_pos = [x, x]
                y_pos = [0,
                         self.parent.value('y_distance') * len(self.idx_label)]
                path = self.scene.addPath(Path(x_pos, y_pos))
                path.setPen(QPen(QColor(LINE_COLOR), LINE_WIDTH,
                                 Qt.DotLine))

        if self.parent.value('grid_y'):
            for one_label_item in self.idx_label:
                x_pos = [window_start, window_end]
                y_pos = [one_label_item.y(), one_label_item.y()]
                path = self.scene.addPath(Path(x_pos, y_pos))
                path.setPen(QPen(QColor(LINE_COLOR), LINE_WIDTH, Qt.DotLine))

    def display_markers(self):
        """Add markers on top of first plot."""
        for item in self.idx_markers:
            self.scene.removeItem(item)
        self.idx_markers = []

        window_start = self.parent.value('window_start')
        window_length = self.parent.value('window_length')
        window_end = window_start + window_length
        y_distance = self.parent.value('y_distance')

        markers = []
        if self.parent.info.markers is not None:
            if self.parent.value('marker_show'):
                markers = self.parent.info.markers

        for mrk in markers:
            if window_start <= mrk['end'] and window_end >= mrk['start']:

                mrk_start = max((mrk['start'], window_start))
                mrk_end = min((mrk['end'], window_end))
                color = QColor(self.parent.value('marker_color'))

                item = QGraphicsRectItem(mrk_start, 0,
                                         mrk_end - mrk_start,
                                         len(self.idx_label) * y_distance)
                item.setPen(color)
                item.setBrush(color)
                item.setZValue(-9)
                self.scene.addItem(item)

                item = TextItem_with_BG(color.darker(200))
                item.setText(mrk['name'])
                item.setPos(mrk['start'],
                            len(self.idx_label) *
                            self.parent.value('y_distance'))

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

#.........这里部分代码省略.........
        for player in player_list_set:
            player_data = self.players[player]
            if player in player_items_set and \
               self.map_points_player_items[player] in self._scene.items():
                # Update
                self.map_points_player_items[player_data.name].setRect(
                    player_data.x - circle_size / 2,
                    player_data.y - circle_size / 2,
                    circle_size,
                    circle_size
                )
            else:
                # Create New Point
                color = QColor().fromRgb(
                    player_data.r,
                    player_data.g,
                    player_data.b
                )
                circle = QGraphicsEllipseItem(
                    player_data.x - circle_size / 2,
                    player_data.y - circle_size / 2,
                    circle_size,
                    circle_size
                )
                circle.setBrush(color)
                self.map_points_player_items[player_data.name] = circle
                self._scene.addItem(
                    self.map_points_player_items[player_data.name]
                )

        # Find/remove players who aren't in players list from the map
        for key in [player for player in player_items_set
                    if player not in player_list_set]:
            self._scene.removeItem(self.map_points_player_items[key])

        # Center map
        self.center()

    def set_scale(self, ratio):
        # Scale scene
        self.setTransform(QTransform())
        self.scale_ratio = ratio
        self.scale(self.scale_ratio, self.scale_ratio)

        # Scale map lines
        map_line_width = self.settings.get_value('maps', 'map_line_width')
        for key in self.map_line_path_items.keys():
            pen = self.map_line_path_items[key].pen()
            pen.setWidth(
                max(
                    map_line_width,
                    map_line_width / self.scale_ratio
                )
            )
            self.map_line_path_items[key].setPen(pen)

        # Scale map grid
        grid_line_width = self.settings.get_value('maps', 'grid_line_width')
        pen = self.map_grid_path_item.pen()
        pen.setWidth(
            max(
                grid_line_width,
                grid_line_width / self.scale_ratio
            )
        )
        self.map_grid_path_item.setPen(pen)

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

#.........这里部分代码省略.........
            self.trackingPathGroup.setRadius(i)
        self.updateInputGraphicsView()

    def addRegionButtonClicked(self):
        if not self.videoPlaybackWidget.isOpened():
            return

        name_num = self.regionTableWidget.rowCount()

        for i, name in enumerate(map(lambda x: x.data(Qt.DisplayRole), self.getCol(0))):
            try:
                val = int(name)
            except:
                continue

            name_num = max(name_num, val+1)

        self.addRow(str(name_num), QColor('red'), FigureType.Recutangular)

    def removeRegionButtonClicked(self):
        if not self.videoPlaybackWidget.isOpened():
            return

        if not len(self.regionTableWidget.selectedItems()) > 0:
            return

        selected_row = self.regionTableWidget.row(self.regionTableWidget.selectedItems()[0])

        name_item = self.regionTableWidget.item(selected_row, 0)
        name = name_item.data(Qt.UserRole)

        item = self.graphics_items.pop(name)
        if item is not None:
            self.inputScene.removeItem(item)

        self.regionTableWidget.removeRow(selected_row)

    def upRegionButtonClicked(self):
        if not self.videoPlaybackWidget.isOpened():
            return

        self.moveRow(True)

    def downRegionButtonClicked(self):
        if not self.videoPlaybackWidget.isOpened():
            return

        self.moveRow(False)

    def addRow(self, name, color, figType):
        i = self.regionTableWidget.rowCount()
        self.regionTableWidget.insertRow(i)

        nameItem = QTableWidgetItem(name)
        nameItem.setData(Qt.UserRole, name)
        nameItem.setFlags(Qt.ItemIsEditable | Qt.ItemIsSelectable | Qt.ItemIsEnabled)

        colorItem = QTableWidgetItem()
        colorItem.setData(Qt.BackgroundRole, color)
        colorItem.setData(Qt.DisplayRole, color)

        figItem = QTableWidgetItem()
        figItem.setData(Qt.DisplayRole, figType.name)

        self.regionTableWidget.setItem(i, 0, nameItem)
        self.regionTableWidget.setItem(i, 1, colorItem)

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

    new_pixmap = pyqtSignal(QtGui.QPixmap)
    new_pixel_under_mouse = pyqtSignal(bool, int, int, QtGui.QColor)
    destroy_widget = pyqtSignal()
    fit_in_view = pyqtSignal()

    def __init__(self, parent=None):
        super(TcamScreen, self).__init__(parent)
        self.setMouseTracking(True)
        self.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
                           QtWidgets.QSizePolicy.Expanding)
        self.setDragMode(QGraphicsView.ScrollHandDrag)
        self.setFrameStyle(0)
        self.scene = QGraphicsScene(self)
        self.setScene(self.scene)

        self.new_pixmap.connect(self.on_new_pixmap)
        self.fit_in_view.connect(self.fit_view)
        self.pix = ViewItem()
        self.scene.addItem(self.pix)
        self.scene.setSceneRect(self.pix.boundingRect())

        self.is_fullscreen = False

        # Flag to differentiate between actual images
        # and 'fake images' i.e. color background + text while
        # waiting for first trigger image
        self.display_real_image = True
        self.text_item = None

        self.fit_in_view_called = False

        self.mouse_position_x = -1
        self.mouse_position_y = -1

        self.zoom_factor = 1.0
        self.first_image = True
        self.image_counter = 0

        self.capture_roi = False
        self.roi_obj = None
        self.roi_origin = None
        self.roi_widgets = []

        self.selection_area = None
        self.capture_widget = None
        self.origin = None

    def fit_view(self):
        """

        """

        self.reset_zoom()
        self.scene.setSceneRect(self.pix.boundingRect())
        self.scene.update()
        self.fitInView(self.scene.sceneRect(), Qt.KeepAspectRatio)

    def reset_zoom(self):

        self.zoom_factor = 1.0
        # this resets the view internal transformation matrix
        self.setTransform(QtGui.QTransform())

    def on_new_pixmap(self, pixmap):
        self.image_counter += 1
        self.pix.setPixmap(pixmap)

        if not self.display_real_image:
            self.text_item.hide()
            self.scene.removeItem(self.text_item)
            self.display_real_image = True

        if self.image_counter == 1:
            self.resize(self.size())
            self.scene.setSceneRect(self.pix.boundingRect())
            self.update()

            self.reset_zoom()
            self.first_image = False

        # wait for the second image
        # resizeEvents, etc appear before the scene has adjusted
        # to the actual image size. By waiting for the 2. image
        # we circumvent this by having the first image making all
        # adjustments for us. The only scenario where this will
        # cause problems is triggering.
        if self.is_fullscreen and self.image_counter == 2:
            self.fit_view()

        self.send_mouse_pixel()
        # don't call repaint here
        # it causes problems once the screen goes blank due to screensavers, etc
        # self.repaint()

    def wait_for_first_image(self):

        if not self.display_real_image:
            return
#.........这里部分代码省略.........

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

#.........这里部分代码省略.........
                if self.initializeEventDialog():
                    global filterOperation
                    filterOperation = None
                    self.removeTrackingGraphicsItems()
                    self.savedFlag = True
                else:
                    return
            self.filePath = filePath
            ret = self.videoPlaybackWidget.openVideo(filePath)
            if not ret:
                return False

            self.videoPlaybackWidget.show()

            self.cv_img = self.videoPlaybackWidget.getCurrentFrame()
            self.currentFrameNo = 0
            self.videoPlaybackWidget.setMaxTickableFrameNo(0)
            self.initializeTrackingSystem()

            return True
        else:
            return False

    def openFilterFile(self, activated=False, filePath = None):
        if filePath is None:
            filePath, _ = QFileDialog.getOpenFileName(None, 'Open Block File', userDir, "Block files (*.filter)")

        if len(filePath) is not 0:
            if filterOperation is not None and self.videoPlaybackWidget.isOpened():
                if self.initializeEventDialog():
                    self.videoPlaybackWidget.closeVideo()
                    self.videoPlaybackWidget.hide()
                    self.removeTrackingGraphicsItems()
                    self.inputScene.removeItem(self.inputPixmapItem)
                    self.savedFlag = True
                else:
                    return
            logger.debug("Open Filter file: {0}".format(filePath))

            self.filterIO = FilterIO(filePath)

            exec(self.filterIO.getFilterCode(), globals())

            self.filter = None

            self.initializeTrackingSystem()
            self.evaluate()

    def saveCSVFile(self, activated=False, filePath = None):
        if len(self.df.keys())!=0:
            dirctory = os.path.dirname(self.filePath)
            base_name = os.path.splitext(os.path.basename(self.filePath))[0]

            path = os.path.join(dirctory, '{0}-{1}.txt'.format(base_name, "info"))
            filePath, _ = QFileDialog.getSaveFileName(None, 'Save Info File', path, "TXT files (*.txt)")

            if len(filePath) is not 0:
                logger.debug("Saving Info file: {0}".format(filePath))

                with open(filePath, 'w') as fp:
                    fp.write(self.videoPlaybackWidget.getVideoInfo())

            for attr, df in self.df.items():
                path = os.path.join(dirctory, '{0}-{1}.csv'.format(base_name, attr))
                filePath, _ = QFileDialog.getSaveFileName(None, 'Save CSV File', path, "CSV files (*.csv)")

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import removeItem [as 别名]
class GraphicsGraphView(View, QGraphicsView):
    '''The GraphicsGraphView defines a graphical representation of a Graph.


    Attribute(s):
    nodes (Dictionary[GraphicNode]): All nodes (views)
    edges (Dictionary[GraphicEdge]): All edges (views)
    scene (QGraphicsScene): Scene to show items (nodes and edges)
    nodeHasBeenMoved (bool): Flag to check if a node has been moved
    factor (int): Used when enlarging/shrinking scene
    '''

    factor = 2

    def __init__(self):
        # Parent constructor(s)
        View.__init__(self)
        QGraphicsView.__init__(self)

        self.nodes = {}
        self.edges = {}
        self.nodeHasBeenMoved = False

        # Enable Antiliasing
        self.setRenderHint(QPainter.Antialiasing)

        # Rectangular selection
        self.setDragMode(QGraphicsView.RubberBandDrag)
        self.setRubberBandSelectionMode(Qt.IntersectsItemShape)

        # Init scene
        self.scene = QGraphicsScene()
        self.setScene(self.scene)
        self.resetSceneRect()
        self.scene.installEventFilter(self)
        self.show()

    def addNode(self, dictArgsNode):
        '''Add a node.

        Argument(s):
        dictArgsNode (Dictionary[]): Dictionary of arguments of the node
        '''
        # Create the node
        self.nodes[dictArgsNode[NodeArgs.id]] = GraphicsEllipseNode(
            dictArgsNode[NodeArgs.id],
            self)
        # Edit it
        self.editNode(dictArgsNode)

        # Add it to the scene
        self.scene.addItem(self.nodes[dictArgsNode[NodeArgs.id]])

    def editNode(self, dictArgsNode):
        '''Edit a node.

        Argument(s):
        dictArgsNode (Dictionary[]): Dictionary of arguments of the node
        '''
        self.nodes[dictArgsNode[NodeArgs.id]].edit(dictArgsNode)

    def removeNode(self, dictArgsNode):
        '''Remove a node.

        Argument(s):
        dictArgsNode (Dictionary[]): Dictionary of arguments of the node
        '''
        # Remove the node from the scene
        self.scene.removeItem(self.nodes[dictArgsNode[NodeArgs.id]])
        self.shrinkSceneRect(self.nodes[dictArgsNode[NodeArgs.id]])
        self.nodes.pop(dictArgsNode[NodeArgs.id])

        # Reset scene rect
        if not self.scene.items():
            self.resetSceneRect()

    def addEdge(self, dictArgsEdge):
        '''Add an edge.

        Argument(s):
        dictArgsEdge (Dictionary[]): Dictionary of arguments of the edge
        '''
        # Init source and dest nodes
        source = self.nodes[dictArgsEdge[EdgeArgs.sourceId]]
        dest = self.nodes[dictArgsEdge[EdgeArgs.destId]]

        # Create the edge
        self.edges[dictArgsEdge[EdgeArgs.id]] = GraphicsLineEdge(
            source,
            dest,
            dictArgsEdge[EdgeArgs.id],
            self
        )

        # Edit it
        self.editEdge(dictArgsEdge)

        # Add edge to the scene
        self.scene.addItem(self.edges[dictArgsEdge[EdgeArgs.id]])

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

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

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

        if len(filePath) is not 0:
            self.filePath = filePath
            img = cv2.imread(filePath)
            if img is None:
                return False

            self.cv_img = img
            self.videoPlaybackWidget.hide()
            self.updateInputGraphicsView()

            self.evaluate()

            return True
        else:
            return False

    def openCSVFile(self, activated=False, filePath=None):
        if filePath is None:
            filePath, _ = QFileDialog.getOpenFileName(None, 'Open CSV File', userDir, 'CSV files (*.csv)')

        if len(filePath) is not 0:
            df = pd.read_csv(filePath, index_col=0)
            name = df.index.name

            if name is None:
                name = 'position'

            self.df[name] = df
            self.file_name_dict[name] = filePath

            if name is None or name=='position':
                if self.trackingPathGroup is not None:
                    self.inputScene.removeItem(self.trackingPathGroup)

                self.trackingPathGroup = TrackingPathGroup()
                self.trackingPathGroup.setRect(self.inputScene.sceneRect())
                self.inputScene.addItem(self.trackingPathGroup)

                if not self.actionPath.isChecked():
                    self.trackingPathGroup.setDrawLine(False)
                if not self.actionCircle.isChecked():
                    self.trackingPathGroup.setDrawItem(False)
                if not self.actionIntervalMark.isChecked():
                    self.trackingPathGroup.setDrawMarkItem(False)

                self.trackingPathGroup.setDataFrame(self.df['position'])
            elif name=='arrow':
                if self.movableArrowGroup is not None:
                    self.inputScene.removeItem(self.movableArrowGroup)

                self.movableArrowGroup = MovableArrowGroup()
                self.inputScene.addItem(self.movableArrowGroup)
                self.movableArrowGroup.edited.connect(self.arrowEdited)

                if not self.actionArrow.isChecked():
                    self.movableArrowGroup.hide()

            if 'arrow' in self.df.keys() and 'position' in self.df.keys():
                self.movableArrowGroup.setDataFrame(self.df['arrow'], self.df['position'])

            self.initialize()

    def openColorFile(self, activated=False, filePath=None):
        if filePath is None:
            filePath, _ = QFileDialog.getOpenFileName(None, 'Open Color File', userDir, 'Color files (*.color)')

# 需要导入模块: from PyQt5.QtWidgets import QGraphicsScene [as 别名]
# 或者: from PyQt5.QtWidgets.QGraphicsScene import removeItem [as 别名]
class ImageViewerQt(QGraphicsView):
    """ PyQt image viewer widget for a QPixmap in a QGraphicsView scene with mouse zooming and panning.

    Displays a QImage or QPixmap (QImage is internally converted to a QPixmap).
    To display any other image format, you must first convert it to a QImage or QPixmap.

    Some useful image format conversion utilities:
        qimage2ndarray: NumPy ndarray <==> QImage    (https://github.com/hmeine/qimage2ndarray)
        ImageQt: PIL Image <==> QImage  (https://github.com/python-pillow/Pillow/blob/master/PIL/ImageQt.py)

    Mouse interaction:
        Left mouse button drag: Pan image.
        Right mouse button drag: Zoom box.
        Right mouse button doubleclick: Zoom to show entire image.
    """

    # Mouse button signals emit image scene (x, y) coordinates.
    # !!! For image (row, column) matrix indexing, row = y and column = x.
    leftMouseButtonPressed = pyqtSignal(float, float)
    rightMouseButtonPressed = pyqtSignal(float, float)
    leftMouseButtonReleased = pyqtSignal(float, float)
    rightMouseButtonReleased = pyqtSignal(float, float)
    leftMouseButtonDoubleClicked = pyqtSignal(float, float)
    rightMouseButtonDoubleClicked = pyqtSignal(float, float)

    def __init__(self):
        QGraphicsView.__init__(self)

        # Image is displayed as a QPixmap in a QGraphicsScene attached to this QGraphicsView.
        self.scene = QGraphicsScene()
        self.setScene(self.scene)

        # Store a local handle to the scene's current image pixmap.
        self._pixmapHandle = None

        # Image aspect ratio mode.
        # !!! ONLY applies to full image. Aspect ratio is always ignored when zooming.
        #   Qt.IgnoreAspectRatio: Scale image to fit viewport.
        #   Qt.KeepAspectRatio: Scale image to fit inside viewport, preserving aspect ratio.
        #   Qt.KeepAspectRatioByExpanding: Scale image to fill the viewport, preserving aspect ratio.
        self.aspectRatioMode = Qt.KeepAspectRatio

        # Scroll bar behaviour.
        #   Qt.ScrollBarAlwaysOff: Never shows a scroll bar.
        #   Qt.ScrollBarAlwaysOn: Always shows a scroll bar.
        #   Qt.ScrollBarAsNeeded: Shows a scroll bar only when zoomed.
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)

        # Stack of QRectF zoom boxes in scene coordinates.
        self.zoomStack = []

        # Flags for enabling/disabling mouse interaction.
        self.canZoom = True
        self.canPan = True

    def hasImage(self):
        """ Returns whether or not the scene contains an image pixmap.
        """
        return self._pixmapHandle is not None

    def clearImage(self):
        """ Removes the current image pixmap from the scene if it exists.
        """
        if self.hasImage():
            self.scene.removeItem(self._pixmapHandle)
            self._pixmapHandle = None

    def pixmap(self):
        """ Returns the scene's current image pixmap as a QPixmap, or else None if no image exists.
        :rtype: QPixmap | None
        """
        if self.hasImage():
            return self._pixmapHandle.pixmap()
        return None

    def image(self):
        """ Returns the scene's current image pixmap as a QImage, or else None if no image exists.
        :rtype: QImage | None
        """
        if self.hasImage():
            return self._pixmapHandle.pixmap().toImage()
        return None

    def setImage(self, image):
        """ Set the scene's current image pixmap to the input QImage or QPixmap.
        Raises a RuntimeError if the input image has type other than QImage or QPixmap.
        :type image: QImage | QPixmap
        """
        if type(image) is QPixmap:
            pixmap = image
        elif type(image) is QImage:
            pixmap = QPixmap.fromImage(image)
        else:
            raise RuntimeError("ImageViewer.setImage: Argument must be a QImage or QPixmap.")
        if self.hasImage():
            self._pixmapHandle.setPixmap(pixmap)
        else:
            self._pixmapHandle = self.scene.addPixmap(pixmap)
        self.setSceneRect(QRectF(pixmap.rect()))  # Set scene size to image size.
#.........这里部分代码省略.........

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

#.........这里部分代码省略.........
        try:
            # Open the file create the stream and activate the save method of the
            # main item
            fh = QFile(self.filename)
            if not fh.open(QIODevice.WriteOnly):
                raise IOError(fh.errorString())
            stream = QDataStream(fh)
            self.mainItem.save(stream, self.filename)

        except IOError as e:
            QMessageBox.warning(self, "Character Identifier -- Save Error", "Failed to save {}: {}".format(
                self.filename, e))
        finally:
            if fh is not None:
                fh.close()

    def pushButton_load_clicked(self, filename: str=None):
        """ Slot : Activate the load from file operation
        """

        # If the character was not loaded from a file and no save was done
        if not self.filename:
            self.save()
            path = QFileInfo(self.filename).path() if self.filename else os.path.join(
                dataDir, "Chapter 3 - Distance Metrics")
            fname = QFileDialog.getOpenFileName(self, "Character Identifier - Open", path,
                                                "Character Identifier Files (*.chr)")
            if not fname:
                return
            self.filename = fname[0]
            fh = None
        else:
            self.filename = filename

        try:
            fh = QFile(self.filename)

            if not fh.open(QIODevice.ReadOnly):
                raise IOError(fh.errorString())
            items = self.graphicsScene.items()
            while items:
                item = items.pop()
                self.graphicsScene.removeItem(item)
                del item

            stream = QDataStream(fh)
            self.mainItem = CharItem(self.itemBoundaries, self.itemPos)
            self.graphicsScene.addItem(self.mainItem)
            self.mainItem.load(stream, self.filename)
            self.dirty = False
        except IOError as e:
            QMessageBox.warning(self, "Page Designer -- Open Error", "Failed to open {}: {}".format(self.filename, e))
        finally:
            if fh is not None:
                fh.close()

    def accept(self):
        """ Slot : OK exit
        """
        # If the item was not set - set it
        if not self.mainItem.wasSetted:
            self.mainItem.set()

        # Save the item
        self.save()
        return super(CharIdentifierInput, self).accept()

    def save(self):
        """ save operation

            This method is activated before all the operations that cause
            The item to be removed from the screen
        """
        # If the item was changed - ask for saving
        if self.mainItem.dirty:
            if QMessageBox.question(None, "Char Identifier Input", "Do You want to save changes ?",
                                    QMessageBox.StandardButtons(QMessageBox.Yes
                                                                | QMessageBox.No)) == QMessageBox.Yes:
                self.pushButton_save_clicked()

    def reject(self):
        """ Slot : reject operation

            exit the dialog with true
        """
        self.save()
        return super(CharIdentifierInput, self).accept()

    def pushButton_reset_clicked(self):
        """ Slot : clear the presentation
        """
        self.save()
        self.graphicsScene.clear()
        self.graphicsView.viewport().update()
        self.newItem()

    def pushButton_revertSet_clicked(self):
        """ Slot : revert the setting for continue drowning
        """
        self.mainItem.revertTransform()

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

#.........这里部分代码省略.........
            ret = self.videoPlaybackWidget.openVideo(filePath)
            if ret == False:
                return False

            self.videoPlaybackWidget.show()
            self.filterClassHash = None

            return True

    def openImageFile(self, activated=False, filePath = None):
        if filePath == None:
            filePath, _ = QFileDialog.getOpenFileName(None, 'Open Image File', userDir)

        if len(filePath) is not 0:
            self.filePath = filePath
            img = cv2.imread(filePath)
            if img is None:
                return False

            self.cv_img = img
            self.fgbg = None

            self.videoPlaybackWidget.hide()
            self.updateInputGraphicsView()

            # Initialize Filter when opening new file.
            self.filterClassHash = None

            return True
        else:
            return False

    def updateInputGraphicsView(self):
        self.inputScene.removeItem(self.inputPixmapItem)
        qimg = misc.cvMatToQImage(self.cv_img)
        self.inputPixmap = QPixmap.fromImage(qimg)

        rect = QtCore.QRectF(self.inputPixmap.rect())
        self.inputScene.setSceneRect(rect)

        self.inputPixmapItem = QGraphicsPixmapItem(self.inputPixmap)
        self.inputScene.addItem(self.inputPixmapItem)

        self.inputGraphicsView.viewport().update()
        self.inputGraphicsViewResized()

    def getPixmapItemClickedPos(self, event):
        pos = event.scenePos().toPoint()
        print(pos)

    def inputPixmapItemClicked(self, event):
        pos = event.scenePos().toPoint()

        img = self.inputPixmap.toImage()
        pix = img.pixel(pos)
        rgb = QColor(pix).name()
        logger.debug("Selected pixel color: {0}".format(rgb))

        parameters = {
                'Color': rgb,
                }
        string = json.dumps(parameters)
        webFrame = self.blocklyWebView.page().mainFrame()
        webFrame.evaluateJavaScript("Apps.setValueToSelectedBlock({0});".format(string))

    def openFilterFile(self, activated=False, filePath = None):

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

#.........这里部分代码省略.........
            # self.evaluate()

            return True
        else:
            return False

    def openImageFile(self, activated=False, filePath = None):
        if filePath == None:
            filePath, _ = QFileDialog.getOpenFileName(None, 'Open Image File', userDir)

        if len(filePath) is not 0:
            self.filePath = filePath
            img = cv2.imread(filePath)
            if img is None:
                return False

            self.cv_img = img
            self.videoPlaybackWidget.hide()
            self.updateInputGraphicsView()

            self.evaluate()

            return True
        else:
            return False

    def openCSVFile(self, activated=False, filePath=None):
        if filePath is None:
            filePath, _ = QFileDialog.getOpenFileName(None, 'Open CSV File', userDir, 'CSV files (*.csv)')

        if len(filePath) is not 0:
            self.df = pd.read_csv(filePath, index_col=0)
            if self.handInputSystem is not None:
                self.inputScene.removeItem(self.handInputSystem)
            self.handInputSystem = HandInputSystem()
            self.handInputSystem.setRect(self.inputScene.sceneRect())
            self.inputScene.addItem(self.handInputSystem)
            self.handInputSystem.setDataFrame(self.df)
            self.handInputSystem.setPoints()

            self.dataFrameWidget.clear()
            self.dataFrameWidget.dataFrameNo = self.handInputSystem.dataFrameNo
            self.dataFrameWidget.editingNo = 0
            for item in range(self.handInputSystem.dataFrameNo+1):
                color = self.handInputSystem.itemList[item].getColor()
                print(item,color)
                self.dataFrameWidget.colorList.append(color)
            self.dataFrameWidget.setUniqueIDLabel()

            self.evaluate()

    def saveCSVFile(self, activated=False, filePath = None):
        #if self.df is not None:
        if self.handInputSystem.isDataFrame():
            filePath, _ = QFileDialog.getSaveFileName(None, 'Save CSV File', userDir, "CSV files (*.csv)")

            if len(filePath) is not 0:
                logger.debug("Saving CSV file: {0}".format(filePath))
                self.handInputSystem.saveCSV(filePath)

    def updateInputGraphicsView(self):
        # print("update")
        # self.inputScene.clear()
        self.inputScene.removeItem(self.inputPixmapItem)
        qimg = misc.cvMatToQImage(self.cv_img)
        self.inputPixmap = QPixmap.fromImage(qimg)

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

#.........这里部分代码省略.........
    def updateGun(self, address, strGun):
        """ Take inputs from user and if the fire button has been pressed fire a projectile

        :param address: The client that sent the update gun request
        :param strGun: Contains information about what direction the gun is facing and if fire button has been pressed
        :return: True if address was a gunner
        """
        for blob in self.listBlobs:
            if blob.gunner == address: # if address passed in is a gunner carry out gunner stuff
                blob.gun.fireTally = self.getFireTally(strGun)
                blob.gun.desiredAngle = self.getAngle(strGun)

    """ Update game graphics with respect to the current game state """
    def updateGame(self, addressDict, input, currTime):
        try:
            print(currTime)
            diff = 120 - currTime
            print("diff: ", diff)
            timeString = "Time: {}".format(diff)
            print(timeString)
            self.timeTxt.setText(timeString)
            for key in addressDict.keys():
                address = addressDict[key]
            isDriver = self.updatePos(address, input)
            if not isDriver:
                isGunner = self.updateGun(address, input)
            for blob in self.listBlobs:
                self.manageProjectiles(blob)

            self.drawGame()
        except ValueError:
            print("address was not assigned a value before being used")

    def manageBlob(self, blob):
        """ Check if a blob has collided with an item, if a blob has collided with an item carry out the correct
        response.
            # Wall - Blob is not allowed to pass into a wall

        :param blob:
        :return:
        """
        isCollision = False
        collidedItems = blob.collidingItems()

        for item in collidedItems:
            if item is self.angWall or item is self.cirWall:
                isCollision = True
        print(isCollision)
        return isCollision

    def manageProjectiles(self, blob):
        """ Manage projectiles - send the call to update position on screen, remove from active projectiles if
        necessary, check for collisions with other Blobs
        :return:
        """
        # add particles to seen if they are not in the scene already
        for p in blob.gun.projectiles:
            if not p in self.scene.items():
                self.scene.addItem(p)

        # check for collision with other blobs
        # for b in self.listBlobs:
        #     if b != blob:
        collidedItems = []
        for p in blob.gun.projectiles:
            # for each projectile check if p collides with blob b
            collidedItems = p.collidingItems()
            for item in collidedItems:
                if item is self.angWall or item is self.cirWall:
                    # item is a wall remove particle
                    blob.gun.pToRemove.add(p)
                elif item in self.listBlobs and item != blob:
                    # item is a blob and is not the current blob the particles belong to
                    blob.hits += 1
                    blob.gun.pToRemove.add(p)


        tempList = []
        """ Put items that are still in the group and are marked to be removed into a temporary list to allow for their
        removal without causing an error within the for loop
        """
        for item in self.scene.items():
            if item in blob.gun.pToRemove:
                tempList.append(item)  # items in tempList are Projectiles that are marked to be removed

        for p in tempList:
            blob.gun.projectiles.remove(p)  # remove from active projectile set
            self.scene.removeItem(p)  # Remove the item from the group
            blob.gun.pToRemove.remove(p)  # Remove the projectile from the set signifying it should be removed

        print("SCORE: ", blob.hits)

    """ Draw all graphics in the game """
    def drawGame(self):
        for blob in self.listBlobs:
            blob.onDraw([self.width(), self.height()], self.angWall, self.cirWall)
            # self.manageProjectiles(blob)

    def gameLoop(self):
        """

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

    '''
    Minimap
    '''

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

        super(Minimap, self).__init__(parent)

        self._scene = QGraphicsScene()
        self.setAutoFillBackground(True)
        self.setViewport(QGLWidget())
        self.setScene(self._scene)
        self.setAlignment(Qt.AlignTop)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        self.nav_cursor = Cursor()
        self.nav_cursor.graphics_view = self
        self._scene.addItem(self.nav_cursor)
        self._graphic_item_list = []
        self._pixmap = None
        self._text_edit = None
        self._abstract_doc_layout = None
        self._is_cursor_moved = False

        self._img_generator = ImageGenerator()
        self._img_generator.image_generated.connect(self._update_with)
        # self.setBackgroundRole(QPalette.Dark)

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

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

    @pyqtSlot()
    def update(self):
        if self._is_cursor_moved:
            pass
        self._generate_image(self.text_edit)

    def _change_scrollbar_value(self, value):
        self._scrollbar.setValue(value)

    def resizeEvent(self, event):

        # self._image_label.setFixedHeight(self.height())
        # self._image_label.setFixedWidth(self.width())
        return QGraphicsView.resizeEvent(self, event)

#--------------------------------------------------------------------------
    def _generate_image(self, text_edit):

        doc = text_edit.document()

        item_list = []
        for i in range(0, doc.blockCount()):
            block = doc.findBlockByNumber(i)
            item = DocItem()
            item.block_text = block.text()
            item.text_format = block.blockFormat()
            item.width = text_edit.viewport().width()
            layout = block.layout()
            item.lines = []
            if layout:
                for i in range(0, layout.lineCount()):
                    item.lines.append(layout.lineAt(i))

            item_list.append(item)
        self._img_generator.set_items(item_list)
        self._img_generator.start()

    @pyqtSlot('QPixmap')
    def _update_with(self, pixmap):
        for g_item in self._graphic_item_list:
            if g_item.name == "map":
                self._scene.removeItem(g_item)
                self._graphic_item_list.remove(g_item)
                del g_item

        item = self._scene.addPixmap(pixmap)
        item.name = "map"
        item.setPos(0, 0)
        self._pixmap = pixmap
        self._graphic_item_list.append(item)

        self.setFixedWidth(pixmap.width())

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