PyQt5 – Crear aplicación de pintura

Hay tantas opciones proporcionadas por Python para desarrollar una aplicación GUI y PyQt5 es una de ellas. PyQt5 es un kit de herramientas GUI multiplataforma, un conjunto de enlaces de Python para Qt v5. Uno puede desarrollar una aplicación de escritorio interactiva con tanta facilidad debido a las herramientas y la simplicidad que ofrece esta biblioteca.

En este artículo veremos cómo podemos crear una aplicación Paint usando PyQt5. Nuestra aplicación Paint consistirá en lo siguiente

 Características :

  1. El usuario puede seleccionar diferentes tamaños de pincel 
  2. El usuario puede seleccionar diferentes colores de pincel 
  3. Salvamento del lienzo 
  4. Borrar todo el lienzo a la vez  

Pasos para diseñar los widgets:
1. Cree una ventana, establezca su geometría y título 
2. Cree una barra de menú 
3. Dentro de la barra de menú, agregue diferentes menús, que son el menú de archivo, el menú de tamaño y el menú de color 
4. Agregue la acción de guardar y borrar al archivo menú 
 

5. Agregue una acción de diferentes tamaños de pincel al menú de tamaño de pincel 
 

6. Agregue una acción de color de pincel diferente al menú de color de pincel 
 

7. Crea un lienzo en blanco y agrégalo a la ventana.

Pasos de back-end:
1. Cree una variable diferente: indicador de dibujo para verificar si actualmente está dibujando o no y configúrelo en Falso, variable de tamaño de pincel para configurar el tamaño actual del pincel, color del pincel para configurar el color actual del pincel y la variable de posición actual para conocer la posición de cursor 
2. Agregar acción al widget de borrar y guardar 
3. Dentro de la acción de borrar, llene el lienzo con color blanco 
4. Dentro de la acción de guardar, guarde el lienzo 
5. Agregue acciones (métodos) a varios tamaños de pincel y color para establecer el tamaño y el color 
6 Cree un evento de pintura para dibujar un lienzo blanco en la pantalla 
7. Cree un método para saber cuándo se presiona el botón izquierdo del mouse dentro de ese método, haga que el indicador de dibujo sea verdadero y cambie la posición actual 
8. Cree un método para el movimiento del mouse, dentro de este método verifique si el indicador de dibujo es verdadero y el botón aún está presionado, luego dibuje usando el objeto de pintor y cambie la posición según corresponda. 
9. Cree un método para saber si se suelta el botón del mouse dentro de este método, haga que el indicador de dibujo sea falso.

A continuación se muestra la implementación. 

Python3

# importing libraries
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
import sys
 
# window class
class Window(QMainWindow):
    def __init__(self):
        super().__init__()
 
        # setting title
        self.setWindowTitle("Paint with PyQt5")
 
        # setting geometry to main window
        self.setGeometry(100, 100, 800, 600)
 
        # creating image object
        self.image = QImage(self.size(), QImage.Format_RGB32)
 
        # making image color to white
        self.image.fill(Qt.white)
 
        # variables
        # drawing flag
        self.drawing = False
        # default brush size
        self.brushSize = 2
        # default color
        self.brushColor = Qt.black
 
        # QPoint object to tract the point
        self.lastPoint = QPoint()
 
        # creating menu bar
        mainMenu = self.menuBar()
 
        # creating file menu for save and clear action
        fileMenu = mainMenu.addMenu("File")
 
        # adding brush size to main menu
        b_size = mainMenu.addMenu("Brush Size")
 
        # adding brush color to ain menu
        b_color = mainMenu.addMenu("Brush Color")
 
        # creating save action
        saveAction = QAction("Save", self)
        # adding short cut for save action
        saveAction.setShortcut("Ctrl + S")
        # adding save to the file menu
        fileMenu.addAction(saveAction)
        # adding action to the save
        saveAction.triggered.connect(self.save)
 
        # creating clear action
        clearAction = QAction("Clear", self)
        # adding short cut to the clear action
        clearAction.setShortcut("Ctrl + C")
        # adding clear to the file menu
        fileMenu.addAction(clearAction)
        # adding action to the clear
        clearAction.triggered.connect(self.clear)
 
        # creating options for brush sizes
        # creating action for selecting pixel of 4px
        pix_4 = QAction("4px", self)
        # adding this action to the brush size
        b_size.addAction(pix_4)
        # adding method to this
        pix_4.triggered.connect(self.Pixel_4)
 
        # similarly repeating above steps for different sizes
        pix_7 = QAction("7px", self)
        b_size.addAction(pix_7)
        pix_7.triggered.connect(self.Pixel_7)
 
        pix_9 = QAction("9px", self)
        b_size.addAction(pix_9)
        pix_9.triggered.connect(self.Pixel_9)
 
        pix_12 = QAction("12px", self)
        b_size.addAction(pix_12)
        pix_12.triggered.connect(self.Pixel_12)
 
        # creating options for brush color
        # creating action for black color
        black = QAction("Black", self)
        # adding this action to the brush colors
        b_color.addAction(black)
        # adding methods to the black
        black.triggered.connect(self.blackColor)
 
        # similarly repeating above steps for different color
        white = QAction("White", self)
        b_color.addAction(white)
        white.triggered.connect(self.whiteColor)
 
        green = QAction("Green", self)
        b_color.addAction(green)
        green.triggered.connect(self.greenColor)
 
        yellow = QAction("Yellow", self)
        b_color.addAction(yellow)
        yellow.triggered.connect(self.yellowColor)
 
        red = QAction("Red", self)
        b_color.addAction(red)
        red.triggered.connect(self.redColor)
 
 
    # method for checking mouse cicks
    def mousePressEvent(self, event):
 
        # if left mouse button is pressed
        if event.button() == Qt.LeftButton:
            # make drawing flag true
            self.drawing = True
            # make last point to the point of cursor
            self.lastPoint = event.pos()
 
    # method for tracking mouse activity
    def mouseMoveEvent(self, event):
         
        # checking if left button is pressed and drawing flag is true
        if (event.buttons() & Qt.LeftButton) & self.drawing:
             
            # creating painter object
            painter = QPainter(self.image)
             
            # set the pen of the painter
            painter.setPen(QPen(self.brushColor, self.brushSize,
                            Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
             
            # draw line from the last point of cursor to the current point
            # this will draw only one step
            painter.drawLine(self.lastPoint, event.pos())
             
            # change the last point
            self.lastPoint = event.pos()
            # update
            self.update()
 
    # method for mouse left button release
    def mouseReleaseEvent(self, event):
 
        if event.button() == Qt.LeftButton:
            # make drawing flag false
            self.drawing = False
 
    # paint event
    def paintEvent(self, event):
        # create a canvas
        canvasPainter = QPainter(self)
         
        # draw rectangle  on the canvas
        canvasPainter.drawImage(self.rect(), self.image, self.image.rect())
 
    # method for saving canvas
    def save(self):
        filePath, _ = QFileDialog.getSaveFileName(self, "Save Image", "",
                          "PNG(*.png);;JPEG(*.jpg *.jpeg);;All Files(*.*) ")
 
        if filePath == "":
            return
        self.image.save(filePath)
 
    # method for clearing every thing on canvas
    def clear(self):
        # make the whole canvas white
        self.image.fill(Qt.white)
        # update
        self.update()
 
    # methods for changing pixel sizes
    def Pixel_4(self):
        self.brushSize = 4
 
    def Pixel_7(self):
        self.brushSize = 7
 
    def Pixel_9(self):
        self.brushSize = 9
 
    def Pixel_12(self):
        self.brushSize = 12
 
    # methods for changing brush color
    def blackColor(self):
        self.brushColor = Qt.black
 
    def whiteColor(self):
        self.brushColor = Qt.white
 
    def greenColor(self):
        self.brushColor = Qt.green
 
    def yellowColor(self):
        self.brushColor = Qt.yellow
 
    def redColor(self):
        self.brushColor = Qt.red
 
 
 
# create pyqt5 app
App = QApplication(sys.argv)
 
# create the instance of our Window
window = Window()
 
# showing the window
window.show()
 
# start the app
sys.exit(App.exec())

Producción : 

Publicación traducida automáticamente

Artículo escrito por rakshitarora y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *