Ikuti proyek komprehensif ini untuk mempelajari lebih lanjut tentang Python dan pemrosesan gambar.

Baik Anda ingin mengerjakan proyek Python yang menarik atau menjelajahi berbagai aspek pemrograman Python, membangun aplikasi kamera dapat memenuhi tujuan ini. Ini melibatkan penggabungan berbagai aspek pemrograman Python, seperti pengembangan antarmuka pengguna grafis (GUI), pemrosesan gambar dan video, dan multi-threading.

Selain itu, memecahkan tantangan praktis seperti ini membantu mempertajam keterampilan pemecahan masalah Anda. Keterampilan ini sangat berharga dalam upaya pemrograman apa pun.

Menyiapkan Lingkungan Anda

Mulailah dengan menciptakan lingkungan virtual baru. Ini akan mengisolasi proyek Anda dan memastikan tidak ada konflik antara versi berbeda dari paket yang Anda instal. Kemudian, jalankan perintah terminal ini:

pip install opencv-python pillow

Perintah ini akan menginstal OpenCV perpustakaan dan PIL (Perpustakaan Pencitraan Python) di lingkungan virtual Anda. Anda akan menggunakan OpenCV untuk fungsionalitas computer vision dan PIL untuk manipulasi gambar.

Kode sumber lengkap proyek ini tersedia di a Repositori GitHub.

Mengimpor Perpustakaan yang Diperlukan

Setelah Anda menginstal pustaka ini, Anda dapat mengimpornya bersama dengan modul lain yang diperlukan dari pustaka standar Python:

import tkinter as tk
import cv2
from PIL import Image, ImageTk
import os
import threading
import time

Anda akan melakukannya menggunakan tkinter untuk membuat antarmuka pengguna grafis untuk aplikasi Anda dan modul os, threading, dan waktu untuk fungsionalitas terkait. Dengan memisahkan beberapa kode Anda menjadi untaian, Anda akan melakukannya memungkinkannya berjalan secara bersamaan.

Membuat Direktori Galeri dan Mendefinisikan Variabel dan Bendera Global

Buat direktori untuk menyimpan gambar yang diambil dan rekaman video. Langkah ini akan memastikan bahwa direktori tersebut ada sebelum melanjutkan untuk menangkap atau merekam video.

ifnot os.path.exists("gallery"):
 os.makedirs("gallery")

Kemudian tentukan gambar_thumbnail Dan video_thumbnail variabel. Ini akan menyimpan thumbnail gambar dan video di galeri.

# Initialize image_thumbnails as a global list
image_thumbnails = []
video_thumbnails = [] # New list for video thumbnails
update_camera = True

Itu perbarui_kamera bendera akan mengontrol pembaruan umpan kamera.

Mengambil Gambar Dari Umpan Kamera

Tentukan fungsi yang akan menggunakan OpenCV untuk mengambil gambar dari umpan kamera. Kemudian harus mengambil bingkai dari kamera, menyimpannya di galeri direktori, dan menampilkannya menggunakan tampilkan_gambar.

defcapture_image():
 ret, frame = cap.read()
if ret:
# Generate a unique filename with a timestamp
 timestamp = time.strftime("%Y%m%d%H%M%S")
 image_path = os.path.join("gallery", f"captured_image_{timestamp}.jpg")
 cv2.imwrite(image_path, frame)
 show_image(image_path)

Memulai dan Menghentikan Perekaman Video

Sebelum Anda menampilkan video, Anda memerlukan cara untuk membuatnya. Untuk mencapai hal ini, buatlah fungsi yang memulai proses perekaman video saat pengguna ingin merekam video. Fungsi ini juga harus menonaktifkan Catatan tombol (untuk mencegah beberapa rekaman secara bersamaan) dan aktifkan Berhenti Merekam tombol. Ini menunjukkan bahwa perekaman sedang berlangsung.

defstart_recording():
global video_writer, recording_start_time, recording_stopped, update_camera
ifnot video_writer:
 timestamp = time.strftime("%Y%m%d%H%M%S")
 video_path = os.path.join("gallery", f"recorded_video_{timestamp}.mp4")


# Use mp4v codec (or try other codecs)
 fourcc = cv2.VideoWriter_fourcc(*'mp4v')


# Adjust frame rate and resolution if needed
 video_writer = cv2.VideoWriter(video_path, fourcc, 20.0,
 (640, 480))


 recording_start_time = time.time()
 recording_stopped = False
 record_button.config(state=tk.DISABLED)
 stop_button.config(state=tk.NORMAL)
# Start a separate thread for recording and time-lapse display
 recording_thread = threading.Thread(target=record_and_display)
 recording_thread.start()

Kemudian, buat fungsi yang menghentikan perekaman video dan melepaskan penulis video.

defstop_recording():
global video_writer, recording_stopped
if video_writer:
 video_writer.release()
 recording_stopped = True
 record_button.config(state=tk.NORMAL)
 stop_button.config(state=tk.DISABLED)

Fungsi ini juga memperbarui UI yang mengaktifkan Catatan tombol dan menonaktifkan Berhenti Merekam tombol. Hal ini menunjukkan bahwa perekaman telah berhenti.

Merekam dan Menampilkan Video

Buat fungsi yang akan terus menangkap bingkai dari kamera, memprosesnya, dan menampilkannya di GUI sebagai umpan kamera. Hal ini harus dilakukan kecuali jika Berhenti Merekam tombol ditekan.

defrecord_and_display():
global recording_stopped, update_camera
while video_writer andnot recording_stopped:
 ret, frame = cap.read()


if ret:
 frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)


# Calculate elapsed time and add it to the frame
 elapsed_time = time.time() - recording_start_time
 timestamp = f"Time Elapsed: {int(elapsed_time)}s"


 cv2.putText(frame, timestamp, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 
0.5, (255, 255, 255), 2)


 img = Image.fromarray(frame)
 photo = ImageTk.PhotoImage(image=img)
 camera_feed.config(image=photo)
 camera_feed.image = photo


 video_writer.write(frame)
 time.sleep(0.05)
 camera_feed.after(10, update_camera_feed)

Fungsi ini juga menghitung waktu yang telah berlalu sejak perekaman dimulai dan menampilkannya pada bingkai video.

Menampilkan Gambar dan Video yang Diambil

Sekarang setelah Anda mengambil gambar dan merekam video, Anda memerlukan cara untuk menampilkannya.

Untuk menampilkan gambar, buat fungsi yang membuka gambar dan menampilkannya di feed kamera. Hal ini dicapai dengan membuka gambar menggunakan PIL, lalu mengonversinya ke format itu tkinter dapat ditampilkan, dan terakhir memperbarui widget umpan kamera dengan gambar baru.

defshow_image(image_path):
 image = Image.open(image_path)
 photo = ImageTk.PhotoImage(image=image)
 camera_feed.config(image=photo)
 camera_feed.image = photo

Untuk menampilkan video yang diambil, buat fungsi yang membuka jendela pemutar video tempat pengguna dapat melihat rekaman video. Ini juga menjeda pembaruan umpan kamera saat video diputar.

defplay_video(video_path):
defclose_video_player():
 video_player.destroy()
global update_camera
 update_camera = True
global update_camera
 update_camera = False


 video_player = tk.Toplevel(root)
 video_player.title("Video Player")


 video_cap = cv2.VideoCapture(video_path)


defupdate_video_frame():
 ret, frame = video_cap.read()


if ret:
 frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 img = Image.fromarray(frame)
 photo = ImageTk.PhotoImage(image=img)
 video_label.config(image=photo)
 video_label.image = photo


# Get the actual frame rate of the video
 frame_rate = video_cap.get(cv2.CAP_PROP_FPS)
 delay = int(1000 / frame_rate)


 video_player.after(delay, update_video_frame) 
else:
 video_player.destroy()


 video_label = tk.Label(video_player)
 video_label.pack()


 update_video_frame()
 video_player.protocol("WM_DELETE_WINDOW", close_video_player)

Menjeda pembaruan umpan kamera memastikan pengalaman menonton yang lancar.

Membuat Thumbnail Video dan Membuka Galeri

Buat fungsi yang akan menghasilkan gambar mini untuk video tertentu. Hal ini akan memudahkan pengguna untuk mengidentifikasi video yang diminati.

defcreate_video_thumbnail(video_path):
 video_cap = cv2.VideoCapture(video_path)
 ret, frame = video_cap.read()
if ret:
 frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 thumbnail = Image.fromarray(frame).resize((100, 100))
 thumbnail_photo = ImageTk.PhotoImage(image=thumbnail)
return thumbnail_photo, os.path.basename(video_path) 
returnNone, None

Selanjutnya, buat fungsi yang memutar video ketika pengguna mengklik thumbnail video di jendela galeri:

defplay_video_from_thumbnail(video_path):
 play_video(video_path)

Kemudian buat fungsi yang membuat jendela baru tempat pengguna dapat melihat gambar dan video yang diambil.

defopen_gallery():
global update_camera
 update_camera = False
 gallery_window = tk.Toplevel(root)
 gallery_window.title("Gallery")


defback_to_camera():
 gallery_window.destroy()
global update_camera


# Resume updating the camera feed
 update_camera = True


 back_button = tk.Button(gallery_window, text="Back to Camera", 
 command=back_to_camera)


 back_button.pack()


 gallery_dir = "gallery"
 image_files = [f for f in os.listdir(gallery_dir) if f.endswith(".jpg")]
 video_files = [f for f in os.listdir(gallery_dir) if f.endswith(".mp4")]


# Clear the existing image_thumbnails and video_thumbnails lists
del image_thumbnails[:]
del video_thumbnails[:]


for image_file in image_files:
 image_path = os.path.join(gallery_dir, image_file)
 thumbnail = Image.open(image_path).resize((100, 100))
 thumbnail_photo = ImageTk.PhotoImage(image=thumbnail)
 image_name = os.path.basename(image_file)


defshow_image_in_gallery(img_path, img_name):
 image_window = tk.Toplevel(gallery_window)
 image_window.title("Image")
 img = Image.open(img_path)
 img_photo = ImageTk.PhotoImage(img)
 img_label = tk.Label(image_window, image=img_photo)
 img_label.image = img_photo
 img_label.pack()
 img_label_name = tk.Label(image_window, text=img_name)
 img_label_name.pack()


 thumbnail_label = tk.Label(gallery_window, image=thumbnail_photo)
 thumbnail_label.image = thumbnail_photo


 thumbnail_label.bind("", lambda event, 
 img_path=image_path, 
 img_name=image_name: 
 show_image_in_gallery(img_path, img_name))


 thumbnail_label.pack()
 image_thumbnails.append(thumbnail_photo) 


# Display the image filename below the thumbnail
 image_name_label = tk.Label(gallery_window, text=image_name)
 image_name_label.pack()


for video_file in video_files:
 video_path = os.path.join(gallery_dir, video_file)


# Create a video thumbnail and get the filename
 thumbnail_photo, video_name = create_video_thumbnail(video_path)


if thumbnail_photo:
 video_thumbnail_button = tk.Button(
 gallery_window,
 image=thumbnail_photo,
 command=lambda path=video_path: play_video_from_thumbnail(path)
 )


 video_thumbnail_button.pack()


# Store the video thumbnail PhotoImage objects
 video_thumbnails.append(thumbnail_photo) 
# Display the video filename below the thumbnail
 video_name_label = tk.Label(gallery_window, text=video_name)
 video_name_label.pack()

Thumbnail dibuat untuk gambar dan video. Artinya, Anda dapat mengekliknya untuk melihat gambar berukuran penuh atau memutar video.

Membuat Antarmuka Pengguna Utama untuk Aplikasi Anda

Mulailah dengan membuat yang utama tkinter jendela aplikasi dan kemudian beri judul.

root = tk.Tk()
root.title("Camera Application")

Kemudian inisialisasi variabel yang diperlukan.

video_writer = None
recording_start_time = 0# Initialize recording start time
recording_stopped = False# Initialize recording_stopped flag

Kemudian buat tombol untuk berbagai tindakan.

capture_button = tk.Button(root, text="Capture", command=capture_image)
record_button = tk.Button(root, text="Record", command=start_recording)
stop_button = tk.Button(root, text="Stop Recording", command=stop_recording)
gallery_button = tk.Button(root, text="Gallery", command=open_gallery)
quit_button = tk.Button(root, text="Quit", command=root.quit)

Gunakan manajer tata letak kisi untuk mengatur tombol di jendela utama.

capture_button.grid(row=0, column=0, padx=10, pady=10)
record_button.grid(row=0, column=1, padx=10, pady=10)
stop_button.grid(row=0, column=2, padx=10, pady=10)
gallery_button.grid(row=0, column=3, padx=10, pady=10)
quit_button.grid(row=0, column=4, padx=10, pady=10)

Buat widget untuk menampilkan umpan kamera dan menginisialisasinya.

camera_feed = tk.Label(root)
camera_feed.grid(row=1, column=0, columnspan=5)
cap = cv2.VideoCapture(0)

Kemudian, buat fungsi yang terus memperbarui feed kamera yang ditampilkan di tkinter jendela.

defupdate_camera_feed():
if update_camera:
ifnot video_writer:
 ret, frame = cap.read()
if ret:
 frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 img = Image.fromarray(frame)
 photo = ImageTk.PhotoImage(image=img)
 camera_feed.config(image=photo)
 camera_feed.image = photo


 root.after(10, update_camera_feed)
update_camera_feed()

Akhirnya, mulai yang utama tkinter lingkaran peristiwa.

root.mainloop()

Loop ini bertanggung jawab untuk menangani interaksi pengguna.

Menguji Fitur Aplikasi

Video ini menunjukkan berbagai fitur aplikasi:

Mengasah Keterampilan Python Anda Dengan OpenCV

OpenCV mendominasi dalam hal visi komputer. Ia bekerja dengan banyak perpustakaan berbeda yang memungkinkan Anda membuat banyak proyek keren. Anda dapat menggunakannya dengan Python untuk melatih dan mempertajam keterampilan pemrograman Anda.