Update pages/demo.py

pages/demo.py

@@ -1273,6 +1273,367 @@ elif st.session_state.page == "opencv":
 
 
 
+    if st.button('Advanced OPENCV'):
+        navigate_to('advopencv')
+
+
+    if st.button('Back to unstructured data'):
+        navigate_to('unstructured_data')
+
+    if st.button('Back to Data collection'):
+        navigate_to('data_collection')
+    if st.button("Back to Main Page"):
+        navigate_to("main")
+
+
+
+
+
+
+
+
+
+#------------------------------------------------------ ADvanced Opencv ------------------------------------------
+
+
+
+elif st.session_state.page == "advopencv":
+    st.title("Advanced OpenCV Concepts")
+
+    # Section: Converting Image Colors
+    st.header("1. Converting Image Colors with `cv2.cvtColor()`")
+    st.write("""
+    OpenCV allows you to easily convert images between different color spaces using `cv2.cvtColor()`.
+    - Common conversions include:
+      - **BGR to RGB** (used for correct color representation in visualization)
+      - **BGR to Grayscale** (for black-and-white processing)
+    """)
+
+    st.subheader("Example: BGR to RGB Conversion")
+    st.code("""
+import cv2
+img_bgr = cv2.imread("path_to_image.jpg")  # Read image in BGR format
+img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)  # Convert to RGB
+cv2.imshow("RGB Image", img_rgb)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+    """, language="python")
+
+    st.subheader("Example: BGR to Grayscale Conversion")
+    st.code("""
+import cv2
+img_bgr = cv2.imread("path_to_image.jpg")  # Read image in BGR format
+img_gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)  # Convert to Grayscale
+cv2.imshow("Grayscale Image", img_gray)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+    """, language="python")
+
+    st.image(r"image/colortogray.jpg", caption="Color Conversions: BGR to RGB and Grayscale")
+
+    st.markdown("---")
+
+    # Section: Splitting and Merging Channels
+    st.header("2. Splitting and Merging Channels in OpenCV")
+    st.write("""
+    OpenCV allows you to split the three color channels (Blue, Green, Red) and work on them individually. You can later merge them back into an image using `cv2.merge()`.
+    - **Splitting**: Separates the image into its B, G, and R channels.
+    - **Merging**: Combines the B, G, and R channels back into a single image.
+    """)
+
+    st.subheader("Example: Splitting Channels")
+    st.code("""
+import cv2
+img_bgr = cv2.imread("path_to_image.jpg")  # Read image
+b, g, r = cv2.split(img_bgr)  # Split into Blue, Green, and Red channels
+cv2.imshow("Blue Channel", b)
+cv2.imshow("Green Channel", g)
+cv2.imshow("Red Channel", r)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+    """, language="python")
+    st.image(r"image/bgr.png", caption="Splitting and Merging Channels in OpenCV")
+
+    st.subheader("Example: Merging Channels")
+    st.code("""
+import cv2
+img_bgr = cv2.imread("path_to_image.jpg")  # Read image
+b, g, r = cv2.split(img_bgr)  # Split channels
+merged_img = cv2.merge([b, g, r])  # Merge channels back
+cv2.imshow("Merged Image", merged_img)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+    """, language="python")
+
+    st.image(r"image/original.png", caption="Splitting and Merging Channels in OpenCV")
+
+    st.markdown("---")
+    
+
+
+
+
+
+    if st.button('Video in OpenCV'):
+        navigate_to('video')
+    if st.button('Back to unstructured data'):
+        navigate_to('unstructured_data')
+
+    if st.button('Back to Data collection'):
+        navigate_to('data_collection')
+    if st.button("Back to Main Page"):
+        navigate_to("main")
+
+
+
+
+
+
+
+
+
+
+#------------------------------------------------------ Video ------------------------------------------
+elif st.session_state.page == "video":
+
+    st.title("Video Handling with OpenCV")
+
+    # Section 1: Introduction to Video Handling
+    st.header("1. Introduction to Video Handling")
+    st.write("""
+    In OpenCV, videos are treated as a sequence of images called frames. You can process videos using the `cv2.VideoCapture()` class, which allows you to:
+    - Read video files from your system.
+    - Capture live video from a webcam or other video input devices.
+    - Process each frame in the video stream individually.
+    """)
+
+    #st.image("https://via.placeholder.com/600x400.png?text=Video+Frames", caption="Frames in a Video", use_container_width=True)
+
+    st.markdown("---")
+
+    
+
+
+    # Section 2: Reading a Video File
+    st.header("2. Reading a Video File")
+    st.write("""
+    To read a video file, OpenCV uses the `cv2.VideoCapture()` function. It loads the video file and allows you to process each frame sequentially. 
+    The following example demonstrates how to:
+    - Read frames from a video file.
+    - Display the video in a window.
+    """)
+
+    st.subheader("Example: Reading and Displaying a Video")
+    st.code("""
+import cv2
+
+# Open the video file
+video = cv2.VideoCapture("path_to_video.mp4")
+
+
+# Loop to read and display frames
+while True:
+    suc, frame = video.read()  # Read a frame
+    if not suc:
+        print("Video Ended")
+        break
+
+    cv2.imshow("Video Playback", frame)  # Display the frame
+
+    # Break loop on 'q' key press
+    if cv2.waitKey(1) & 255 == ord('q'):
+        break
+
+video.release()  # Release the video file
+cv2.destroyAllWindows()  # Close all OpenCV windows
+    """, language="python")
+
+    #st.image("https://via.placeholder.com/600x400.png?text=Reading+Video", caption="Reading and Displaying a Video File")
+
+    st.markdown("---")
+    st.header("Understanding `cv2.waitKey()` and Key Input")
+    st.write("""
+    The line `if cv2.waitKey(1) & 255 == ord('q'):` is used in OpenCV to handle keyboard input while processing video frames. Here’s a breakdown:
+    - **`cv2.waitKey(1)`**:
+      - Waits for a key press for `1` millisecond.
+      - Returns the ASCII value of the key pressed, or `-1` if no key is pressed.
+    - **`& 255`**:
+      - Masks the higher-order bits to ensure compatibility across systems.
+      - Extracts only the last 8 bits (ASCII value).
+    - **`ord('q')`**:
+      - Provides the ASCII value of the character `'q'`.
+      - The condition checks if the user pressed the `'q'` key to quit the program.
+    """)
+
+    st.subheader("Combined Condition")
+    st.write("""
+    The full condition:
+    ```python
+    if cv2.waitKey(1) & 255 == ord('q'):
+        break
+    ```
+    This checks if the user pressed the `'q'` key during video processing. If true, the loop exits, and the program ends gracefully.
+    """)
+    st.markdown("---")
+
+    # Section 3: Using `cv2.VideoCapture` for Live Capture
+    st.header("3. Capturing Video from Webcam")
+    st.write("""
+    The `cv2.VideoCapture()` function can also be used to capture live video from your webcam or connected camera devices.
+    """)
+
+    st.subheader("Basic Example: Capturing Video from Webcam")
+    st.code("""
+import cv2
+
+# Open video capture (0 for primary webcam)
+video = cv2.VideoCapture(0)
+
+# Loop to read frames
+while True:
+    suc, frame = video.read()  # Read a frame
+    if not suc:
+        break
+    cv2.imshow("Webcam", frame)  # Display the frame
+
+    # Break loop on 'q' key press
+    if cv2.waitKey(1) & 255 == ord('q'):
+        break
+
+video.release()  # Release the video capture object
+cv2.destroyAllWindows()  # Close all OpenCV windows
+    """, language="python")
+
+    #st.image("https://via.placeholder.com/600x400.png?text=Webcam+Capture", caption="Webcam Video Capture Example")
+
+    st.markdown("---")
+
+    # Section 4: Converting Video to Grayscale
+    st.header("4. Processing Video: Converting to Grayscale")
+    st.write("""
+    You can process each frame of the video in real-time. The following example demonstrates how to:
+    - Convert each frame of a video to grayscale.
+    - Display the processed video.
+    """)
+
+    st.subheader("Example: Converting Video to Grayscale")
+    st.code("""
+import cv2
+
+# Open the video file
+video = cv2.VideoCapture("path_to_video.mp4")
+
+# Loop to read and process frames
+while True:
+    suc, frame = video.read()  # Read a frame
+    if not suc:
+        break
+
+    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # Convert frame to grayscale
+    cv2.imshow("Grayscale Video", gray_frame)  # Display the processed frame
+
+    # Break loop on 'q' key press
+    if cv2.waitKey(30) & 255 == ord('q'):
+        break
+
+video.release()  # Release the video file
+cv2.destroyAllWindows()  # Close all OpenCV windows
+    """, language="python")
+
+    #st.image("https://via.placeholder.com/600x400.png?text=Grayscale+Video", caption="Grayscale Video Processing Example")
+
+    st.markdown("---")
+
+    # Section 5: Splitting Channels in a Video Frame
+    st.header("5. Splitting Channels in a Video Frame")
+    st.write("""
+    You can split the three color channels (Blue, Green, and Red) from a video frame and process them individually. This example demonstrates splitting channels and displaying them separately.
+    """)
+
+    st.subheader("Example: Splitting Video Frame Channels")
+    st.code("""
+import cv2
+
+# Open video capture
+video = cv2.VideoCapture("path_to_video.mp4")  # Replace with 0 for webcam
+
+while True:
+    suc, frame = video.read()
+    if not suc:
+        break
+
+    # Split the frame into channels
+    b, g, r = cv2.split(frame)
+
+    # Merge and display individual channels
+    blue_img = cv2.merge([b, g*0, r*0])
+    green_img = cv2.merge([b*0, g, r*0])
+    red_img = cv2.merge([b*0, g*0, r])
+
+    cv2.imshow("Original Frame", frame)
+    cv2.imshow("Blue Channel", blue_img)
+    cv2.imshow("Green Channel", green_img)
+    cv2.imshow("Red Channel", red_img)
+
+    # Break loop on 'q' key press
+    if cv2.waitKey(1) & 255 == ord('q'):
+        break
+
+video.release()
+cv2.destroyAllWindows()
+    """, language="python")
+
+   # st.image("https://via.placeholder.com/600x400.png?text=Splitting+Video+Channels", caption="Splitting Channels from a Video Frame")
+
+    st.markdown("---")
+
+    # Section 6: Saving a Specific Frame
+    st.header("6. Capturing and Saving a Specific Frame")
+    st.write("""
+    Use OpenCV to capture a specific frame from a video and save it as an image file. The following example captures a frame when the 's' key is pressed.
+    """)
+
+    st.subheader("Example: Saving a Frame")
+    st.code("""
+import cv2
+
+video = cv2.VideoCapture("path_to_video.mp4")  # Replace with 0 for webcam
+
+while True:
+    suc, frame = video.read()
+    if not suc:
+        break
+
+    cv2.imshow("Video", frame)
+
+    # Save frame on 's' key press
+    if cv2.waitKey(1) & 255 == ord('s'):
+        cv2.imwrite("captured_frame.jpg", frame)
+        print("Frame saved as captured_frame.jpg")
+
+    # Break loop on 'q' key press
+    if cv2.waitKey(1) & 255 == ord('q'):
+        break
+
+video.release()
+cv2.destroyAllWindows()
+    """, language="python")
+
+    #st.image("https://via.placeholder.com/600x400.png?text=Capture+and+Save+Frame", caption="Capturing and Saving Frames from Video")
+
+    st.markdown("---")
+
+
+
+
+
+
+
+    if st.button('Image Augmentation'):
+        navigate_to('augmentation')
+
+    if st.button('Opencv'):
+        navigate_to('advopencv')
 
     if st.button('Back to unstructured data'):
         navigate_to('unstructured_data')
@@ -1292,14 +1653,248 @@ elif st.session_state.page == "opencv":
 
 
 
+
+
+
+
+
 #------------------------------------------------------ blank ------------------------------------------
+elif st.session_state.page == "augmentation":
+    st.title("Image Augmentation Techniques with OpenCV")
+
+    # Introduction to Image Augmentation
+    st.header("What is Image Augmentation?")
+    st.write("""
+    Image augmentation is a technique used to artificially expand the size of a dataset by creating modified versions of images. 
+    These modifications help improve the performance and robustness of machine learning models by enabling them to generalize better to unseen data.
+    Common augmentation techniques include:
+    - **Scaling**: Resizing the image.
+    - **Translation**: Shifting the image along X and Y axes.
+    - **Shearing**: Skewing the image along an axis.
+    - **Rotation**: Rotating the image by a specified angle.
+    - **Cropping**: Extracting a specific region of interest from the image.
+    
+    These techniques are widely used in computer vision tasks like object detection, image classification, and segmentation.
+    """)
+
+    st.image(r"image/augmentaion.png", caption="Overview of Image Augmentation", use_container_width=True)
+
+    st.markdown("---")
+    st.header("1. Scaling")
+    st.write("""
+    Scaling resizes the image, either enlarging or reducing it. 
+    OpenCV provides functions like `cv2.resize()` and `cv2.warpAffine()` for this purpose. 
+    Scaling is useful for preparing images for machine learning models or adjusting their resolution.
+    """)
+    st.image(r"image/scaling1.webp", caption="Scaling Example", use_container_width=True)
+    st.subheader('Code:')
+    st.code("""
+import cv2
+import numpy as np
+
+sx, sy = 1.5, 1.5  # Scaling factors
+tx, ty = 0, 0  # Translation (no translation)
+s_mat = np.array([[sx, 0, tx], [0, sy, ty]], dtype=np.float32)  # Scaling matrix
+scaled_img = cv2.warpAffine(img, s_mat, (int(1.5 * 500), int(1.5 * 333)))  # Scaled image
+cv2.imshow("Original", img)
+cv2.imshow("Scaled", scaled_img)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+    """, language="python")
+
+    st.markdown("---")
+
+    # Section 2: Translation
+    st.header("2. Translation")
+    st.write("""
+    Translation shifts an image along the X and Y axes. OpenCV uses the `cv2.warpAffine()` function with a translation matrix for this transformation.
+    It’s useful for augmenting datasets by moving objects within images.
+    """)
+    st.image(r"image/translation1.png", caption="Translation Example", use_container_width=True)
+    st.subheader('Code:')
+    st.code("""
+import cv2
+import numpy as np
+
+tx, ty = 50, 50  # Shift by 50 pixels along both axes
+t_mat = np.array([[1, 0, tx], [0, 1, ty]], dtype=np.float32)  # Translation matrix
+translated_img = cv2.warpAffine(img, t_mat, (img.shape[1] + tx, img.shape[0] + ty))
+cv2.imshow("Original", img)
+cv2.imshow("Translated", translated_img)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+    """, language="python")
+
+    st.markdown("---")
+
+    # Section 3: Shearing
+    st.header("3. Shearing")
+    st.write("""
+    Shearing skews an image along the X or Y axis. OpenCV uses a shearing matrix with the `cv2.warpAffine()` function to apply this transformation.
+    Shearing is less commonly used in real-world applications but can be useful for certain data augmentation tasks.
+    """)
+    st.image(r"image/sheering1.png", caption="Shearing Example", use_container_width=True)
+    st.subheader('Code:')
+    st.code("""
+import cv2
+import numpy as np
+
+shx, shy = 5, 2  # Shearing factors
+shear_mat = np.array([[1, shx, 0], [shy, 1, 0]], dtype=np.float32)  # Shearing matrix
+sheared_img = cv2.warpAffine(img, shear_mat, (int(3 * 500), int(3 * 333)))
+cv2.imshow("Original", img)
+cv2.imshow("Sheared", sheared_img)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+    """, language="python")
+
+    st.markdown("---")
+
+    # Section 4: Rotation
+    st.header("4. Rotation")
+    st.write("""
+    Rotation rotates an image around a specific point. OpenCV provides the `cv2.getRotationMatrix2D()` function to create a rotation matrix for use with `cv2.warpAffine()`.
+    """)
+    st.image(r"image/rotation1.png", caption="Rotation Example", use_container_width=True)
+    st.subheader('Code:')
+    st.code("""
+import cv2
+
+center = (img.shape[1] // 2, img.shape[0] // 2)  # Center of rotation
+angle = 90  # Rotation angle in degrees
+scale = 1  # Scale factor (1 means no scaling)
+rotation_matrix = cv2.getRotationMatrix2D(center, angle, scale)
+rotated_img = cv2.warpAffine(img, rotation_matrix, (img.shape[1], img.shape[0]))
+cv2.imshow("Original", img)
+cv2.imshow("Rotated", rotated_img)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+    """, language="python")
+
+    st.markdown("---")
+
+    # Section 5: Cropping
+    st.header("5. Cropping")
+    st.write("""
+    Cropping extracts a specific region from an image. This is a simple yet effective way to focus on specific parts of an image or reduce its size.
+    """)
+    st.image(r"image/cropping1.png", caption="Cropping Example", use_container_width=True)
+    st.subheader('Code:')
+    st.code("""
+import cv2
+
+# Define the region to crop
+cropped_img = img[65:192, 187:323]  # Rows: 65 to 192, Columns: 187 to 323
+cv2.imshow("Original", img)
+cv2.imshow("Cropped", cropped_img)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+    """, language="python")
+
+    st.markdown("---")
+
+
+
+
 
 
+
+    if st.button('Projects'):
+        navigate_to('projects')
+
+    if st.button('Opencv'):
+        navigate_to('advopencv')
+
+    if st.button('Back to unstructured data'):
+        navigate_to('unstructured_data')
+
+    if st.button('Back to Data collection'):
+        navigate_to('data_collection')
+    if st.button("Back to Main Page"):
+        navigate_to("main")
+
+
+
+
+
+
+
+
+#------------------------------------------------------ Projects ------------------------------------------
+elif st.session_state.page == "projects":
+
+    st.title("My OpenCV Projects")
+
+    # Project 1: Don't Drink and Drive
+    st.header("🚫 Don't Drink and Drive: A Visual Story with Python (OpenCV) 🚗🍷")
+    st.write("""
+    I'm thrilled to share this impactful project using Python and OpenCV: an animation video that emphasizes the critical message—**“Don’t Drink & Drive.”**
+
+    ### 🔹 The Animation Story:
+    - It begins with a lively bar scene 🍻, where fun quickly takes a dangerous turn.
+    - A drunken individual makes the risky decision to drive 🚙, leading to a tragic accident 💥.
+    - **Message**: This animation serves as a strong reminder: Safety first—never drink and drive! 💡
+
+    ### 🛠️ Technologies Used:
+    - `cv2.line`, `cv2.circle`, `cv2.rectangle`: Drawing roads 🛣️, characters 👥, and vehicles 🚗.
+    - `cv2.putText`: Displaying the powerful message “Don’t Drink & Drive” ✋🚫.
+    - `cv2.setMouseCallback`: Making the scenes interactive with mouse events 🖱️.
+    - `cv2.imshow` & `cv2.waitKey`: Bringing the animation to life frame-by-frame 🎞️.
+    """)
+
+    # Button for GitHub link
+    if st.button('View this Animation on GitHub'):
+        st.markdown("[View this on GitHub](https://github.com/Kaustubh102/opencv_animation_gif)", unsafe_allow_html=True)
+
+    st.markdown("---")
+
+    # Project 2: The GIF - Debugging Frustration
+    st.header("🔹 The GIF: Debugging Frustration Captured in Motion 🐞🎶")
+    st.write("""
+    This project captures the frustration from coding bugs 🐞 in a fun and creative way! The GIF depicts:
+    - A keyboard transforming into a **therapy drum 🥁**, symbolizing how we often just need to drum out the stress of debugging!
+
+    ### 🛠️ Technologies Used:
+    - `cv2.line`, `cv2.circle`, `cv2.rectangle`: Drawing creative elements.
+    - `cv2.putText`: Adding text for context and humor.
+    - `cv2.imshow` & `cv2.waitKey`: Creating the animated effect.
+    - **Fun Twist**: Sometimes all you need is to drum out the stress! 🤯
+    """)
+
+    # Button for GitHub link
+    if st.button('View this GIF on GitHub'):
+        st.markdown("[View this on GitHub](https://github.com/Kaustubh102/opencv_animation_gif)", unsafe_allow_html=True)
+
+    st.markdown("---")
+
+
+
+
+    if st.button('Back to Semistructured data'):
+        navigate_to('semistructured_data')
+
+    if st.button('Back to Data collection'):
+        navigate_to('data_collection')
+    if st.button("Back to Main Page"):
+        navigate_to("main")
+
+
+
+
+#------------------------------------------------------ blank ------------------------------------------
 elif st.session_state.page == "blank":
 
 
 
 
+    if st.button('Back to Semistructured data'):
+        navigate_to('semistructured_data')
+
+    if st.button('Back to Data collection'):
+        navigate_to('data_collection')
+    if st.button("Back to Main Page"):
+        navigate_to("main")
+