Update pages/Data Collection.py

pages/Data Collection.py

@@ -1396,6 +1396,9 @@ elif st.session_state.current_page == "image_transformations":
     
     # 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
     
@@ -1410,11 +1413,15 @@ elif st.session_state.current_page == "image_transformations":
     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.
     
-    ### Available Rotation Modes:
     - **`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.
@@ -1437,10 +1444,134 @@ elif st.session_state.current_page == "image_transformations":
     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")