Hey there! Since you're already comfortable with PyQt5's basic widgets, adding 2D and 3D visualization for your gyro/accelerometer data is totally doable. Let's break down the tools and approaches you can use:

2D Graphics (Square, Circle, Arc) #

For 2D drawing similar to Tkinter, QPainter is PyQt5's go-to tool. You'll need to create a custom widget (subclass QWidget or QFrame) and override its paintEvent method to handle drawing. Here's a quick example that covers the shapes you mentioned:

from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QPainter, QPen, QBrush
from PyQt5.QtCore import Qt
import sys

class DrawWidget(QWidget):
    def __init__(self):
        super().__init__()
        self.setFixedSize(400, 400)

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)  # Smooth edges

        # Draw a square
        painter.setPen(QPen(Qt.blue, 2))
        painter.setBrush(QBrush(Qt.lightGray))
        painter.drawRect(50, 50, 100, 100)

        # Draw a circle
        painter.setPen(QPen(Qt.red, 2))
        painter.setBrush(QBrush(Qt.yellow))
        painter.drawEllipse(200, 50, 100, 100)

        # Draw an arc (180 degrees, from 0 to 180)
        painter.setPen(QPen(Qt.green, 3))
        painter.drawArc(50, 200, 150, 150, 0, 180 * 16)  # Note: angles are in 1/16 degrees

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = DrawWidget()
    window.show()
    sys.exit(app.exec_())

Tips for 2D: #

• To update graphics in real-time (like with sensor data), call self.update() from your sensor data handler—this triggers a new paintEvent.
• For dynamic data plots (like accelerometer time series), consider PyQtGraph—it's optimized for fast, real-time plotting and integrates seamlessly with PyQt5.

3D Object Creation (Similar to Processing) #

PyQt5 has the Qt3D module for native 3D rendering. It's a bit more structured than Processing's 3D, but once you get the core components down, it's straightforward. Here's a minimal example to create a rotating cube (you can adapt this to respond to your gyro data):

from PyQt5.Qt3DCore import QEntity, QTransform
from PyQt5.Qt3DExtras import Q3DWindow, QOrbitCameraController, QCuboidMesh, QPhongMaterial
from PyQt5.QtGui import QVector3D
from PyQt5.QtCore import QTimer
import sys

if __name__ == "__main__":
    app = QApplication(sys.argv)

    # Create 3D window
    view = Q3DWindow()
    view.setTitle("3D Cube")
    container = view.createWindowContainer()
    container.setMinimumSize(400, 400)

    # Root entity
    root_entity = QEntity()

    # Cube mesh + material
    cube_mesh = QCuboidMesh()
    cube_material = QPhongMaterial()
    cube_material.setDiffuse(Qt.red)

    # Cube entity with transform
    cube_entity = QEntity(root_entity)
    cube_entity.addComponent(cube_mesh)
    cube_entity.addComponent(cube_material)
    cube_transform = QTransform()
    cube_entity.addComponent(cube_transform)

    # Camera controller (allow mouse rotation/zoom)
    camera = view.camera()
    camera.lens().setPerspectiveProjection(45, 16/9, 0.1, 1000)
    camera.setPosition(QVector3D(5, 5, 5))
    camera.setViewCenter(QVector3D(0, 0, 0))
    controller = QOrbitCameraController(root_entity)
    controller.setCamera(camera)

    view.setRootEntity(root_entity)

    # Simulate gyro data rotation (replace with your actual sensor input)
    timer = QTimer()
    angle = 0
    def update_rotation():
        nonlocal angle
        angle += 1
        cube_transform.setRotationX(angle)
        cube_transform.setRotationY(angle * 0.5)
    timer.timeout.connect(update_rotation)
    timer.start(30)

    container.show()
    sys.exit(app.exec_())

Tips for 3D: #

• Qt3D uses an entity-component system: every object is an QEntity, and you add components (mesh, material, transform) to define its behavior.
• To link your gyro data to 3D rotations, just update the QTransform component's rotation values whenever new sensor data comes in—no need to redraw the entire scene.
• If you need more complex 3D models, you can load OBJ/FBX files using QMesh (set the source to your model file path).

General Best Practices #

• Keep sensor data processing in a separate thread (use QThread) to avoid blocking the UI. Use PyQt's signal-slot mechanism to send data to the UI thread for visualization.
• For both 2D and 3D, use QTimer to control update frequency (match your sensor's sample rate for smooth results).
• Check out PyQt5's official examples for Qt3D and QPainter—they cover most common use cases and are great for learning.

内容的提问来源于stack exchange，提问作者Juno