Update pages/Data Collection.py

pages/Data Collection.py

@@ -1357,7 +1357,305 @@ def opencv_projects_page():
 def Image_Augmentation_page():
 
         st.title("Image Augmentation")
+        # Heading
+        st.markdown("""
+            <h3 style="color: #9400d3;">What is Image Augmentation?</h3>
+        """, unsafe_allow_html=True)
+        
+        # Definition
+        st.write("""
+        Image augmentation is a method used to enhance the size and variety of an image dataset by applying transformations to existing images. 
+        These transformations introduce variations while preserving the core features of the image, making it useful for training machine learning models to handle diverse inputs. 
+        
+        *How It Works*
+        Image augmentation applies transformations like resizing, rotation, flipping, and more to the original image. These changes simulate real-world variations, ensuring that machine learning models can identify patterns even with differences in perspective, scale, or lighting conditions.
+        
+        The key idea is to preserve the original features of the image while introducing diversity. For example, if we take an image and apply five different transformations, we generate five new variations of that image. This provides the model with more data to learn from, improving its performance and ability to generalize.
+        """)
+    
+        # Types of Image Augmentation
+        
+        st.markdown("""
+            <h3 style="color: #9400d3;">Types of Image Augmentation</h3>
+        """, unsafe_allow_html=True)
+        
+        st.write("""
+        Image augmentation is broadly categorized into two types:
+        
+        1. *Affine Transformations*
+        2. *Non-Affine Transformations*
+        """)
+    
+        # Affine Transformations
+        
+        st.markdown("""
+            <h3 style="color: #9400d3;">Affine Transformations</h3>
+        """, unsafe_allow_html=True)
+        
+        st.write("""
+        *Affine Transformations* are transformations where:
+        
+        1. The transformed image and the original image maintain *parallelism between lines*.
+        2. In some cases, the *angle between lines* and the *length of the lines* may also be preserved.
+        
+        These transformations ensure that the geometric relationships within the image remain intact, even as the image is resized, rotated, or shifted.
+        
+        Affine transformations are performed using a mathematical operation known as an *Affine Matrix*, which maps the original image coordinates to new coordinates.
+        """)
     
+        st.markdown("""
+            <h3 style="color: #e25822;">Common Affine Transformations:</h3>
+        """, unsafe_allow_html=True)
+        
+        st.write("""
+        1. *Scaling*: Changing the size of the image while maintaining its proportions.
+        2. *Translation*: Shifting the image horizontally, vertically, or both.
+        3. *Rotation*: Rotating the image around a specified center point.
+        4. *Shearing*: Slanting the image along the x or y axis, creating a skewed effect.
+        5. *Cropping*: Extracting a specific portion of the image, usually to focus on a region of interest.
+        
+        These transformations are linear, meaning the relationships between points in the image remain consistent.
+        """)
+    
+        st.image(
+            "https://huggingface.co/spaces/LakshmiHarika/MachineLearning/resolve/main/Images/affine_transformations.png",
+            use_container_width=True)
+    
+        # Explanation for Translation
+        st.markdown("""
+            <h3 style="color: #9400d3;">Translation</h3>
+        """, unsafe_allow_html=True)
+        
+        st.write("""
+        *Translation* involves moving an image from one location to another along the x-axis, y-axis, or both. It adjusts the position of the image on the canvas without modifying its original content.
+        
+        The transformation is performed using a translation matrix:
+        """)
+    
+        st.write("""
+        The translation matrix is represented as:
+        [[1, 0, tx], [0, 1, ty]]
+            
+        Here:
+        - *tx*: Specifies the shift along the x-axis (horizontal axis).
+        - *ty*: Specifies the shift along the y-axis (vertical axis).
+        
+        """)
+    
+        st.code("""
+        # Load the image
+        img = cv2.imread('path_to_image.jpg')
+        
+        # Define translation parameters
+        tx = 100  # Shift 100 pixels along the x-axis
+        ty = 50   # Shift 50 pixels along the y-axis
+        
+        # Create the translation matrix
+        translation_matrix = np.array([[1, 0, tx], [0, 1, ty]], dtype=np.float32)
+        
+        # Apply translation
+        translated_img = cv2.warpAffine(img, translation_matrix, (300, 300))
+        
+        # Display the images
+        cv2.imshow("Original Image", img)
+        cv2.imshow("Translated Image", translated_img)
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+        """, language="python")
+    
+        # Explanation for Rotation
+        st.markdown("""
+            <h3 style="color: #9400d3;">Rotation</h3>
+        """, unsafe_allow_html=True)
+        
+        st.write("""
+        *Rotation* involves rotating an image around a specified center point by a given angle. It changes the orientation of the image while preserving its content.
+        
+        The rotation is performed using a rotation matrix:
+        [[cos(θ), -sin(θ), tx], [sin(θ), cos(θ), ty]]
+        Here:
+        - *θ (theta)*: Specifies the rotation angle in degrees.
+        - *tx, ty*: Specifies the adjustments to reposition the rotated image.
+        - *Scale*: A factor that can resize the image during rotation.
+        """)
+        
+        # Code Example
+        st.code("""
+        # Load the image
+        img = cv2.imread('path_to_image.jpg')
+        
+        # Define the rotation matrix
+        r_m = cv2.getRotationMatrix2D((1347, 900), 50, 1)  # Center at (1347, 900), Rotate by 50 degrees, Scale = 1
+        
+        # Apply rotation
+        r_img = cv2.warpAffine(img, r_m, (580, 500), borderMode=cv2.BORDER_DEFAULT)
+        
+        # Display the images
+        cv2.imshow("Original Image", img)
+        cv2.imshow("Rotated Image", r_img)
+        
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+        """, language="python")
+        
+        # Explanation for Direct Rotation
+        st.markdown("""
+            <h3 style="color: #9400d3;">Direct Rotation Using cv2.rotate</h3>
+        """, unsafe_allow_html=True)
+        
+        st.write("""
+        OpenCV provides a direct method for rotating images with predefined angles: cv2.rotate. 
+        This method simplifies rotation operations for 90°, 180°, and 270° (clockwise or counterclockwise) without requiring a custom rotation matrix.
+        
+        - **cv2.ROTATE_180**: Rotates the image by 180°.
+        - **cv2.ROTATE_90_CLOCKWISE**: Rotates the image by 90° clockwise.
+        - **cv2.ROTATE_90_COUNTERCLOCKWISE**: Rotates the image by 90° counterclockwise.
+        """)
+        
+        # Code Example
+        st.code("""
+        # Rotate the image using predefined rotation modes
+        img1 = cv2.rotate(img, cv2.ROTATE_180)  # Rotate 180 degrees
+        img2 = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)  # Rotate 90 degrees clockwise
+        img3 = cv2.rotate(img, cv2.ROTATE_90_COUNTERCLOCKWISE)  # Rotate 90 degrees counterclockwise
+        
+        # Display the images
+        cv2.imshow("Original Image", img)
+        cv2.imshow("Rotated 180°", img1)
+        cv2.imshow("Rotated 90° Clockwise", img2)
+        cv2.imshow("Rotated 90° Counterclockwise", img3)
+        
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+        """, language="python")
+    
+        # Explanation for Shearing
+        st.markdown("""
+            <h3 style="color: #9400d3;">Shearing</h3>
+        """, unsafe_allow_html=True)
+        
+        st.write("""
+        *Shearing* is a transformation that slants the shape of an image along the x-axis, y-axis, or both. It skews the content of the image, creating a shifted or stretched effect.
+        
+        The transformation is performed using a shearing matrix:
+        """)
+        
+        st.write("""
+        The shearing matrix is represented as:
+        
+        For x-axis shear:
+        [[1, shx, 0], [0, 1, 0]]
+        
+        For y-axis shear:
+        [[1, 0, 0], [shy, 1, 0]]
+        
+        Here:
+        - *shx*: Shear factor along the x-axis.
+        - *shy*: Shear factor along the y-axis.
+        """)
+    
+        st.code("""
+        # Load the image
+        img = cv2.imread('path_to_image.jpg')
+        
+        # Define shearing parameters
+        shx = 1  # Shear factor along the x-axis
+        shy = 3  # Shear factor along the y-axis
+        tx = 0   # Translation along the x-axis
+        ty = 0   # Translation along the y-axis
+        
+        # Create the shearing matrix
+        shearing_matrix = np.array([[1, shx, tx], [shy, 1, ty]], dtype=np.float32)
+        
+        # Apply the shearing transformation
+        sheared_img = cv2.warpAffine(img, shearing_matrix, (300, 300))
+        
+        # Display the original and sheared images
+        cv2.imshow("Original Image", img)
+        cv2.imshow("Sheared Image", sheared_img)
+        
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+        """, language="python")
+    
+    
+        # Explanation for Scaling
+        st.markdown("""
+            <h3 style="color: #9400d3;">Scaling</h3>
+        """, unsafe_allow_html=True)
+        
+        st.write("""
+        *Scaling* is a transformation that changes the size of an image. It can be used to enlarge or shrink the image while maintaining its original proportions or altering them.
+        
+        Scaling is performed using a scaling matrix:
+        """)
+        
+        st.write("""
+        The scaling matrix is represented as:
+        [[sx, 0, 0], [0, sy, 0]]
+        Here:
+        - *sx*: Scaling factor along the x-axis.
+        - *sy*: Scaling factor along the y-axis.
+        - If sx and sy are greater than 1, the image is enlarged.
+        - If sx and sy are less than 1, the image is shrunk.
+        """)
+    
+        st.code("""
+        # Load the image
+        img = cv2.imread('path_to_image.jpg')
+        
+        # Define scaling and translation parameters
+        sx, sy = 2, 1  # Scale by 2 along the x-axis and 1 along the y-axis
+        tx, ty = 0, 0  # No translation
+        
+        # Create the scaling matrix
+        scaling_matrix = np.array([[sx, 0, tx], [0, sy, ty]], dtype=np.float32)
+        
+        # Apply scaling
+        scaled_img = cv2.warpAffine(img, scaling_matrix, (2 * 300, 300))
+        
+        # Display the images
+        cv2.imshow("Original Image", img)
+        cv2.imshow("Scaled Image", scaled_img)
+        
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+        """, language="python")
+    
+    
+        # Explanation for Cropping
+        st.markdown("""
+            <h3 style="color: #9400d3;">Cropping</h3>
+        """, unsafe_allow_html=True)
+        
+        st.write("""
+        *Cropping* is a transformation that extracts a specific portion of an image, usually to focus on a region of interest. 
+        It is achieved by selecting a rectangular region of the image using pixel coordinates.
+        
+        The process involves defining the coordinates for:
+        - *Top-left corner (x1, y1)*: Starting point of the crop.
+        - *Bottom-right corner (x2, y2)*: Ending point of the crop.
+        """)
+        
+        st.code("""
+        # Load the image
+        img = cv2.imread('path_to_image.jpg')
+        
+        # Define crop coordinates
+        x1, y1 = 50, 50  # Top-left corner
+        x2, y2 = 200, 200  # Bottom-right corner
+        
+        # Crop the image
+        cropped_img = img[y1:y2, x1:x2]
+        
+        # Display the images
+        cv2.imshow("Original Image", img)
+        cv2.imshow("Cropped Image", cropped_img)
+        
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+        """, language="python")
+        
         if st.button("Back to Home"):
             st.session_state['page'] = "home"