feat: Enhance documentation for computer vision filters in app.py

- Expanded the documentation section to provide detailed descriptions for each available filter, including parameters, usage, and links to relevant OpenCV resources.
- Improved clarity and organization of filter information to enhance user understanding and experience.
- Added fallback messaging for filters without existing documentation.

app.py

@@ -424,7 +424,11 @@ with main_tabs[2]:  # Documentation Tab
     st.markdown(
         """
     ## Documentation
-    
+
+    This section provides details about the available computer vision filters and transformations.
+    You can select multiple filters, and they will be applied sequentially in the order chosen within each category.
+    Adjust the parameters in the control panel to see the effects in real-time.
+
     ### Available Filters
     """
     )
@@ -435,98 +439,225 @@ with main_tabs[2]:  # Documentation Tab
             for filter_name in filters:
                 st.markdown(f"#### {filter_name}")
 
-                # Add description for each filter
-                if filter_name == "Color Filter":
+                # Add detailed description and links for each filter
+                if filter_name == "Resize":
                     st.markdown(
                         """
-                    Isolates specific colors in the HSV (Hue, Saturation, Value) color space.
-                    
+                    Changes the dimensions (width and height) of the video frame. Useful for adjusting the output size or preparing the frame for other operations that require a specific input size.
+
                     **Parameters:**
-                    - **Hue**: Color type (0-180)
-                    - **Saturation**: Color intensity (0-255)
-                    - **Value**: Brightness (0-255)
-                    
-                    **Usage**: Object detection based on color, creative effects, background removal.
+                    - **Width**: Target width in pixels.
+                    - **Height**: Target height in pixels.
+
+                    **Usage**: Scaling for performance, UI fitting, preprocessing for models.
+
+                    **Docs**: [OpenCV Geometric Transformations](https://docs.opencv.org/4.x/da/d6e/tutorial_py_geometric_transformations.html) (See `cv2.resize`)
                     """
                     )
-                elif filter_name == "Canny":
+                elif filter_name == "Rotation":
                     st.markdown(
                         """
-                    Detects edges in the image using the Canny edge detection algorithm.
-                    
+                    Rotates the video frame around its center by a specified angle.
+
                     **Parameters:**
-                    - **Lower Threshold**: Minimum gradient value to consider as an edge
-                    - **Upper Threshold**: Maximum gradient value to consider as an edge
-                    
-                    **Usage**: Edge detection, feature extraction, line detection.
+                    - **Angle**: Rotation angle in degrees (0-360).
+
+                    **Usage**: Image orientation correction, creative effects.
+
+                    **Docs**: [OpenCV Geometric Transformations](https://docs.opencv.org/4.x/da/d6e/tutorial_py_geometric_transformations.html) (See `cv2.getRotationMatrix2D` and `cv2.warpAffine`)
                     """
                     )
                 elif filter_name == "Blur":
                     st.markdown(
                         """
-                    Applies Gaussian blur to smooth the image.
-                    
+                    Applies Gaussian blur to smooth the image, reducing noise and detail. The kernel size determines the extent of blurring.
+
                     **Parameters:**
-                    - **Kernel Size**: Size of the blurring matrix (higher values create more blur)
-                    
-                    **Usage**: Noise reduction, detail smoothing, pre-processing for other algorithms.
+                    - **Kernel Size**: Size of the blurring matrix (must be an odd number). Higher values create more blur.
+
+                    **Usage**: Noise reduction, detail smoothing, pre-processing for edge detection or other algorithms.
+
+                    **Docs**: [OpenCV Smoothing Images](https://docs.opencv.org/4.x/d4/d13/tutorial_py_filtering.html) (See `cv2.GaussianBlur`)
                     """
                     )
-                elif filter_name == "Rotation":
+                elif filter_name == "Sharpen":
+                    st.markdown(
+                        """
+                    Enhances the edges and details in the image using a sharpening kernel. This is achieved by subtracting a blurred version of the image from the original.
+
+                    **Parameters:** None (uses a fixed kernel).
+
+                    **Usage**: Enhancing image clarity, highlighting details.
+
+                    **Docs**: [OpenCV Image Filtering Concepts](https://docs.opencv.org/4.x/d4/d13/tutorial_py_filtering.html) (Concept explanation, the implementation uses a custom kernel)
+                    """
+                    )
+                elif filter_name == "Canny":
+                    st.markdown(
+                        """
+                    Detects edges in the image using the Canny edge detection algorithm, a multi-stage process to find sharp changes in intensity.
+
+                    **Parameters:**
+                    - **Lower Threshold**: Minimum intensity gradient to be considered a potential edge.
+                    - **Upper Threshold**: Maximum intensity gradient. Edges above this are definite edges. Pixels between the thresholds are included if connected to definite edges.
+
+                    **Usage**: Edge detection, feature extraction, object boundary identification.
+
+                    **Docs**: [OpenCV Canny Edge Detection](https://docs.opencv.org/4.x/da/d22/tutorial_py_canny.html)
+                    """
+                    )
+                elif filter_name == "Contour":
                     st.markdown(
                         """
-                    Rotates the image by a specified angle.
-                    
+                    Finds and draws contours (continuous curves joining points along a boundary with the same intensity) in the image. Usually applied after thresholding or edge detection.
+
+                    **Parameters:** None (finds contours on the processed image and draws them).
+
+                    **Usage**: Object detection, shape analysis, feature extraction.
+
+                    **Docs**: [OpenCV Contours](https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html) (See `cv2.findContours`, `cv2.drawContours`)
+                    """
+                    )
+                elif filter_name == "Hough Lines":
+                    st.markdown(
+                        """
+                    Detects straight lines in the image using the Hough Line Transform (Probabilistic variant). Works best on edge-detected images.
+
+                    **Parameters:** None (uses preset parameters for `cv2.HoughLinesP`).
+
+                    **Usage**: Line detection in images, structure identification.
+
+                    **Docs**: [OpenCV Hough Line Transform](https://docs.opencv.org/4.x/d6/d10/tutorial_py_houghlines.html) (See `cv2.HoughLinesP`)
+                    """
+                    )
+                elif filter_name == "Color Filter":
+                    st.markdown(
+                        """
+                    Isolates specific colors by converting the image to HSV (Hue, Saturation, Value) color space and applying a threshold based on the selected ranges.
+
                     **Parameters:**
-                    - **Angle**: Rotation angle in degrees (0-360)
-                    
-                    **Usage**: Image orientation correction, creative effects.
+                    - **Lower Bounds (Hue, Sat, Val)**: Minimum HSV values for the color range.
+                    - **Upper Bounds (Hue, Sat, Val)**: Maximum HSV values for the color range.
+
+                    **Usage**: Object detection based on color, color segmentation, special effects.
+
+                    **Docs**: [OpenCV Changing Colorspaces](https://docs.opencv.org/4.x/df/d9d/tutorial_py_colorspaces.html) (See `cv2.cvtColor` and `cv2.inRange`)
                     """
                     )
-                elif filter_name == "Resize":
+                elif filter_name == "Histogram Equalization":
                     st.markdown(
                         """
-                    Changes the dimensions of the image.
-                    
+                    Improves contrast in grayscale images by redistributing pixel intensities more evenly across the histogram. Applied to the Value channel if the input is color.
+
+                    **Parameters:** None.
+
+                    **Usage**: Enhancing contrast in low-contrast images, improving visibility of details.
+
+                    **Docs**: [OpenCV Histogram Equalization](https://docs.opencv.org/4.x/d5/daf/tutorial_py_histogram_equalization.html) (See `cv2.equalizeHist`)
+                    """
+                    )
+                elif filter_name == "Color Quantization":
+                    st.markdown(
+                        """
+                    Reduces the number of distinct colors in an image using K-Means clustering in the color space. Groups similar colors together.
+
+                    **Parameters:** None (uses a fixed number of clusters, K=8).
+
+                    **Usage**: Image compression, posterization effect, simplifying color palettes.
+
+                    **Docs**: [OpenCV K-Means Clustering](https://docs.opencv.org/4.x/d1/d5c/tutorial_py_kmeans_opencv.html) (Underlying algorithm)
+                    """
+                    )
+                elif filter_name == "Pencil Sketch":
+                    st.markdown(
+                        """
+                    Creates a pencil sketch effect by converting the image to grayscale, inverting it, blurring the inverted image, and blending it with the original grayscale image using color dodge.
+
+                    **Parameters:** None.
+
+                    **Usage**: Artistic image transformation, creating sketch-like visuals.
+
+                    **Docs**: Involves multiple OpenCV steps (Grayscale, Blur, Blending). See [Color Dodge Blending](https://en.wikipedia.org/wiki/Blend_modes#Dodge_and_burn).
+                    """
+                    )
+                elif filter_name == "Morphology":
+                    st.markdown(
+                        """
+                    Applies morphological operations (Erode, Dilate, Open, Close) to modify the shape of features in the image, typically on binary images.
+
                     **Parameters:**
-                    - **Width**: Output width in pixels
-                    - **Height**: Output height in pixels
-                    
-                    **Usage**: Scaling for performance, UI fitting, preprocessing.
+                    - **Operation**: Type of morphological operation (`erode`, `dilate`, `open`, `close`).
+                    - **Kernel Size**: Size of the structuring element used (odd number).
+
+                    **Usage**: Noise removal, joining broken parts, thinning/thickening features.
+
+                    **Docs**: [OpenCV Morphological Transformations](https://docs.opencv.org/4.x/d9/d61/tutorial_py_morphological_ops.html) (See `cv2.erode`, `cv2.dilate`, `cv2.morphologyEx`)
+                    """
+                    )
+                elif filter_name == "Adaptive Threshold":
+                    st.markdown(
+                        """
+                    Applies adaptive thresholding, where the threshold value is calculated locally for different regions of the image. Useful for images with varying illumination.
+
+                    **Parameters:** None (uses `cv2.ADAPTIVE_THRESH_GAUSSIAN_C`).
+
+                    **Usage**: Image segmentation in non-uniform lighting conditions.
+
+                    **Docs**: [OpenCV Image Thresholding](https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html) (See `cv2.adaptiveThreshold`)
                     """
                     )
+                elif filter_name == "Optical Flow":
+                    st.markdown(
+                        """
+                        Calculates and visualizes the apparent motion of objects between consecutive frames using the Farneback algorithm. Shows motion vectors as lines on the image.
+
+                        **Parameters:** None (Requires previous frame data internally).
+
+                        **Usage**: Motion tracking, video stabilization analysis, action recognition.
+
+                        **Docs**: [OpenCV Optical Flow](https://docs.opencv.org/4.x/d4/dee/tutorial_optical_flow.html) (See `cv2.calcOpticalFlowFarneback`)
+                        """
+                    )
                 elif filter_name == "Hand Tracker":
                     st.markdown(
                         """
-                    Detects and tracks hand positions and landmarks using MediaPipe.
-                    
-                    **Parameters:** None (uses pre-trained models)
-                    
-                    **Usage**: Gesture recognition, hand pose estimation, interactive applications.
+                    Detects and tracks hand positions and landmarks (joints) in real-time using the MediaPipe Hands solution. Draws landmarks and connections on the detected hands.
+
+                    **Parameters:** None (uses pre-trained MediaPipe models).
+
+                    **Usage**: Gesture recognition, sign language interpretation, virtual object interaction, hand pose estimation.
+
+                    **Docs**: [MediaPipe Hand Landmarker](https://developers.google.com/mediapipe/solutions/vision/hand_landmarker)
                     """
                     )
                 elif filter_name == "Face Tracker":
                     st.markdown(
                         """
-                    Detects and tracks facial landmarks using MediaPipe.
-                    
-                    **Parameters:** None (uses pre-trained models)
-                    
-                    **Usage**: Face detection, facial expression analysis, AR effects.
+                    Detects faces in the video feed using the MediaPipe Face Detection solution and draws bounding boxes around them.
+
+                    **Parameters:** None (uses pre-trained MediaPipe models).
+
+                    **Usage**: Face detection, counting people, basic facial analysis applications, input for face recognition or landmark detection.
+
+                    **Docs**: [MediaPipe Face Detector](https://developers.google.com/mediapipe/solutions/vision/face_detector)
                     """
                     )
                 else:
-                    st.markdown(f"Documentation for {filter_name} filter.")
+                    # Fallback for any filters missed
+                    st.markdown(
+                        f"Detailed documentation for the **{filter_name}** filter is pending."
+                    )
+
+                st.divider()  # Add a separator between filter descriptions
 
     st.markdown(
         """
-    ### Technical Details
-    
-    For more information about the algorithms and techniques used in this application, refer to:
-    
-    - [OpenCV Documentation](https://docs.opencv.org/4.x/d6/d00/tutorial_py_root.html)
-    - [MediaPipe Documentation](https://ai.google.dev/edge/mediapipe/solutions/guide?hl=pt-br)
-    - [Streamlit Documentation](https://docs.streamlit.io/)
+    ### General Technical Details
+
+    - **OpenCV**: The core library used for most image processing functions. [OpenCV Python Tutorials](https://docs.opencv.org/4.x/d6/d00/tutorial_py_root.html)
+    - **MediaPipe**: Used for the advanced Hand and Face Tracking features. [MediaPipe Solutions](https://developers.google.com/mediapipe/solutions/)
+    - **Streamlit**: The framework used to build this web application interface. [Streamlit Documentation](https://docs.streamlit.io/)
+    - **WebRTC**: Enables real-time video streaming from your webcam to the browser for processing. (Handled by `streamlit-webrtc`)
     """
     )
 
@@ -535,7 +666,7 @@ st.markdown(
 <div style="position: fixed; bottom: 0; width: 100%; background-color: #0E1117;
             padding: 8px; text-align: center; border-top: 1px solid #262730;">
     <p style="margin: 0; font-size: 13px; color: #AAAAAA;">
-    OpenCV Explorer | Built with Streamlit | © 2024
+    OpenCV Explorer | Built with Streamlit 
     </p>
 </div>
 """,