pythonOCC例子搬运：5.显示画面上叠加信息与动画

淩亂°似流年 2022-03-30 13:38 218阅读 0赞

这里返回总目录>>[**返回总目录**][Link 1]  
core\_visualization\_overpaint\_viewer.py  
本例从https://github.com/tpaviot/pythonocc-demos搬运而来  
运行版本：**0.18.2**  
在其余版本运行不保证正确  
**先上结果图**

![在这里插入图片描述][20190106123715358.gif]  
**代码部分**

from __future__ import print_function
    
    import random
    import sys
    
    from OCC.Display.backend import load_any_qt_backend, get_qt_modules
    
    load_any_qt_backend()
    
    QtCore, QtGui, QtWidgets, QtOpenGL = get_qt_modules()
    from OCC.Display.qtDisplay import qtViewer3d
    
    # --------------------------------------------------------------------------
    # these are names of actions that invoke the OpenGL viewport to be redrawn
    # such actions need to be invoked through the GLWidget.update method, which
    # in turn invoked the GLWidget.paintEvent method
    # this way, all command that redraw the viewport are invoked synchronously
    # --------------------------------------------------------------------------
    
    
    ON_ZOOM = "on_zoom"
    ON_ZOOM_AREA = "on_zoom_area"
    ON_ZOOM_FACTOR = "on_zoom_factor"
    ON_ZOOM_FITALL = "on_zoom_fitall"
    ON_DYN_ZOOM = "on_dyn_zoom"
    ON_DYN_ROT = "on_dyn_rot"
    ON_DYN_PAN = "on_dyn_pan"
    ON_MOVE_TO = "on_move_to"
    ON_SHIFT_SELECT = "on_shift_select"
    ON_SELECT = "on_select"
    ON_SELECT_AREA = "on_select_area"
    
    
    class Bubble(object):
        def __init__(self, position, radius, velocity):
            self.position = position
            self.vel = velocity
            self.radius = radius
    
            self.innerColor = self.randomColor()
            self.outerColor = self.randomColor()
            self.updateBrush()
    
        def updateBrush(self):
            gradient = QtGui.QRadialGradient(
                    QtCore.QPointF(self.radius, self.radius),
                    self.radius,
                    QtCore.QPointF(self.radius * 0.5, self.radius * 0.5))
            gradient.setColorAt(0, QtGui.QColor(255, 255, 255, 0))
            gradient.setColorAt(0.25, self.innerColor)
            gradient.setColorAt(1, self.outerColor)
            self.brush = QtGui.QBrush(gradient)
    
        def drawBubble(self, painter, mouse_intersects):
            painter.save()
            painter.translate(self.position.x() - self.radius,
                              self.position.y() - self.radius)
            painter.setBrush(self.brush)
    
            if mouse_intersects:
                font = painter.font()
                font.setPointSize(20)
                painter.setFont(font)
                painter.setPen(QtCore.Qt.red)
                painter.drawText(0, 0, "so hovering over!!!")
    
            painter.drawEllipse(0, 0, int(2 * self.radius), int(2 * self.radius))
            painter.restore()
    
        def randomColor(self):
            red = random.randrange(205, 256)
            green = random.randrange(205, 256)
            blue = random.randrange(205, 256)
            alpha = random.randrange(91, 192)
            return QtGui.QColor(red, green, blue, alpha)
    
        def move(self, bbox):
            self.position += self.vel
            leftOverflow = self.position.x() - self.radius - bbox.left()
            rightOverflow = self.position.x() + self.radius - bbox.right()
            topOverflow = self.position.y() - self.radius - bbox.top()
            bottomOverflow = self.position.y() + self.radius - bbox.bottom()
    
            if leftOverflow < 0.0:
                self.position.setX(self.position.x() - 2 * leftOverflow)
                self.vel.setX(-self.vel.x())
            elif rightOverflow > 0.0:
                self.position.setX(self.position.x() - 2 * rightOverflow)
                self.vel.setX(-self.vel.x())
    
            if topOverflow < 0.0:
                self.position.setY(self.position.y() - 2 * topOverflow)
                self.vel.setY(-self.vel.y())
            elif bottomOverflow > 0.0:
                self.position.setY(self.position.y() - 2 * bottomOverflow)
                self.vel.setY(-self.vel.y())
    
        def rect(self):
            return QtCore.QRectF(self.position.x() - self.radius,
                                 self.position.y() - self.radius, 2 * self.radius,
                                 2 * self.radius)
    
    
    class GLWidget(qtViewer3d):
        def __init__(self, parent=None):
            super(GLWidget, self).__init__(parent)
    
            #: state
            self._initialized = False
    
            # no effect?
            self.doubleBuffer()
    
            # ---------------------------------------------------------------------
            # parameters for bubbles
            # ---------------------------------------------------------------------
    
            midnight = QtCore.QTime(0, 0, 0)
            random.seed(midnight.secsTo(QtCore.QTime.currentTime()))
            self.bubbles = []
    
            # parameter for overpainted text box
    
            self.text = """
            Example overpainting the OpenGL viewport, inspired by a similar example from Qt
            """
    
            # ---------------------------------------------------------------------
            # create properties for the last coordinate, such that the stupid
            # "point" conversion takes place implicitly
            # ---------------------------------------------------------------------
    
            self.lastPos = QtCore.QPoint()
    
            # ---------------------------------------------------------------------
            # GUI parameters
            # ---------------------------------------------------------------------
    
            self.setMinimumSize(200, 200)
            self.setWindowTitle("Overpainting a Scene")
    
            # parameters for overpainting
            self.setAttribute(QtCore.Qt.WA_NoSystemBackground)
            self.setAutoFillBackground(False)
    
            # ---------------------------------------------------------------------
            # setup
            # ---------------------------------------------------------------------
    
            # start the background thread that performs the overpainting of
            # the OpenGL view with bubbles
            self._setupAnimation()
    
            # ---------------------------------------------------------------------
            # GUI State
            # ---------------------------------------------------------------------
    
            # QPoint stored on mouse press
            self._point_on_mouse_press = QtCore.QPoint()
    
            # QPoint stored on mouse move
            self._point_on_mouse_move = QtCore.QPoint()
    
            # stores the delta between self._point_on_mouse_press and self._point_on_mouse_move
            self._delta_event_pos = None
            self._current_action = self.current_action = None
    
            # mouse button state
            self._is_right_mouse_button_surpressed = False
            self._is_left_mouse_button_surpressed = False
    
        @property
        def point_on_mouse_press(self):
            x = self._point_on_mouse_press.x()
            y = self._point_on_mouse_press.y()
            return x, y
    
        @point_on_mouse_press.setter
        def point_on_mouse_press(self, event):
            if isinstance(event, QtGui.QMouseEvent):
                self._point_on_mouse_press = QtCore.QPoint(event.pos())
            elif isinstance(event, QtCore.QPoint):
                self._point_on_mouse_press = QtCore.QPoint(event)
    
        @property
        def point_on_mouse_move(self):
            x = self._point_on_mouse_move.x()
            y = self._point_on_mouse_move.y()
            return x, y
    
        @point_on_mouse_move.setter
        def point_on_mouse_move(self, event):
            if isinstance(event, (QtGui.QMouseEvent, QtGui.QWheelEvent)):
                self._point_on_mouse_move = QtCore.QPoint(event.pos())
            elif isinstance(event, QtCore.QPoint):
                self._point_on_mouse_move = QtCore.QPoint(event)
    
        @property
        def delta_mouse_event_pos(self):
            """delta between previous_event and next_event"""
            pos_a = self._point_on_mouse_press
            pos_b = self._point_on_mouse_move
    
            dX = pos_a.x() - pos_b.x()
            dY = pos_a.y() - pos_b.y()
            return dX, dY
    
        @property
        def is_right_mouse_button_surpressed(self):
            return self._is_right_mouse_button_surpressed
    
        @is_right_mouse_button_surpressed.setter
        def is_right_mouse_button_surpressed(self, value):
            self._is_right_mouse_button_surpressed = value
    
        @property
        def is_left_mouse_button_surpressed(self):
            return self._is_left_mouse_button_surpressed
    
        @is_left_mouse_button_surpressed.setter
        def is_left_mouse_button_surpressed(self, value):
            self._is_left_mouse_button_surpressed = value
    
        def _setupAnimation(self):
            self.animationTimer = QtCore.QTimer()
            self.animationTimer.setSingleShot(False)
            self.animationTimer.timeout.connect(self.animate)
            self.animationTimer.start(25)
    
        def mousePressEvent(self, event):
            self.point_on_mouse_press = event
            self.setFocus()
    
            button = event.button()
            modifiers = event.modifiers()
    
            if button == QtCore.Qt.RightButton:
                self.is_right_mouse_button_surpressed = True
            elif button == QtCore.Qt.LeftButton:
                self.is_left_mouse_button_surpressed = True
    
            if button == QtCore.Qt.RightButton and modifiers == QtCore.Qt.ShiftModifier:
                # ON_ZOOM_AREA
                self._drawbox = True
    
            elif button == QtCore.Qt.LeftButton and modifiers == QtCore.Qt.ShiftModifier:
                # ON_SELECT_AREA
                self._drawbox = True
                self._select_area = True
    
            self.is_right_mouse_button_surpressed = True
    
        def mouseReleaseEvent(self, event):
            button = event.button()
            modifiers = event.modifiers()
    
            if button == QtCore.Qt.RightButton:
                self.is_right_mouse_button_surpressed = False
                if modifiers == QtCore.Qt.ShiftModifier:
                    self.current_action = ON_ZOOM_AREA
    
            if button == QtCore.Qt.LeftButton:
                self.is_left_mouse_button_surpressed = False
    
                if self._select_area:
                    self.current_action = ON_SELECT_AREA
                elif modifiers == QtCore.Qt.ShiftModifier:
                    self.current_action = ON_SHIFT_SELECT
                else:
                    self.current_action = ON_SELECT
    
            self._drawbox = False
            self._select_area = False
    
            self.point_on_mouse_move = event
            self.update()
    
        def mouseMoveEvent(self, event):
            self.point_on_mouse_move = event
    
            buttons = int(event.buttons())
            modifiers = event.modifiers()
    
            # rotate
            if buttons == QtCore.Qt.LeftButton and not modifiers == QtCore.Qt.ShiftModifier:
                self.current_action = ON_DYN_ROT
    
            # dynamic zoom
            elif buttons == QtCore.Qt.RightButton and not modifiers == QtCore.Qt.ShiftModifier:
                self.current_action = ON_DYN_ZOOM
    
            # dynamic panning
            elif buttons == QtCore.Qt.MidButton:
                self.current_action = ON_DYN_PAN
    
            # zoom window, overpaints rectangle
            elif buttons == QtCore.Qt.RightButton and modifiers == QtCore.Qt.ShiftModifier:
                self.current_action = ON_ZOOM_AREA
    
            # select area
            elif buttons == QtCore.Qt.LeftButton and modifiers == QtCore.Qt.ShiftModifier:
                self.current_action = ON_SELECT_AREA
    
            self.update()
    
        def wheelEvent(self, event):
    
            if self._have_pyqt5:
                delta = event.angleDelta().y()
            else:
                delta = event.delta()
    
            if delta > 0:
                self.zoom_factor = 1.3
            else:
                self.zoom_factor = 0.7
            self.current_action = ON_ZOOM_FACTOR
            self.point_on_mouse_move = event
    
            self.update()
    
        def keyPressEvent(self, event):
            if event.key() == ord("F"):
                # fit all command, invokes repaint
                self.current_action = ON_ZOOM_FITALL
                self.update()
            else:
                super(GLWidget, self).keyPressEvent(event)
    
        def on_zoom_area(self):
            dx, dy = self.delta_mouse_event_pos
    
            tolerance = 2
            if abs(dx) <= tolerance and abs(dy) <= tolerance:
                # zooming at a near nil value can segfault the opengl viewer
                pass
            else:
                if not self.is_right_mouse_button_surpressed:
                    coords = [self.point_on_mouse_press[0],
                              self.point_on_mouse_press[1],
                              self.point_on_mouse_move[0],
                              self.point_on_mouse_move[1]]
                    self._display.ZoomArea(*coords)
    
        def on_zoom_factor(self):
            self._display.ZoomFactor(self.zoom_factor)
    
        def on_zoom_fitall(self):
            """ handle fitting the scene in the viewport
    
            invoked on pressing "f"
    
            """
            self._display.FitAll()
    
        def on_zoom(self):
            self._zoom_area = True
    
        def on_dyn_zoom(self):
            """ handle zooming of the viewport
    
            through the shift + right mouse button
    
            """
            self._display.DynamicZoom(self.point_on_mouse_press[0],
                                      self.point_on_mouse_press[1],
                                      self.point_on_mouse_move[0],
                                      self.point_on_mouse_move[1]
                                      )
            self.point_on_mouse_press = self._point_on_mouse_move
    
        def on_dyn_rot(self):
            """ handle rotation of the viewport
    
            """
            self._display.StartRotation(*self.point_on_mouse_press)
            self._display.Rotation(*self.point_on_mouse_move)
            self.point_on_mouse_press = self._point_on_mouse_move
    
        def on_dyn_pan(self):
            """ handle panning of the viewport
    
            """
            dx, dy = self.delta_mouse_event_pos
            self.point_on_mouse_press = self._point_on_mouse_move
            self._display.Pan(-dx, dy)
    
        def on_move_to(self):
            # Relays mouse position in pixels theXPix and theYPix to the
            # interactive context selectors
            # This is done by the view theView passing this position to the main
            # viewer and updating it
            # Functions in both Neutral Point and local contexts
    
            # TODO: 6.9.1 changes this, important...
            # If theToRedrawOnUpdate is set to false, callee should call
            # RedrawImmediate() to highlight detected object.
            print(" no specific action -> MoveTo")
            self._display.MoveTo(*self.point_on_mouse_move)
    
        def on_select(self):
            self._display.Select(*self.point_on_mouse_move)
    
        def on_shift_select(self):
            self._display.ShiftSelect(*self.point_on_mouse_move)
    
        def on_select_area(self):
            pass
            # TODO: not really implemented
            # self._display.SelectArea(Xmin, Ymin, Xmin+dx, Ymin+dy)
    
        def _dispatch_camera_command_actions(self):
            """ dispatches actions that involve zooming, panning or rotating
            the viewport. Any of these actions invokes redrawing the view.
            This is why its relevant that these are handled in a specific method
    
            This method is to be called **exclusisely** from the .paintEvent method
            since here it can be interwoven with the overpainting routines
    
            Returns
            -------
    
            perform_action : bool
                True if any actions were performed, and implicitly the viewport
                was redrawn
                False otherwise
    
            """
            perform_action = False
    
            if self.current_action:
                print("handling camera action:", self.current_action)
    
            try:
                if self.current_action is not None:
                    action = getattr(self, self.current_action)
                    action()
    
            except Exception:
                print("could not invoke camera command action {0}".format(
                        self.current_action))
    
            finally:
                self.current_action = None
    
            return perform_action
    
        def paintEvent(self, event):
            """ handles all actions that redraw the viewport
    
            Parameters
            ----------
            event : QPaintEvent
    
            See Also
            --------
            this method is also invoked through the self.update method, see the
            mouseMoveEvent method
            """
    
            if self._inited:
                # actions like panning, zooming and rotating the view invoke
                # redrawing it
                # therefore, these actions need to be performed in the paintEvent
                # method
                # this way, redrawing the view takes place synchronous with the
                # overpaint action
                # not respecting this order would lead to a jittering view
                if not self._dispatch_camera_command_actions():
                    # if no camera actions took place, invoke a redraw of
                    # the viewport
                    self._display.View.Redraw()
    
                if self.context().isValid():
                    # acquire the OpenGL context
                    self.makeCurrent()
                    painter = QtGui.QPainter(self)
                    painter.setRenderHint(QtGui.QPainter.Antialiasing, True)
                    # swap the buffer before overpainting it
                    self.swapBuffers()
                    # perform overpainting
                    self._overpaint(event, painter)
                    painter.end()
                    # hand over the OpenGL context
                    self.doneCurrent()
                else:
                    print('invalid OpenGL context: Qt cannot overpaint viewer')
    
        def _overpaint(self, event, painter):
            """ overpaint the viewport
    
            the viewport is overpainted to render a rectangle selection
            or -more awesomely- to overpaint bubbles on top of the viewport
            in a background rendering thread
    
            Parameters
            ----------
    
            event:
    
            painter:
    
            """
            self.drawBubbles(event, painter)
    
            # draw instructions in half transparent rectangle on top of
            # the viewport
            self.drawInstructions(painter)
    
            if self._drawbox:
                # draw selection rectangle
                self.drawBox(painter)
    
        def showEvent(self, event):
            """ invoked when on first draw of the viewport
    
            """
            self.createBubbles(20 - len(self.bubbles))
    
    
        def createBubbles(self, number):
            """ instantiate a `number` of bubbles to be painted on top of
            the viewport
            """
            for _ in range(number):
                position = QtCore.QPointF(
                        self.width() * (0.1 + 0.8 * random.random()),
                        self.height() * (0.1 + 0.8 * random.random()))
                radius = min(self.width(), self.height()) * (
                    0.0125 + 0.0875 * random.random())
                velocity = QtCore.QPointF(
                        self.width() * 0.0125 * (-0.5 + random.random()),
                        self.height() * 0.0125 * (-0.5 + random.random()))
    
                self.bubbles.append(Bubble(position, radius, velocity))
    
        def animate(self):
            """ update the position of the bubbles
    
            this method is invoked from the self.animationTimer method
    
            """
            for bubble in self.bubbles:
                bubble.move(self.rect())
            self.update()
    
        def drawBox(self, painter):
            """ overpaint a rectangle on top of the viewport, when selecting with
            Shift + right mouse button
            """
            painter.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0), 1))
            tolerance = 2
    
            dx, dy = self.delta_mouse_event_pos
    
            if abs(dx) <= tolerance and abs(dy) <= tolerance:
                pass
    
            else:
                rect = QtCore.QRect(self.point_on_mouse_press[0],
                                    self.point_on_mouse_press[1], -dx, -dy)
                painter.drawRect(rect)
    
        def drawBubbles(self, event, painter):
            """ overpaint soap like bubble on top of the viewport
    
            """
            for bubble in self.bubbles:
                bubble_rect = bubble.rect()
                if bubble_rect.intersects(QtCore.QRectF(event.rect())):
                    pt = QtCore.QPointF(self._point_on_mouse_move)
                    over_mouse = bubble_rect.contains(pt)
                    bubble.drawBubble(painter, over_mouse)
    
        def drawInstructions(self, painter):
            """ overpaint a message with a gray transparent background
    
            """
            transparency = 80
            metrics = QtGui.QFontMetrics(self.font())
            border = max(4, metrics.leading())
    
            rect = metrics.boundingRect(0, 0, self.width() - 2 * border,
                                        int(self.height() * 0.125),
                                        QtCore.Qt.AlignCenter | QtCore.Qt.TextWordWrap,
                                        self.text)
    
            painter.setRenderHint(QtGui.QPainter.TextAntialiasing)
    
            painter.fillRect(
                    QtCore.QRect(0, 0, self.width(), rect.height() + 2 * border),
                    QtGui.QColor(0, 0, 0, transparency))
    
            painter.setPen(QtCore.Qt.white)
    
            painter.fillRect(
                    QtCore.QRect(0, 0, self.width(), rect.height() + 2 * border),
                    QtGui.QColor(0, 0, 0, transparency))
    
            painter.drawText((self.width() - rect.width()) / 2, border,
                             rect.width(),
                             rect.height(),
                             QtCore.Qt.AlignCenter | QtCore.Qt.TextWordWrap,
                             self.text)
    
    
    if __name__ == '__main__':
        def TestOverPainting():
            class AppFrame(QtWidgets.QWidget):
                def __init__(self, parent=None):
                    QtWidgets.QWidget.__init__(self, parent)
                    self.setWindowTitle(self.tr("qtDisplay3d overpainting example"))
                    self.resize(1280, 1024)
                    self.canva = GLWidget(self)
                    mainLayout = QtWidgets.QHBoxLayout()
                    mainLayout.addWidget(self.canva)
                    mainLayout.setContentsMargins(0, 0, 0, 0)
                    self.setLayout(mainLayout)
    
                def runTests(self):
                    self.canva._display.Test()
    
            app = QtWidgets.QApplication(sys.argv)
            frame = AppFrame()
            frame.show()
            frame.canva.InitDriver()
            frame.runTests()
            app.exec_()
    
    
        TestOverPainting()

[Link 1]: https://blog.csdn.net/weixin_42755384/article/details/85772835
[20190106123715358.gif]: /images/20220330/2d635ebf14d7488ebb8b61a92057a227.png