Menambah Ciri Kamera Dikawal Pengguna Pada Jam GUI Python Kami

Dalam tutorial kami sebelum ini, kami membina jam GUI yang boleh disesuaikan menggunakan Python dan Tkinter. Mari kita melangkah lebih jauh dengan menambahkan ciri kamera yang membolehkan pengguna menangkap dan menyimpan imej atas permintaan. Projek ini akan memperkenalkan anda untuk bekerja dengan input kamera dalam Python, meningkatkan kemahiran anda dalam pembangunan GUI dan pengendalian fail.

Menyediakan Persekitaran

Sebelum kami memulakan, pastikan anda telah memasang perpustakaan yang diperlukan. Kami akan menggunakan OpenCV untuk pengendalian kamera. Pasang menggunakan pip:

pip install opencv-python

Seterusnya, kita akan Pasang Bantal menggunakan pip.

pip install Pillow

Sekarang kami telah memasang semua kebergantungan, kami boleh menambah kamera. Kami akan mencipta dua jenis kamera: kamera biasa dan kamera tersembunyi di sebalik klik.

Kekal bersama saya.

    import cv2
    from PIL import Image, ImageTk
    import os
    from datetime import datetime

Mencipta Fungsi Kamera

Jom tambah fungsi untuk mengendalikan tangkapan kamera:

    def capture_image():
        # Initialize the camera
        cap = cv2.VideoCapture(0)

        if not cap.isOpened():
            print("Error: Could not open camera.")
            return

        # Capture a frame
        ret, frame = cap.read()

        if not ret:
            print("Error: Could not capture image.")
            cap.release()
            return

        # Create a directory to store images if it doesn't exist
        if not os.path.exists("captured_images"):
            os.makedirs("captured_images")

        # Generate a unique filename using timestamp
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"captured_images/image_{timestamp}.png"

        # Save the image
        cv2.imwrite(filename, frame)
        print(f"Image saved as {filename}")

        # Release the camera
        cap.release()

        # Display the captured image
        display_image(filename)

Mari kita pecahkan fungsi capture_image() dengan cara yang mudah difahami oleh pemula. Kami akan meneliti setiap bahagian langkah demi langkah, menerangkan perkara yang berlaku dan sebabnya.

`def capture_image()`

Barisan ini mencipta fungsi baharu yang dipanggil capture_image(). Fikirkan fungsi sebagai satu set arahan yang boleh kita gunakan pada bila-bila masa kita ingin mengambil gambar.

`cap = cv2.VideoCapture(0)`

Di sini, kami sedang menyediakan kamera kami. Bayangkan anda menghidupkan kamera digital:

• cv2 ialah alat (perpustakaan) yang membantu kami bekerja dengan kamera dan imej dalam Python.
• VideoCapture(0) adalah seperti menekan butang kuasa kamera. 0 bermaksud "gunakan kamera pertama yang anda temui" (biasanya kamera web terbina dalam pada komputer riba).
• Kami memanggil topi persediaan kamera ini (singkatan untuk menangkap), jadi kami boleh merujuknya kemudian.

    if not cap.isOpened():
        print("Error: Could not open camera.")
        return

Bahagian ini menyemak sama ada kamera dihidupkan dengan betul:

• jika tidak cap.isOpened(): bertanya, "Adakah kamera gagal dihidupkan?"
• Jika gagal, kami mencetak mesej ralat.

• kembali bermaksud "berhenti di sini dan keluar dari fungsi" jika ada masalah.

  ret, bingkai = cap.read()

Sekarang kami mengambil gambar sebenar:

cap.read() adalah seperti menekan butang pengatup pada kamera.

Ia memberi kita dua perkara:

• ret: Jawapan ya/tidak kepada "Adakah gambar itu berjaya diambil?"
• bingkai: Gambar sebenar, jika ia diambil.

    if not ret:
        print("Error: Could not capture image.")
        cap.release()
        return

Ini menyemak sama ada gambar berjaya diambil:

• Jika ret adalah "tidak" (yang bermaksud gambar gagal), kami:

• Cetak mesej ralat.

• cap.release() mematikan kamera.

• kembali keluar dari fungsi.
  

    if not os.path.exists("captured_images"):
        os.makedirs("captured_images")

Bahagian ini mencipta folder khas untuk menyimpan gambar kami:

if not os.path.exists("captured_images"):` checks if a folder named "captured_images" already exists.

• Jika ia tidak wujud, os.makedirs("captured_images") mencipta folder ini.
• Ia seperti mencipta album baharu untuk menyimpan foto anda.

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"captured_images/image_{timestamp}.png"

Di sini, kami sedang mencipta nama unik untuk gambar kami:

datetime.now() mendapat tarikh dan masa semasa.
.strftime("%Y%m%d_%H%M%S") format kali ini menjadi rentetan seperti "20240628_152059" (Tahun-Bulan-Hari_JamMinuteSecond).

• Kami menggunakan ini untuk mencipta nama fail seperti "captured_images/image_20240628_152059.png".
• Ini memastikan setiap gambar mempunyai nama unik berdasarkan masa ia diambil.

    cv2.imwrite(filename, frame)
    print(f"Image saved as {filename}")

Kini kami sedang menyimpan gambar.

v2.imwrite(nama fail, bingkai) menyimpan gambar (bingkai) kami dengan nama fail yang kami buat.
Kami kemudian mencetak mesej yang menyatakan tempat imej itu disimpan.

`cap.release()`

Barisan ini mematikan kamera, seperti menekan butang kuasa sekali lagi apabila anda selesai.

`display_image(filename)`

Akhir sekali, kami memanggil fungsi lain untuk menunjukkan gambar yang baru kami ambil pada skrin.
Secara ringkasnya, fungsi ini melakukan perkara berikut.

• Menghidupkan kamera
• Periksa sama ada kamera berfungsi
• Mengambil gambar
• Pastikan gambar berjaya diambil
• Mencipta folder untuk menyimpan gambar jika ia tidak wujud
• Memberi gambar nama unik berdasarkan masa semasa
• Menyimpan gambar dalam folder
• Mematikan kamera

Setiap langkah mempunyai semakan untuk memastikan perkara berfungsi dengan betul dan jika terdapat masalah pada bila-bila masa, fungsi akan berhenti dan memberitahu kami apa yang salah.

Memaparkan Imej Yang Ditangkap

Tambah fungsi untuk memaparkan imej yang ditangkap:

    def display_image(filename):
        # Open the image file
        img = Image.open(filename)

        # Resize the image to fit in the window
        img = img.resize((300, 200), Image.LANCZOS)

        # Convert the image for Tkinter
        photo = ImageTk.PhotoImage(img)

        # Update the image label
        image_label.config(image=photo)
        image_label.image = photo

Mari kita mulakan dengan penjelasan mesra pemula tentang operasi fail dan kemudian menyelami kod tersebut.

Operasi Fail untuk Pemula:

1. Baca:

   • Ini seperti membuka buku dan melihat kandungannya.
   • Dalam pengaturcaraan, membaca fail bermakna mengakses kandungannya tanpa mengubahnya.
   • Contoh: Membuka imej untuk melihatnya.

2. Tulis:

   • This is like writing in a notebook.
   • In programming, writing means adding new content to a file or changing existing content.
   • Example: Saving a new image or modifying an existing one.

3. Execute:

   • This is like following a set of instructions.
   • In programming, executing usually refers to running a program or script.
   • For images, we don't typically "execute" them, but we can process or display them.

Now, let's focus on the display_image(filename) function:

`def display_image(filename)`

This line defines a function named display_image that takes a filename as input. This filename is the path to the image we want to display.

`img = Image.open(filename)`

Here's where we use the "read" operation:

• Image.open() is a function from the PIL (Python Imaging Library) that opens an image file.
• It's like telling the computer, "Please look at this picture for me."
• The opened image is stored in the variable img.

• This operation doesn't change the original file; it allows us to work with its contents.

  img = img.resize((300, 200), Image.LANCZOS)

This line resizes the image:

• img.resize() changes the size of the image.
• (300, 200) sets the new width to 300 pixels and height to 200 pixels.

• Image.LANCZOS is a high-quality resizing method that helps maintain image quality.

  photo = ImageTk.PhotoImage(img)

This line converts the image for use with Tkinter (the GUI library we're using):

• ImageTk.PhotoImage() takes our resized image and converts it into a format that Tkinter can display.
• This converted image is stored in the photo variable.

    image_label.config(image=photo)
    image_label.image = photo

These lines update the GUI to show the image:

• image_label is a Tkinter widget (like a container) that can display images.
• config(image=photo) tells this label to display our processed image.
• image_label.image = photo is a special line that prevents the image from being deleted by Python's garbage collector.

In summary, this function does the following:

1. Opens an image file (read operation).
2. Resize the image to fit nicely in our GUI window.
3. Converts the image to a format our GUI system (Tkinter) can understand.
4. Updates a label in our GUI to display this image.

This process doesn't involve writing to the file or executing it. We're simply reading the image, processing it in memory, and displaying it in our application.

Adding GUI Elements

Update your existing GUI to include a button for image capture and a label to display the image:

# Add this after your existing GUI elements
capture_button = tk.Button(window, text="Capture Image", command=capture_image)
capture_button.pack(anchor='center', pady=5)

image_label = tk.Label(window)
image_label.pack(anchor='center', pady=10)

• Adjusting the Window Size:

You may need to adjust the window size to accommodate the new elements:

window.geometry("350x400")  # Increase the height

• Complete Code:

Here's the complete code incorporating the new camera feature:

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

    window = tk.Tk()
    window.title("Python GUI Clock with Camera")
    window.geometry("350x400")

    is_24_hour = True

    def update_time():
        global is_24_hour
        time_format = '%H:%M:%S' if is_24_hour else '%I:%M:%S %p'
        time_string = strftime(time_format)
        date_string = strftime('%B %d, %Y')
        time_label.config(text=time_string)
        date_label.config(text=date_string)
        time_label.after(1000, update_time)

    def change_color():
        colors = ['black', 'red', 'green', 'blue', 'yellow', 'purple', 'orange']
        current_bg = time_label.cget("background")
        next_color = colors[(colors.index(current_bg) + 1) % len(colors)]
        time_label.config(background=next_color)
        date_label.config(background=next_color)

    def toggle_format():
        global is_24_hour
        is_24_hour = not is_24_hour

    def capture_image():
        cap = cv2.VideoCapture(0)

        if not cap.isOpened():
            print("Error: Could not open camera.")
            return

        ret, frame = cap.read()

        if not ret:
            print("Error: Could not capture image.")
            cap.release()
            return

        if not os.path.exists("captured_images"):
            os.makedirs("captured_images")

        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"captured_images/image_{timestamp}.png"

        cv2.imwrite(filename, frame)
        print(f"Image saved as {filename}")

        cap.release()

        display_image(filename)

    def display_image(filename):
        img = Image.open(filename)
        img = img.resize((300, 200), Image.LANCZOS)
        photo = ImageTk.PhotoImage(img)
        image_label.config(image=photo)
        image_label.image = photo

    time_label = tk.Label(window, font=('calibri', 40, 'bold'), background='black', foreground='white')
    time_label.pack(anchor='center')

    date_label = tk.Label(window, font=('calibri', 24), background='black', foreground='white')
    date_label.pack(anchor='center')

    color_button = tk.Button(window, text="Change Color", command=change_color)
    color_button.pack(anchor='center', pady=5)

    format_button = tk.Button(window, text="Toggle 12/24 Hour", command=toggle_format)
    format_button.pack(anchor='center', pady=5)

    capture_button = tk.Button(window, text="Capture Image", command=capture_image)
    capture_button.pack(anchor='center', pady=5)

    image_label = tk.Label(window)
    image_label.pack(anchor='center', pady=10)

    update_time()
    window.mainloop()

Conclusion

You've now enhanced your GUI clock with a user-controlled camera feature. This addition demonstrates how to integrate hardware interactions into a Python GUI application, handle file operations, and dynamically update the interface.

Always respect user privacy and obtain the necessary permissions when working with camera features in your applications.

Resource

• How to Identify a Phishing Email in 2024
• Build Your First Password Cracker
• Python for Beginners

Atas ialah kandungan terperinci Menambah Ciri Kamera Dikawal Pengguna Pada Jam GUI Python Kami. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!