Directorio
Pintar en PyQt5
El sistema de pintura PyQt5 es capaz de representar gráficos vectoriales, imágenes y texto de esquema basado en fuentes. Cuando queremos cambiar o mejorar un widget existente, o si creamos un widget personalizado desde cero, necesitamos pintar en la aplicación. Para dibujar, utilizamos la API de dibujo proporcionada por el kit de herramientas PyQt5.
QPainter
QPainterRealice dibujos de bajo nivel en widgets y otros dispositivos de dibujo. Puede dibujar desde líneas simples hasta formas complejas.
método paintEvent
La pintura se paintEvent()completó en este método. El código de dibujo se coloca entre los métodos begin()y los end()métodos del objeto QPainter. Realiza dibujos de bajo nivel en widgets y otros dispositivos de dibujo.
Dibujo de texto
Primero dibujamos un texto Unicode en el área del cliente de la ventana.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
from PyQt5.QtWidgets import QWidget, QApplication
from PyQt5.QtGui import QPainter, QColor, QFont
from PyQt5.QtCore import Qt
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.text = "Лев Николаевич Толстой\nАнна Каренина"
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('Drawing text')
self.show()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
self.drawText(event, qp)
qp.end()
def drawText(self, event, qp):
qp.setPen(QColor(168, 34, 3))
qp.setFont(QFont('Decorative', 10))
qp.drawText(event.rect(), Qt.AlignCenter, self.text)
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())En nuestro ejemplo, dibujamos un texto en Cylliric. El texto está alineado vertical y horizontalmente.
def paintEvent（self，event）：
...El dibujo se realiza en el evento de dibujo.
qp = QPainter()
qp.begin(self)
self.drawText(event, qp)
qp.end()Esta QPainterclase es responsable de toda la pintura de bajo nivel. Todos los métodos de pintura son intermedios begin()y end()métodos. La pintura real se confía a este drawText()método.
qp.setPen(QColor(168, 34, 3))
qp.setFont(QFont('Decorative', 10))Aquí, hemos definido el lápiz y la fuente utilizados para dibujar el texto.
qp.drawText(event.rect(), Qt.AlignCenter, self.text)Este drawText()método dibuja texto en la ventana. rect()El método de evento de pintura devuelve el rectángulo que debe actualizarse. A medida Qt.AlignCenterque alineamos el texto en dos dimensiones.
Figura: Dibujo de texto
Punto de trazado
Los puntos son los objetos gráficos más simples que se pueden dibujar. Este es un pequeño lugar en la ventana.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PyQt5.QtWidgets import QWidget, QApplication
from PyQt5.QtGui import QPainter
from PyQt5.QtCore import Qt
import sys, random
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 300, 190)
self.setWindowTitle('Points')
self.show()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawPoints(qp)
qp.end()
def drawPoints(self, qp):
qp.setPen(Qt.red)
size = self.size()
for i in range(1000):
x = random.randint(1, size.width()-1)
y = random.randint(1, size.height()-1)
qp.drawPoint(x, y)
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())En nuestro ejemplo, dibujamos al azar 1000 puntos rojos en el área del cliente de la ventana.
qp.setPen（Qt.red）Ponemos el bolígrafo en rojo. Utilizamos Qt.redconstantes de color predefinidas .
size = self.size（）Cada vez que se cambia el tamaño de la ventana, se genera un evento de dibujo. Usamos este size()método para obtener el tamaño actual de la ventana. Usamos el tamaño de la ventana para distribuir los puntos en el área del cliente de la ventana.
qp.drawPoint（x，y） Utilizamos este drawPoint()método para ilustrar este punto.
Figura: Puntos
Color
El color es un objeto que representa una combinación de valores de intensidad rojo, verde y azul (RGB). Los valores RGB válidos oscilan entre 0 y 255. Podemos definir colores de varias maneras. Los más comunes son los valores decimales o hexadecimales RGB. También podemos usar valores RGBA, que representan rojo, verde, azul y alfa. Aquí agregamos información adicional sobre la transparencia: el valor alfa 255 define la opacidad total, 0 significa transparencia total, por ejemplo, el color no es visible.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PyQt5.QtWidgets import QWidget, QApplication
from PyQt5.QtGui import QPainter, QColor, QBrush
import sys
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 350, 100)
self.setWindowTitle('Colours')
self.show()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawRectangles(qp)
qp.end()
def drawRectangles(self, qp):
col = QColor(0, 0, 0)
col.setNamedColor('#d4d4d4')
qp.setPen(col)
qp.setBrush(QColor(200, 0, 0))
qp.drawRect(10, 15, 90, 60)
qp.setBrush(QColor(255, 80, 0, 160))
qp.drawRect(130, 15, 90, 60)
qp.setBrush(QColor(25, 0, 90, 200))
qp.drawRect(250, 15, 90, 60)
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())En nuestro ejemplo, hemos dibujado tres rectángulos de colores.
color = QColor（0,0,0）
color.setNamedColor（ '＃d4d4d4'）Aquí usamos la notación hexadecimal para definir colores.
qp.setBrush（QColor（200,0,0））
qp.drawRect（10,15,90,60）Aquí definimos un pincel y dibujamos un rectángulo. Un pincel para uñas es un objeto gráfico básico que se utiliza para dibujar el fondo de una forma. Este drawRect()método acepta cuatro parámetros. Los dos primeros son los valores x e y en el eje. Los parámetros tercero y cuarto son el ancho y la altura del rectángulo. Este método utiliza la pluma y el pincel actuales para dibujar el rectángulo.
Figura: color
QPEN
Este QPenes un objeto gráfico básico. Se utiliza para dibujar líneas, curvas y contornos de rectángulos, elipses, polígonos u otras formas.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PyQt5.QtWidgets import QWidget, QApplication
from PyQt5.QtGui import QPainter, QPen
from PyQt5.QtCore import Qt
import sys
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 280, 270)
self.setWindowTitle('Pen styles')
self.show()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawLines(qp)
qp.end()
def drawLines(self, qp):
pen = QPen(Qt.black, 2, Qt.SolidLine)
qp.setPen(pen)
qp.drawLine(20, 40, 250, 40)
pen.setStyle(Qt.DashLine)
qp.setPen(pen)
qp.drawLine(20, 80, 250, 80)
pen.setStyle(Qt.DashDotLine)
qp.setPen(pen)
qp.drawLine(20, 120, 250, 120)
pen.setStyle(Qt.DotLine)
qp.setPen(pen)
qp.drawLine(20, 160, 250, 160)
pen.setStyle(Qt.DashDotDotLine)
qp.setPen(pen)
qp.drawLine(20, 200, 250, 200)
pen.setStyle(Qt.CustomDashLine)
pen.setDashPattern([1, 4, 5, 4])
qp.setPen(pen)
qp.drawLine(20, 240, 250, 240)
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())En nuestro ejemplo, dibujamos seis líneas. Las líneas se dibujan en seis estilos de pluma diferentes. Hay cinco estilos de pluma predefinidos. También podemos crear estilos de bolígrafo personalizados. La última línea se dibuja con un estilo de lápiz personalizado.
pen = QPen（Qt.black，2，Qt.SolidLine）Creamos un QPenobjeto. El color es negro. El ancho se establece en 2 píxeles para que podamos ver la diferencia entre los estilos de lápiz. Qt.SolidLineEs uno de los estilos de lápiz predefinidos.
pen.setStyle(Qt.CustomDashLine)
pen.setDashPattern([1, 4, 5, 4])
qp.setPen(pen)Aquí definimos un estilo de pluma personalizado. Establecemos el Qt.CustomDashLine estilo del lápiz y llamamos al setDashPattern()método. La lista de números define un estilo. Debe haber un número par. Los números impares definen guiones y espacios de números pares. Cuanto mayor es el número, mayor es el espacio o el guión. Nuestro patrón es 1px dash, 4px space, 5px dash, 4px space, etc.
Figura: estilo de pluma
QBrush
QBrushEs un objeto gráfico básico. Se utiliza para dibujar el fondo de formas gráficas como rectángulos, elipses o polígonos. Hay tres tipos diferentes de pinceles: pinceles predefinidos, degradados o patrones de textura.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PyQt5.QtWidgets import QWidget, QApplication
from PyQt5.QtGui import QPainter, QBrush
from PyQt5.QtCore import Qt
import sys
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 355, 280)
self.setWindowTitle('Brushes')
self.show()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawBrushes(qp)
qp.end()
def drawBrushes(self, qp):
brush = QBrush(Qt.SolidPattern)
qp.setBrush(brush)
qp.drawRect(10, 15, 90, 60)
brush.setStyle(Qt.Dense1Pattern)
qp.setBrush(brush)
qp.drawRect(130, 15, 90, 60)
brush.setStyle(Qt.Dense2Pattern)
qp.setBrush(brush)
qp.drawRect(250, 15, 90, 60)
brush.setStyle(Qt.DiagCrossPattern)
qp.setBrush(brush)
qp.drawRect(10, 105, 90, 60)
brush.setStyle(Qt.Dense5Pattern)
qp.setBrush(brush)
qp.drawRect(130, 105, 90, 60)
brush.setStyle(Qt.Dense6Pattern)
qp.setBrush(brush)
qp.drawRect(250, 105, 90, 60)
brush.setStyle(Qt.HorPattern)
qp.setBrush(brush)
qp.drawRect(10, 195, 90, 60)
brush.setStyle(Qt.VerPattern)
qp.setBrush(brush)
qp.drawRect(130, 195, 90, 60)
brush.setStyle(Qt.BDiagPattern)
qp.setBrush(brush)
qp.drawRect(250, 195, 90, 60)
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())En nuestro ejemplo, dibujamos nueve rectángulos diferentes.
brush = QBrush(Qt.SolidPattern)
qp.setBrush(brush)
qp.drawRect(10, 15, 90, 60)Definimos un objeto pincel. Lo configuramos como un objeto de pintor y drawRect()dibujamos un rectángulo llamando al método.
Figura: Cepillo
Bézier 曲线
La curva de Bezier es una línea cúbica. Se puede usar la curva Bézier en PyQt5 QPainterPath. La ruta del pintor es un objeto compuesto por muchos bloques de construcción gráficos, como rectángulos, elipses, líneas y curvas.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from PyQt5.QtWidgets import QWidget, QApplication
from PyQt5.QtGui import QPainter, QPainterPath
from PyQt5.QtCore import Qt
import sys
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 380, 250)
self.setWindowTitle('Bézier curve')
self.show()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
self.drawBezierCurve(qp)
qp.end()
def drawBezierCurve(self, qp):
path = QPainterPath()
path.moveTo(30, 30)
path.cubicTo(30, 30, 200, 350, 350, 30)
qp.drawPath(path)
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())Este ejemplo dibuja una curva de Bézier.
path = QPainterPath（）
path.moveTo（30,30）
path.cubicTo（30,30,200,350,350,30）Usamos QPainterPathcaminos para crear curvas Bézier. La curva se cubicTo()crea mediante un método que requiere tres puntos: el punto inicial, el punto de control y el punto final.
qp.drawPath(path)El camino final se drawPath()dibuja por método.
Figura: curva de Bézier
En esta parte del tutorial PyQt5, hicimos algunos dibujos básicos.
