पायथन का उपयोग करके कैमरा एप्लिकेशन कैसे बनाएं

चाहे आप एक आकर्षक पायथन परियोजना पर काम करना चाहते हों या पायथन प्रोग्रामिंग के विभिन्न पहलुओं का पता लगाना चाहते हों, एक कैमरा एप्लिकेशन का निर्माण इस उद्देश्य को पूरा करता है। इसमें पायथन प्रोग्रामिंग के विभिन्न पहलुओं का संयोजन शामिल है, जैसे ग्राफिकल यूजर इंटरफेस (जीयूआई) विकास, छवि और वीडियो प्रोसेसिंग, और मल्टी-थ्रेडिंग।

साथ ही, इस तरह की व्यावहारिक चुनौतियों को हल करने से आपकी समस्या-समाधान कौशल को तेज करने में मदद मिलती है। ये कौशल किसी भी प्रोग्रामिंग प्रयास में मूल्यवान हैं।

अपना वातावरण स्थापित करना

से शुरू एक नया आभासी वातावरण बनाना. यह आपके प्रोजेक्ट को अलग कर देगा और सुनिश्चित करेगा कि आपके द्वारा इंस्टॉल किए गए पैकेजों के विभिन्न संस्करणों के बीच कोई विरोध नहीं है। फिर, यह टर्मिनल कमांड चलाएँ:

pip install opencv-python pillow

यह कमांड इंस्टॉल करेगा ओपनसीवी पुस्तकालय और जनहित याचिका (पायथन इमेजिंग लाइब्रेरी) आपके आभासी वातावरण में। आप कंप्यूटर विज़न कार्यक्षमता के लिए OpenCV और छवि हेरफेर के लिए PIL का उपयोग करेंगे।

इस परियोजना का पूर्ण स्रोत कोड a में उपलब्ध है गिटहब रिपॉजिटरी.

आवश्यक पुस्तकालय आयात करना

एक बार जब आप इन पुस्तकालयों को स्थापित कर लेते हैं, तो आप उन्हें पायथन के मानक पुस्तकालय से अन्य आवश्यक मॉड्यूल के साथ आयात कर सकते हैं:

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

आप करेंगे उपयोग tkinter एक ग्राफिकल यूजर इंटरफ़ेस बनाने के लिए आपके एप्लिकेशन और ओएस, थ्रेडिंग और टाइम मॉड्यूल के लिए उनकी संबंधित कार्यक्षमता के लिए। अपने कुछ कोड को थ्रेड्स में अलग करके, आप ऐसा करेंगे इसे समवर्ती रूप से चलाने में सक्षम करें.

एक गैलरी निर्देशिका बनाना और वैश्विक चर और झंडे को परिभाषित करना

कैप्चर की गई छवियों और रिकॉर्ड किए गए वीडियो को संग्रहीत करने के लिए एक निर्देशिका बनाएं। यह चरण सुनिश्चित करेगा कि वीडियो कैप्चर या रिकॉर्ड करने के लिए आगे बढ़ने से पहले निर्देशिका मौजूद है।

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

फिर परिभाषित करें छवि_थंबनेल और वीडियो थंबनेल चर। ये गैलरी में छवियों और वीडियो के थंबनेल संग्रहीत करेंगे।

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

अपडेट_कैमरा फ़्लैग कैमरा फ़ीड अपडेट को नियंत्रित करेगा।

कैमरा फ़ीड से छवियाँ कैप्चर करना

एक फ़ंक्शन परिभाषित करें जो कैमरा फ़ीड से एक छवि कैप्चर करने के लिए OpenCV का उपयोग करेगा। फिर इसे कैमरे से एक फ्रेम प्राप्त करना चाहिए, इसे इसमें सहेजना चाहिए गैलरी निर्देशिका, और इसका उपयोग करके प्रदर्शित करें show_image.

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)

वीडियो रिकॉर्डिंग प्रारंभ करना और बंद करना

इससे पहले कि आप कोई वीडियो प्रदर्शित करें, आपको उसे बनाने का एक तरीका चाहिए। इसे प्राप्त करने के लिए, एक फ़ंक्शन बनाएं जो वीडियो रिकॉर्डिंग प्रक्रिया शुरू करता है जब उपयोगकर्ता वीडियो कैप्चर करना चाहता है। फ़ंक्शन को भी अक्षम करना चाहिए अभिलेख बटन (एक साथ कई रिकॉर्डिंग को रोकने के लिए) और सक्षम करें रिकॉर्डिंग बंद करें बटन। यह इंगित करता है कि रिकॉर्डिंग प्रगति पर है.

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()

फिर, एक फ़ंक्शन बनाएं जो वीडियो रिकॉर्डिंग बंद कर दे और वीडियो लेखक को रिलीज़ कर दे।

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)

यह फ़ंक्शन यूआई को सक्षम करके अपडेट भी करता है अभिलेख बटन और अक्षम करना रिकॉर्डिंग बंद करें बटन। यह इंगित करता है कि रिकॉर्डिंग बंद हो गई है.

वीडियो रिकॉर्ड करना और प्रदर्शित करना

एक फ़ंक्शन बनाएं जो लगातार कैमरे से फ़्रेम कैप्चर करेगा, उन्हें संसाधित करेगा, और उन्हें कैमरा फ़ीड के रूप में जीयूआई पर प्रदर्शित करेगा। ऐसा तब तक करना चाहिए जब तक कि रिकॉर्डिंग बंद करें बटन दबाया जाता है.

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) 

फ़ंक्शन रिकॉर्डिंग शुरू होने के बाद से बीते समय की भी गणना करता है और इसे वीडियो फ्रेम पर प्रदर्शित करता है।

कैप्चर की गई छवियाँ और वीडियो प्रदर्शित करना

अब जब आपने तस्वीरें खींच ली हैं और वीडियो रिकॉर्ड कर लिया है, तो आपको उन्हें प्रदर्शित करने का एक तरीका चाहिए।

छवियां प्रदर्शित करने के लिए, एक फ़ंक्शन बनाएं जो एक छवि खोलता है और इसे कैमरा फ़ीड में प्रदर्शित करता है। का उपयोग करके छवि को खोलकर इसे प्राप्त किया जाता है जनहित याचिका, फिर इसे एक प्रारूप में परिवर्तित करना tkinter प्रदर्शित कर सकते हैं, और अंत में नई छवि के साथ कैमरा फ़ीड विजेट को अपडेट कर सकते हैं।

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

कैप्चर किए गए वीडियो को प्रदर्शित करने के लिए, एक फ़ंक्शन बनाएं जो एक वीडियो प्लेयर विंडो खोलता है जहां उपयोगकर्ता रिकॉर्ड किए गए वीडियो देख सकता है। वीडियो चलने के दौरान यह कैमरा फ़ीड अपडेट को भी रोक देता है।

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)

कैमरा फ़ीड अपडेट को रोकने से देखने का सहज अनुभव सुनिश्चित होता है।

वीडियो थंबनेल बनाना और गैलरी खोलना

एक फ़ंक्शन बनाएं जो किसी दिए गए वीडियो के लिए थंबनेल छवि उत्पन्न करेगा। इससे उपयोगकर्ताओं के लिए रुचि के वीडियो की पहचान करना आसान हो जाएगा।

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

इसके बाद, एक फ़ंक्शन बनाएं जो उपयोगकर्ता द्वारा गैलरी विंडो में वीडियो के थंबनेल पर क्लिक करने पर वीडियो चलाता है:

defplay_video_from_thumbnail(video_path):
 play_video(video_path)

फिर एक फ़ंक्शन बनाएं जो एक नई विंडो बनाता है जहां उपयोगकर्ता कैप्चर की गई छवियों और वीडियो को देख सकता है।

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()

थंबनेल छवियों और वीडियो दोनों के लिए बनाए जाते हैं। इसका मतलब है कि आप पूर्ण आकार की छवि देखने या वीडियो चलाने के लिए उन पर क्लिक कर सकते हैं।

आपके एप्लिकेशन के लिए मुख्य उपयोगकर्ता इंटरफ़ेस बनाना

मुख्य बनाकर प्रारंभ करें tkinter एप्लिकेशन विंडो खोलें और फिर इसे एक शीर्षक दें।

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

फिर आवश्यक वेरिएबल प्रारंभ करें।

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

फिर विभिन्न कार्यों के लिए बटन बनाएं।

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)

मुख्य विंडो में बटनों को व्यवस्थित करने के लिए ग्रिड लेआउट मैनेजर का उपयोग करें।

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)

कैमरा फ़ीड प्रदर्शित करने और उसे प्रारंभ करने के लिए एक विजेट बनाएं।

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

फिर, एक ऐसा फ़ंक्शन बनाएं जो इसमें प्रदर्शित कैमरा फ़ीड को लगातार अपडेट करता रहे tkinter खिड़की।

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()

अंत में, मुख्य प्रारंभ करें tkinter इवेंट लूप.

root.mainloop()

यह लूप उपयोगकर्ता इंटरैक्शन को संभालने के लिए ज़िम्मेदार है।

ऐप सुविधाओं का परीक्षण

यह वीडियो ऐप की विभिन्न विशेषताओं को प्रदर्शित करता है:

OpenCV के साथ अपने पायथन कौशल को तेज़ करना

जब कंप्यूटर विज़न की बात आती है तो OpenCV हावी हो जाता है। यह कई अलग-अलग पुस्तकालयों के साथ काम करता है जिससे आप कई बेहतरीन प्रोजेक्ट बना सकते हैं। आप अपने प्रोग्रामिंग कौशल का अभ्यास करने और उसे तेज करने के लिए पायथन के साथ इसका उपयोग कर सकते हैं।