Update pages/Data Collection.py

pages/Data Collection.py

@@ -915,13 +915,369 @@ def image_details_page():
 # Unstructured Data - Video Page
 def video_details_page():
     st.title("Unstructured Data - Video Details")
-    st.markdown("""
-    **Videos** are sequences of images with temporal data.
+   
+
+        # Title
+        st.markdown("""
+        <h1 style='text-align: center; color: #FF0000;'>Understanding Video and Frame Rates</h1>",
+        unsafe_allow_html=True
+        """)
+)        
+        # Definition of Video
+        st.markdown("""
+        "<h3 style='text-align: center; color: #FF0000;'>What is video?</h3>",
+        unsafe_allow_html=True       
+        """)
+            
+        st.write("""
+        A **video** is made up of a series of images called frames. These frames are shown one after another very quickly, 
+        giving the impression of continuous motion. For example, if we have a sequence of images I1, I2, I3, ..., In, 
+        the transition between them happens so fast that our eyes can't notice the individual images. 
+        This fast switching between frames is what creates a video.
+        The smoothness of a video depends on how many frames are shown per second, measured in frames per second (fps):
+        - **30 fps**: 30 frames are displayed every second, which gives decent smoothness.
+        - **60 fps**: 60 frames are displayed every second, making the video smoother.
+        The higher the number of frames per second, the smoother the video will look. Fewer frames per second can make the video appear less smooth or choppy.
+        """)
+
+        st.markdown("""
+        "<h3 style='text-align: center; color: #FF0000;'>Understanding Video Processing with OpenCV</h3>",
+        unsafe_allow_html=True       
+        """)
+
+        st.write("""
+        **Load the Video**
+        - OpenCV uses `cv2.VideoCapture()` to load a video file. This function takes the file path of the video and opens it so that we can work with it.
+        
+        **Read Frames**
+        -To process the video, we read each individual frame. OpenCV provides a loop to go through every frame in the video. Inside the loop, the `read()` function grabs each frame until the video reaches the end.
+        
+        **Display Frames**
+        -To simulate video playback, OpenCV uses `cv2.imshow()` to display each frame one by one. This function shows the images in a sequence, making it look like the video is playing.
+        
+        **Exit Playback**
+        -You can exit the playback at any time by pressing a key. A common practice is to check if a specific key (like 'q') is pressed during the playback. If the key is detected, the video stops, and the program ends the loop.
+        """)
+        
+        st.code("""
+            # Reading the video
+    
+            vid = cv2.VideoCapture("Here give the path of the vedio")
+            
+            # Dividing the video into frames and looping each and very frame by suing while loop as we dont how many frames 
+            
+            while True:
+                succ,img = vid.read()
+                
+                if succ == False:    # here if the frame doesnot exist break
+                    break
+                            
+                cv2.imshow("Window name",img)  # display the video 
+                 
+                if cv2.waitKey(1)& 255 == ord("q"): # to interupt the vedio or to come out of video in the middle use ascii value
+                    break
+                    
+            cv2.destroyAllWindows()   # removing all the tempory memory RAM
+        """, language = "python")
+
+        
+        # Use st.markdown to display the explanation
+
+        st.markdown("""
+            "<h3 style='text-align: center; color: #FF0000;'>Understanding `vid.read()`</h3>",
+        unsafe_allow_html=True       
+        """)
+
+        st.markdown("""        
+        - `vid.read()` is used to grab one frame (image) at a time from a video.
+        - It gives back two things:
+          1. **`succ`**: A `True` or `False` value.
+             - **`True`** means the frame was successfully loaded.
+             - **`False`** means the frame could not be loaded (usually because the video has ended).
+          2. **`img`**: The actual frame (image) from the video, which is in the form of a NumPy array. This image can then be processed just like any regular picture.
+        """)
+
+        st.markdown("""
+        "<h3 style='text-align: center; color: #FF0000;'>Understanding `cv2.waitkey()`</h3>",
+        unsafe_allow_html=True       
+        """)
+
+        st.markdown("""
+
+        - **`cv2.waitKey(1)`**:
+          - This function waits for a key to be pressed for 1 millisecond.
+          - If a key is pressed, it returns the code of that key. If no key is pressed, it returns `-1`.
+        
+        - **`& 255`**:
+          - This part ensures the key code is correctly interpreted across different systems.
+          - It keeps only the last 8 bits of the code (the actual key code).
+        
+        - **`ord('q')`**:
+          - This gets the ASCII value of the letter `'q'`.
+          - The ASCII value for `'q'` is 113.
+          - This is used to check if the user pressed the `'q'` key to stop the program.
+        
+        """)
+
+        st.code("""
+        if cv2.waitKey(1)& 255 == ord("q"):
+            break
+        """)
+
+        st.markdown("""
+        "<h3 style='text-align: center; color: #FF0000;'>Converting BGR Video to Grayscale
+        </h3>",
+        unsafe_allow_html=True       
+        """)
+
+        
+
+        # Use st.markdown to display the explanation
+        st.markdown("""        
+        You can process video frames one by one and convert them as needed. In this example, we will:
+        
+        - Convert each frame of a video from BGR (Blue, Green, Red) color format to grayscale (a black-and-white image).
+        - Display both the original video frames and the grayscale frames side by side.
+        """)
+
+
+        # Use st.code to display the OpenCV code
+        st.code("""
+        import cv2
+        
+        # Load the video
+        vid = cv2.VideoCapture("path of the video")
+        
+        while True:
+            succ, img = vid.read()  # Reading the video
+        
+            # Dividing the video into frames and looping through each frame as we don't know how many frames
+            if succ == False:  # If the frame does not exist, break
+                break
+        
+            img1 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # Converting BGR image to Grayscale
+        
+            cv2.imshow("video_color", img)  # Display the original video
+        
+            cv2.imshow("video_gray", img1)  # Display the grayscale video
+        
+            if cv2.waitKey(1) & 255 == ord("q"):  # To interrupt the video or stop in the middle using ASCII value
+                break
+        
+        cv2.destroyAllWindows()  # Removing all the temporary memory (RAM)
+        """, language="python")
+        
+        st.markdown("""
+        "<h3 style='text-align: center; color: #FF0000;'>Splitting video into 3 Different channels (B,G,R)
+        </h3>",
+        unsafe_allow_html=True       
+        """)
+
+
+        # Use st.markdown to display the explanation
+        st.markdown("""        
+        Each frame of a colored video consists of three channels: Blue, Green, and Red (BGR). In this example, we will:
+        
+        - Split each frame of the video into separate Blue, Green, and Red color channels.
+        - Display the original video alongside each individual color channel.
+        """)
+        
+        # Use st.code to display the OpenCV code
+        st.code("""
+        import cv2
+        import numpy as np
+        
+        # Load the video
+        vid = cv2.VideoCapture("path of the video")
+        
+        while True:
+            succ, img = vid.read()
+            
+            if succ == False:
+                break
+            
+            # Split the image into Blue, Green, and Red channels
+            b, g, r = cv2.split(img)
+            z = np.zeros(b.shape, dtype=np.uint8)  # Create a blank channel
+            
+            # Convert the image to grayscale
+            img1 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+                
+            # Display the individual color channels
+            cv2.imshow("bluechannel", cv2.merge([b, z, z]))
+            cv2.imshow("green_channel", cv2.merge([z, g, z]))
+            cv2.imshow("red_channel", cv2.merge([z, z, r]))
+            
+            # Display the grayscale video
+            cv2.imshow("video_gray", img1)
+            
+            if cv2.waitKey(100) & 255 == ord("q"):
+                break
+                
+        cv2.destroyAllWindows()  # Remove temporary windows
+        """, language="python")
+             
+
+        st.markdown("""
+        "<h3 style='text-align: center; color: #ffa500;'>Live Streaming with Webcam
+        </h3>",
+        unsafe_allow_html=True       
+        """)
+
+        # Display the explanation in markdown
+        st.markdown("""
+        
+        OpenCV allows you to use your webcam for live video streaming. The `cv2.VideoCapture()` function is used to activate the webcam. Here's how it works:
+        
+        - `cv2.VideoCapture(0)`: The `0` tells OpenCV to use the default webcam on your computer. If you have multiple cameras, you can use other numbers (like 1, 2) to access those cameras.
+        - This function establishes a connection with the webcam and begins capturing video frames in real time.
+        
+        The following example demonstrates how to:
+        - Activate the webcam.
+        - Display the live stream.
+        - Close the webcam window by pressing the 'p' key.
+        """)
+        
+        # Display the OpenCV code
+        st.code("""
+        import cv2
+        
+        # Capture video from the default webcam (ID = 0)
+        vid = cv2.VideoCapture(0)
+        
+        while True:
+            suc, img = vid.read()
+        
+            if suc == False:
+                print("Web Camera is not working")
+                break
+        
+            cv2.imshow("live stream", img)
+        
+            # Exit the loop when 'p' key is pressed
+            if cv2.waitKey(1) & 255 == ord('p'):
+                break
+        
+        cv2.destroyAllWindows()
+        """, language="python")
+
+        st.markdown("""
+        "<h3 style='text-align: center; color: #ffa500;'>Dual Webcam Stream `Color vs Grayscale Capture`
+        </h3>",
+        unsafe_allow_html=True       
+        """)
+
+        st.markdown("""
+        # Opening Two Webcams: Original and Grayscale Video
+        - 1. The first webcam displays the original video feed from the camera.
+        - 2. The second webcam shows the same video feed, but converted to grayscale, where the color information is removed, leaving only varying shades of gray.
+        """)
+
+        st.code("""
+        vid = cv2.VideoCapture(0) # default id = 0
+
+
+        while True:
+            suc,img=vid.read()
+            
+            if suc == False:
+                print("Web Camera is not working")
+                break
+                
+            img1 = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+                
+            cv2.imshow("live stream",img)              # orginal stream
+            cv2.imshow("Grayscale live stream",img1)   # Gray Scale stream
+            
+            if cv2.waitKey(1) & (255) == ord("q"):
+                break 
+                
+        cv2.destroyAllWindows()
+                """)
+        st.markdown("""
+        "<h3 style='text-align: center; color: #ffa500;'> Webcam Stream with RGB Channel Separation
+        </h3>",
+        unsafe_allow_html=True       
+        """)
+
+
+        st.markdown("""
+        # Split the Image into RGB Channels:
+        - The image captured by the webcam is divided into three parts: Red, Green, and Blue. This is done using `cv2.split()`
+        # Create Separate Channel Images:
+        - The separate Red, Green, and Blue images are then combined back into three full-color images using `cv2.merge()`.
+        - This lets us see each color channel on its own, but in full color.
+        """)
+
+        st.code("""
+        vid = cv2.VideoCapture(0) # default id = 0
+
+
+        while True:
+            suc,img=vid.read()
+            
+            if suc == False:
+                print("Web Camera is not working")
+                break
+                
+            b,g,r=cv2.split(img)
+            z = np.zeros(b.shape,dtype=np.uint8)
+        
+                
+            cv2.imshow("live stream",img)
+            cv2.imshow("livestream1",cv2.merge([b,z,z]))   # Blue channel
+            cv2.imshow("livestream2",cv2.merge([z,g,z]))   # Green channel
+            cv2.imshow("livestream3",cv2.merge([z,z,r]))   # Red channel
+        
+        
+            
+            if cv2.waitKey(1) & (255) == ord("q"):
+                break 
+                
+        cv2.destroyAllWindows()
+        """)
+
+        st.markdown("""
+        "<h3 style='text-align: center; color: #ffa500;'>Webcam Frame Capture and Save
+        </h3>",
+        unsafe_allow_html=True       
+        """)
+
+
+        st.markdown("""
+        - **Activate Webcam**: The webcam is activated automatically when the application starts.
+        - **Capture Frames**: Press the 's' key to capture and save the current frame to the 'captured_frames' folder.
+        - **Stop Webcam Feed**: Press the 'p' key to stop the webcam and close the application.
+        """)
+
+
+        st.code("""
+        vid = cv2.VideoCapture(0) # default id = 0
+        c=0
+        
+        while True:
+            suc,img=vid.read()
+            
+            if suc == False:
+                print("Web Camera is not working")
+                break
+                
+            cv2.imshow("video",img)
+            
+            if cv2.waitKey(1)& (255) == ord("s"):
+                cv2.imwrite(r"C:\Users\lenovo\Desktop\Hari\{}.jpg".format(c),img)  #path to save the images
+                print("image have been captured")
+                c+=1
+                
+            if cv2.waitKey(1)& (255) == ord("q"):
+                break
+                
+        
+        cv2.destroyAllWindows()        
+        """)
+
+
 
-    - Formats include MP4, AVI, MKV, etc.
-    - Libraries like OpenCV and MoviePy are used for video processing.
-    """)
-    st.code('import cv2\nvideo = cv2.VideoCapture("file.mp4")', language="python")
 
     if st.button("Back to Home"):
         st.session_state['page'] = "home"