Creating a Camera Application using Pyqt5
Are you looking to create a camera application using Pyqt5? You have come to the right place. In this article, we will discuss how to create a camera application that captures video from a camera and displays it in a Pyqt5 GUI.
Prerequisites
Before we begin, make sure you have installed the following:
- Python 3.x
- Pyqt5
- OpenCV
You can install Pyqt5 and OpenCV using pip. Run the following command:
pip install pyqt5 opencv-python-headless
Importing necessary libraries
Firstly, we need to import the necessary libraries in our Python script. Open your Python editor and import the following libraries:
import sys
from PyQt5.QtWidgets import QApplication, QDialog, QHBoxLayout, QVBoxLayout, QLabel
from PyQt5.QtCore import Qt, QTimer
import cv2
import numpy as np
Defining the GUI
Next, we will define the GUI. We will create a simple GUI that consists of a label and a button. The label will display the camera video feed, and the button will allow us to start and stop the camera feed.
class CameraGUI(QDialog):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
# Create labels for the camera feed
self.displayLabel = QLabel()
self.displayLabel.setAlignment(Qt.AlignCenter)
self.displayLabel.setMinimumSize(320, 240)
# Create a button to start and stop the feed
self.button = QPushButton('Start Camera')
self.button.clicked.connect(self.startCamera)
# Create a horizontal layout for the button
buttonLayout = QHBoxLayout()
buttonLayout.addWidget(self.button)
# Create a vertical layout for the GUI and add the button and labels
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.displayLabel)
mainLayout.addLayout(buttonLayout)
# Set the layout for the GUI
self.setLayout(mainLayout)
self.setWindowTitle('CameraGUI')
Capturing Video from Camera
Now, let’s define the function that will capture the video from our camera.
class CameraGUI(QDialog):
def __init__(self):
...
def startCamera(self):
# Create a video capture object
self.cap = cv2.VideoCapture(0)
# Set the video capture frame width and height
self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 320)
self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 240)
# Create a timer to read the camera feed and update the label
self.timer = QTimer(self)
self.timer.timeout.connect(self.updateFrame)
self.timer.start(5)
def updateFrame(self):
# Read the camera feed
ret, frame = self.cap.read()
# Convert the video frame to RGB
rgbImage = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# Convert the RGB image to QImage
h, w, ch = rgbImage.shape
qImg = QImage(rgbImage.data, w, h, ch * w, QImage.Format_RGB888)
# Set the QImage to the display label
self.displayLabel.setPixmap(QPixmap.fromImage(qImg))
The startCamera()
function creates a video capture object using OpenCV’s cv2.VideoCapture()
function. We then set the width and height of the video capture frame. Finally, we create a timer that reads the camera feed and calls the updateFrame()
function to update the GUI.
The updateFrame()
function takes the captured frame and converts it to RGB format using OpenCV’s cv2.cvtColor()
function. We then convert the RGB image to a QImage that can be set to the label in our GUI using QPixmap.fromImage()
.
Stopping the Camera
Finally, we need to create the function that will stop the camera feed when the button is pressed.
class CameraGUI(QDialog):
def __init__(self):
...
def stopCamera(self):
self.timer.stop()
self.cap.release()
self.displayLabel.clear()
def startCamera(self):
...
def updateFrame(self):
...
The stopCamera()
function stops the timer, releases the video capture object, and clears the display label.
Running the Application
That’s it! We have defined the necessary functions to create a camera application using Pyqt5. Now, let’s run the application.
if __name__ == '__main__':
app = QApplication(sys.argv)
window = CameraGUI()
window.show()
app.exec_()
Conclusion
In this article, we discussed how to create a camera application using Pyqt5 that captures video from a camera and displays it in a GUI. We defined the necessary functions to start and stop the camera feed, and update the GUI with the captured frames. With these functions, you now have the foundation to create your own camera application. Happy coding!