import streamlit as st 
import pandas as pd 

st.subheader(":red[**Video Capture -**]")
st.write("Video capture is the process of accessing and reading video streams (e.g., from a camera or a video file) in a program. Here's a step-by-step explanation of how video capture works, primarily using OpenCV, a popular library for computer vision tasks in Python.")

st.write("**Import Necessary Libraries**")
st.write("To handle video capture, you need a library like OpenCV. Begin by importing it:")
code="""
import numpy as np
import cv2
"""
st.code(code,language="python")

st.write(":blue[**1. Initialize the Video Capture**]")
code="""
vid = cv2.VideoCapture(0)  # Use path for a video file or 0 for the default webcam
"""
st.code(code,language="python")

st.write("""
- **cv2.VideoCapture(0):**

    - 0 refers to the default webcam of the system.
    
    - You can replace 0 with 1, 2, etc., for other cameras.
    
    - If you're capturing from a file, provide the file path as a string (e.g., 'video.mp4').
""")

st.write(":blue[**2. Start an Infinite Loop for Frame Capture**]")
code="""
while True:  # This loop keeps running, continuously reading frames from the video source (webcam).
"""
st.code(code,language="python")

st.write(":blue[**3. Read Frames**]")
code="""
succ, img = vid.read()  
"""
st.code(code,language="python")
st.write("""
- vid.read

    - Returns two values:
    
        1.succ: A boolean that is True if the frame is read successfully, False otherwise.
        
        2.img: The captured frame, represented as a NumPy array.
""")

st.write(":blue[**4. Handle Errors**]")
code="""
if succ == False:
    print("camera not working")
    break
"""
st.code(code,language="python")
st.write("""
- If succ is False, it indicates the camera isn't working or the video stream cannot be accessed.
- The loop exits if the camera isn't functioning.
""")

st.write(":blue[**5. Display the Frame**]")
code="""
cv2.imshow("live stream", img)
"""
st.code(code,language="python")
st.write("""
- cv2.imshow():
    - Displays the captured frame (img) in a window titled "live stream."
    - The frame is updated in real time.
""")

st.write(":blue[**6. Exit on Key Press**]")
code="""
if cv2.waitKey(1) & 255 == ord("w"):
    break
"""
st.code(code,language="python")
st.write("""
- **cv2.waitKey(1):**

    - Waits for 1 millisecond for a key press.
    
    - The & 255 ensures compatibility with certain systems where cv2.waitKey can return larger values.
    
- **ord("w"):**

    - Detects if the w key is pressed.
    
    - If pressed, the loop breaks, stopping the video stream.

""")

st.write(":blue[**7. Clean Up Resources**]")
code="""
cv2.destroyAllWindows() #Closes all OpenCV windows that were opened using cv2.imshow().
"""
st.code(code,language="python")

st.write(":blue[**Complete Code with Comments**]")
st.write(":blue[**1.code**]")
code="""
import cv2

# Initialize video capture (0 for default webcam)
vid = cv2.VideoCapture(0)

while True:
    # Capture a frame
    succ, img = vid.read()
    
    # Check if the frame was successfully read
    if not succ:
        print("Camera not working")
        break

    # Display the frame in a window
    cv2.imshow("Live Stream", img)

    # Exit the loop if the 'w' key is pressed
    if cv2.waitKey(1) & 255 == ord("w"):
        break

# Release the camera and close all OpenCV windows
vid.release()
cv2.destroyAllWindows()
"""
st.code(code,language="python")

st.write(":blue[**Enhancements**]")
st.write("**1.Add Frame Processing: Apply transformations like grayscale, edge detection, or resizing before displaying.**")
code="""
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imshow("Grayscale Live Stream", gray_img)
"""
st.code(code,language="python")

st.write("**2.Save Frames: Capture and save an image when a specific key (e.g., s) is pressed.**")
code="""
if cv2.waitKey(1) & 255 == ord("s"):
    cv2.imwrite("captured_image.jpg", img)
"""
st.code(code,language="python")

st.write("**3.Handle Multiple Cameras: Use different indices for cv2.VideoCapture() to access other webcams if available.**")
st.write("**4.Real-Time FPS Display: Measure and display the frames per second (FPS) on the live stream.**")


st.write(":blue[**2.code**]")
code="""
import cv2
import numpy as np

# Initialize the video capture (0 for default webcam)
vid = cv2.VideoCapture(0)

while True:
    # Capture frame
    succ, img = vid.read()
    if not succ:
        print("Camera not working")
        break

    # Split the channels
    b, g, r = cv2.split(img)
    
    # Create a black canvas for channel visualization
    z = np.zeros(b.shape, dtype=np.uint8)

    # Display the original and individual color channels
    cv2.imshow("live stream1", img)                     # Original video frame
    cv2.imshow("live stream2", cv2.merge([b, z, z]))    # Blue channel
    cv2.imshow("live stream3", cv2.merge([z, g, z]))    # Green channel
    cv2.imshow("live stream4", cv2.merge([z, z, r]))    # Red channel

    # Exit when 'w' is pressed
    if cv2.waitKey(1) & 255 == ord("w"):
        break

# Release resources and close windows
vid.release()
cv2.destroyAllWindows()
"""
st.code(code,language="python")

st.write(":blue[**Code Explanation**]")
st.write("**1. Video Capture Initialization**")
code="""
vid = cv2.VideoCapture(0)  # Access the default webcam (ID = 0)
"""
st.code(code,language="python")
st.write("""
- cv2.VideoCapture(0) initializes the video capture object using the system's default webcam.

- Replace 0 with a file path (e.g., 'video.mp4') to process a saved video.
""")

st.write("**2. Read Frames in a Loop**")
code="""
while True:
    succ, img = vid.read()
    if succ == False:
        print("camera not working")
        break
"""
st.code(code,language="python")
st.write("""
- The loop runs continuously, capturing video frames in real-time.

- succ: A boolean indicating whether a frame was captured successfully.

- img: The captured frame as a NumPy array.

If the camera isn't working or a frame cannot be captured, the loop exits.
""")

st.write("**3. Split Channels**")
code="""
b, g, r = cv2.split(img)
"""
st.code(code,language="python")
st.write("""
- cv2.split(img) decomposes the frame into its three color channels:
    - b: Blue channel.
    - g: Green channel.
    - r: Red channel.
""")

st.write("**4. Create a Black Canvas for Channel Visualization**")
code="""
z = np.zeros(b.shape, dtype=np.uint8)
"""
st.code(code,language="python")
st.write("""
- np.zeros(b.shape, dtype=np.uint8) creates a black canvas of the same size as the frame's blue channel.

- This black canvas is used to replace other color channels when displaying a single channel.
""")

st.write("**5. Display Original and Channel-Specific Streams**")
code="""
cv2.imshow("live stream1", img)                     # Original video frame
cv2.imshow("live stream2", cv2.merge([b, z, z]))    # Blue channel
cv2.imshow("live stream3", cv2.merge([z, g, z]))    # Green channel
cv2.imshow("live stream4", cv2.merge([z, z, r]))    # Red channel
"""
st.code(code,language="python")
st.write("""
1.cv2.imshow() displays the frames in separate windows:

- live stream1: The original frame.

- live stream2: The blue channel, visualized by merging it with two black channels.

- live stream3: The green channel, visualized similarly.

- live stream4: The red channel.

2.cv2.merge([channel1, channel2, channel3]) combines the individual channels to create a 3-channel image.
""")

st.write("**6. Exit on Key Press**")
code="""
if cv2.waitKey(1) & 255 == ord("w"):
    break
"""
st.code(code,language="python")
st.write("""
- Waits for 1 millisecond to check if the w key is pressed.

- If w is detected, the loop breaks, stopping the video feed.
""")

st.write("**7. Clean Up Resources**")
code="""
import cv2
import os

# Create a directory to save images
os.makedirs("/home/user/han_sign", exist_ok=True)

# Initialize video capture
vid = cv2.VideoCapture(0)

# Initialize counter for image filenames
c = 0

try:
    while True:
        # Capture a frame
        suc, img = vid.read()
        if not suc:
            print("Camera not working")
            break

        # Display the live stream
        cv2.putText(img, "Press 's' to save, 'c' to exit", (10, 30), 
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
        cv2.imshow("Live Stream", img)

        # Save the image when 's' key is pressed
        if cv2.waitKey(1) & 255 == ord("s"):
            cv2.imwrite(f"/home/user/han_sign/{c}.jpg", img)
            print(f"Image {c} has been captured")
            c += 1

        # Exit when 'c' key is pressed
        if cv2.waitKey(1) & 255 == ord("c"):
            break
finally:
    # Release resources and close windows
    vid.release()
    cv2.destroyAllWindows()
    print(f"Total images captured: {c}")
"""
st.code(code,language="python")

st.write("**Code Explanation**")
st.write(":blue[**1. Create a Directory**]")
code="""
import os
os.makedirs("/home/user/han_sign)
"""
st.code(code,language="python")
st.write("""
- os.makedirs(path):

    - Creates a directory at the specified path.
    
    - In this case, a folder named han_sign is created in the Downloads directory.

""")

st.write(":blue[**2. Initialize Video Capture**]")
code="""
vid = cv2.VideoCapture(0)
"""
st.code(code,language="python")
st.write("""
- Initializes video capture using the default webcam (index 0).
- Replace 0 with a file path to use a video file instead.
""")

st.write(":blue[**3. Initialize Counter**]")
code="""
c = 0 #This counter is used to assign unique filenames to the captured images (e.g., 0.jpg, 1.jpg, ...).
"""
st.code(code,language="python")

st.write(":blue[**4. Start an Infinite Loop for Video Capture**]")
code="""
while True:
    suc, img = vid.read()
    if suc == False:
        print("camera not working")
        break

"""
st.code(code,language="python")
st.write("""
- Captures frames from the video stream in real time.

- suc is True if the frame is successfully captured.

- If suc is False, the loop exits, indicating a problem with the camera.
""")

st.write(":blue[**5. Save Images on Key Press**]")
code="""
if cv2.waitKey(1) & 255 == ord("s"):
    cv2.imwrite("/home/user/han_sign"/{}.jpg".format(c), img)
    print("image have been captured")
    c += 1
"""
st.code(code,language="python")
st.write("""
- cv2.waitKey(1) & 255 == ord("s"):

    - Detects if the s key is pressed.
    
- cv2.imwrite(path, img):

    - Saves the current frame (img) as a .jpg file in the specified folder.
    
    - The filename is determined by the counter c.
    
-c += 1:

Increments the counter to ensure the next image has a unique filename.

""")

st.write(":blue[**6. Exit on Key Press**]")
code="""
if cv2.waitKey(1) & 255 == ord("c"):  #Detects if the c key is pressed, which exits the loop and stops the program.
    break
"""
st.code(code,language="python")

st.write(":blue[**7. Release Resources**]")
code="""
cv2.destroyAllWindows() #Closes all OpenCV windows and releases resources.
"""
st.code(code,language="python")