I'm new to the python world and I have an RPI project where I would like to display the camera's (Arducam 16mpx) realtime image into my GUI application. I saw multiple projects web streaming with OpenCV and Tkinter but I just want to feed it into my app. Is there any way to do it simply with Picamera2 and Guizero?
Thank you
Yes, it is possible to display the real-time image from the Arducam 16mpx camera in your GUI application using the Picamera and Guizero libraries in Python.
To do this, you will first need to install the Picamera and Guizero libraries. You can do this by running the following command in your terminal:
pip install picamera guizero
Once you have the libraries installed, you can use the Picamera library to capture images from the camera and the Guizero library to display them in your GUI application. Here is some sample code that demonstrates how to capture an image from the camera and display it in a Guizero window:
from picamera import PiCamera
from guizero import App, Picture
camera = PiCamera()
def update_image():
camera.capture('image.jpg')
image.value = 'image.jpg'
app = App()
image = Picture(app, image='image.jpg', align='left')
app.repeat(1000, update_image)
app.display()
This code will create a new Guizero App and Picture widget and in the update_image function will capture the image from the camera and set the value of the Picture widget to the captured image. The app.repeat(1000, update_image) line will run the update_image function every 1000 milliseconds (1 second), updating the image in the GUI.
You'll need to adjust the code as per your requirement and test it on your Arducam 16mpx camera.
In order to make the code work with your Arducam 16mpx camera you will need to make sure that the camera is properly connected and configured. You can do this by using the camera.start_preview() method to open a preview window and check that the camera is working as expected.
In addition, you may need to adjust the camera's resolution and other settings to match the specifications of your Arducam 16mpx camera. You can do this using the camera.resolution and other properties of the PiCamera class.
You will also need to ensure that you have the required libraries and drivers installed for your camera to work with the PiCamera library.
Here is an example of how you can use the camera.resolution property to set the resolution of the camera to 16mpx :
camera = PiCamera()
camera.resolution = (4608, 3456)
You can also set the image format and other properties such as brightness, contrast, etc.
If you want to stream video from the camera, you will need to use the
PiCamera.start_recording()
method to start streaming video and the
PiCamera.stop_recording()
method to stop streaming video.
Here is an example of how you can use OpenCV to display the video stream from the camera:
import cv2
from picamera.array import PiRGBArray
from picamera import PiCamera
camera = PiCamera()
camera.resolution = (640, 480)
rawCapture = PiRGBArray(camera, size=(640, 480))
cv2.namedWindow("Frame", cv2.WINDOW_NORMAL)
for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
image = frame.array
cv2.imshow("Frame", image)
key = cv2.waitKey(1)
rawCapture.truncate(0)
if key == ord("q"):
break
cv2.destroyAllWindows()
camera.close()
This code will create a new PiCamera object, set the resolution to 640x480, and create a PiRGBArray object to store the video frames. It then creates a new OpenCV window called "Frame" and starts a loop that captures video frames and displays them in the window. The loop continues until the 'q' key is pressed.
You can adjust the resolution of the camera to match the specifications of your Arducam 16mpx camera and also you can add a Guizero App in order to show the video stream in your GUI application.
For those using the Raspberry Pi Camera functionality in 2023, I had the following documentation of my setup. For reference, I have a Raspberry Pi Model 2 B and I went from installing the OS to using OpenCV on Tkinter with this process.
Commands ran:
- sudo rasp-config
- (You will need to turn the legacy camera on)
- (I had to toggle this a couple of times)
- sudo apt-get install python3-pil python3-pil.imagetk
- sudo apt install python3-matplotlib python3-tk
- sudo pip3 install pyzmq
- pip install opencv-contrib-python==4.5.3.56
- (This installation took a long time; upgrade pip if possible)
- (The version that you install matters)
- (I'd like to reinforce that this took forever)
- pip install -U numpy
- sudo apt install -y python3-picamera2
A test file that you can run that check to make sure that your camera is working with Tkinter correctly, use the following code:
'''
CAMERA GUI
------------------
Instructions:
1. Ensure a version of python has been installed (created on Python 3.11.4)
2. Run the command "pip install Pillow"
3. Run the command "pip install opencv-python"
4. Run the GUI; "python ./MainFunction.py"
------------------
'''
import tkinter
import cv2
import PIL.Image, PIL.ImageTk
import time
# GUI class for basic webcam functionality
# Sample class instantiation: App(tkinter.Tk(),"tkinter ad OpenCV")
class App:
def __init__(self, window, window_title, video_source=0):
# Sets up the tkinter window
self.window=window
self.window.title=(window_title)
# Creates instance variable of parameter video_source
self.video_source=video_source
# Adds the video capturing component to the canvas
# Then packs the canvas to the frame
self.vid= MyVideoCapture(self.video_source)
self.canvas=tkinter.Canvas(window, width=self.vid.width, height = self.vid.height)
self.canvas.pack()
# Frame for the buttons
btn_frame=tkinter.Frame(window, background=self.from_rgb((117, 123, 129)))
btn_frame.place(x=0,y=0, anchor="nw", width=self.vid.width+4)
# Snapshot button
self.btn_snapshot=tkinter.Button(btn_frame, text="Snapshot",width=20, command=self.snapshot, bg=self.from_rgb((52, 61, 70)), fg="white")
self.btn_snapshot.pack(side="left", padx=10, pady=10)
# Proses button
# Empty command; could be linked with more features
self.btn_proses=tkinter.Button(btn_frame, text="Proses", width=10, command=None, bg=self.from_rgb((52, 61, 70)), fg="white")
self.btn_proses.pack(side="left", padx=10, pady=10)
# About button
# Empty command; could be linked with more features
self.btn_about=tkinter.Button(btn_frame, text="About", width=10, command=None, bg=self.from_rgb((52, 61, 70)), fg="white")
self.btn_about.pack(side="right", padx=10, pady=10)
# How long in between photo-frames on the GUI
self.delay=15
self.update()
# Required for tkinter to stay open
# Closing the mainloop will close the program
self.window.mainloop()
# Takes a snapshot of the video
# Saves in the same directory as the
def snapshot(self):
ret, frame=self.vid.get_frame()
if ret:
# Writes the image to a file with a name that includes the date
# TODO Change this to be a more readable file name later
cv2.imwrite("frame-"+time.strftime("%d-%m-%Y-%H-%M-%S") + ".jpg", cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) )
else:
print("\nUnable to take a snapshot.\n")
# This is the key method to show the active camera on the GUI
# Basically gets an image from the camera and updates the PIL Image Canvas
# Updates the canvas after "self.delay" milliseconds
def update(self):
ret, frame=self.vid.get_frame()
if ret:
# Updates the canvas on the GUI
self.photo = PIL.ImageTk.PhotoImage(image=PIL.Image.fromarray(frame))
self.canvas.create_image(0,0, image=self.photo, anchor=tkinter.NW)
# Recursive method; waits "self.delay" before calling itself
self.window.after(self.delay,self.update)
def from_rgb(self,rgb):
return "#%02x%02x%02x" % rgb
# Class responsible for the video capturing feature
# Requires the import of cv2
class MyVideoCapture:
"""docstring for MyVideoCapture"""
def __init__(self, video_source=0):
# Instantiating a VideoCapture device from cv2 library
self.vid = cv2.VideoCapture(video_source)
# Throw an exception if the video source cannot be opened.
if not self.vid.isOpened():
raise ValueError("VideoCapture: Unable to open the video source. Check camera.", video_source)
# Getting the camera width and height to correctly display resolution
# Important component for a correct display
self.width = self.vid.get(cv2.CAP_PROP_FRAME_WIDTH)
self.height = self.vid.get(cv2.CAP_PROP_FRAME_HEIGHT)
# Gets the VideoCapture video
# Called by the update() method
def get_frame(self):
if self.vid.isOpened():
ret, frame = self.vid.read()
if ret:
return (ret, cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
else:
return (ret, None)
else:
return (ret,None)
# Closes the video camera with the "release()" command
# Important for closing gracefully
def __del__(self):
if self.vid.isOpened():
self.vid.release()
# How to instantiate this GUI
App(tkinter.Tk(),"tkinter ad OpenCV")
