Update app.py

app.py

@@ -1,52 +1,13 @@
 import gradio as gr
-import cv2
-import numpy as np
+from cv_functions.functions import (
+    image_video_io, color_space_conversion, resize_crop, geometric_transform,
+    thresholding, edge_detection, image_filtering, contour_detection,
+    feature_detection, object_detection, face_detection, image_segmentation,
+    optical_flow, camera_calibration, stereo_vision, background_subtraction,
+    image_stitching, kmeans_clustering, deep_learning, drawing_text
+)
 
-# Load Haar Cascade for face detection
-face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-
-def process_grayscale(image):
-    image = np.array(image)
-    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    return cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
-
-def process_canny(image, threshold1, threshold2):
-    image = np.array(image)
-    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    edges = cv2.Canny(gray, threshold1, threshold2)
-    return cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
-
-def process_blur(image, kernel_size):
-    image = np.array(image)
-    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-    kernel_size = int(kernel_size) | 1  # Ensure odd number
-    blurred = cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)
-    return cv2.cvtColor(blurred, cv2.COLOR_BGR2RGB)
-
-def process_face_detection(image):
-    image = np.array(image)
-    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
-    output = image.copy()
-    for (x, y, w, h) in faces:
-        cv2.rectangle(output, (x, y), (x+w, y+h), (0, 255, 0), 2)
-    return cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
-
-def process_color_space(image, color_space):
-    image = np.array(image)
-    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-    if color_space == "HSV":
-        output = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
-    elif color_space == "LAB":
-        output = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
-    else:
-        output = image  # Fallback to original
-    return cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
-
-# Custom CSS with Tailwind via CDN
+# Custom CSS with Tailwind
 custom_css = """
 <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/tailwind.min.css" rel="stylesheet">
 <style>
@@ -65,60 +26,254 @@ custom_css = """
 
 # Gradio interface
 with gr.Blocks(css=custom_css) as demo:
-    gr.HTML("<h1 class='text-center'>OpenCV Multi-Feature Demo</h1>")
-    gr.Markdown("Upload an image and explore various OpenCV features using the tabs below.", elem_classes=["markdown-style"])
-    
-    image_input = gr.Image(label="Upload Image", type="pil")
+    gr.HTML("<h1 class='text-center'>OpenCV Comprehensive Demo</h1>")
+    gr.Markdown("Explore all OpenCV features by uploading images or videos and selecting a tab below.", elem_classes=["markdown-style"])
     
     with gr.Tabs():
-        with gr.TabItem("Grayscale", elem_classes="tab-button"):
+        # 1. Image and Video I/O
+        with gr.TabItem("Image/Video I/O", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Upload an image or video to display.", elem_classes=["input-label"])
+                    io_image = gr.Image(label="Upload Image", type="pil")
+                    io_video = gr.Video(label="Upload Video")
+                    io_button = gr.Button("Display", elem_classes="btn-primary")
+                with gr.Column():
+                    io_output = gr.Gallery(label="Output")
+            io_button.click(fn=image_video_io, inputs=[io_image, io_video], outputs=io_output)
+        
+        # 2. Color Space Conversion
+        with gr.TabItem("Color Space Conversion", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Convert between RGB, HSV, and LAB color spaces.", elem_classes=["input-label"])
+                    cs_image = gr.Image(label="Upload Image", type="pil")
+                    cs_space = gr.Dropdown(choices=["RGB", "HSV", "LAB"], label="Color Space", value="RGB")
+                    cs_button = gr.Button("Apply Conversion", elem_classes="btn-primary")
+                with gr.Column():
+                    cs_output = gr.Image(label="Converted Image")
+            cs_button.click(fn=color_space_conversion, inputs=[cs_image, cs_space], outputs=cs_output)
+        
+        # 3. Image Resizing and Cropping
+        with gr.TabItem("Resizing and Cropping", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Resize or crop the image.", elem_classes=["input-label"])
+                    rc_image = gr.Image(label="Upload Image", type="pil")
+                    rc_scale = gr.Slider(0.1, 2.0, value=1.0, step=0.1, label="Scale Factor")
+                    rc_crop_x = gr.Slider(0, 1, value=0, step=0.1, label="Crop X (relative)")
+                    rc_crop_y = gr.Slider(0, 1, value=0, step=0.1, label="Crop Y (relative)")
+                    rc_crop_w = gr.Slider(0, 1, value=0.5, step=0.1, label="Crop Width (relative)")
+                    rc_crop_h = gr.Slider(0, 1, value=0.5, step=0.1, label="Crop Height (relative)")
+                    rc_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    rc_output = gr.Gallery(label="Resized and Cropped Images")
+            rc_button.click(fn=resize_crop, inputs=[rc_image, rc_scale, rc_crop_x, rc_crop_y, rc_crop_w, rc_crop_h], outputs=rc_output)
+        
+        # 4. Geometric Transformations
+        with gr.TabItem("Geometric Transformations", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Apply rotation and translation.", elem_classes=["input-label"])
+                    gt_image = gr.Image(label="Upload Image", type="pil")
+                    gt_angle = gr.Slider(-180, 180, value=0, step=1, label="Rotation Angle (degrees)")
+                    gt_tx = gr.Slider(-100, 100, value=0, step=1, label="Translation X (pixels)")
+                    gt_ty = gr.Slider(-100, 100, value=0, step=1, label="Translation Y (pixels)")
+                    gt_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    gt_output = gr.Image(label="Transformed Image")
+            gt_button.click(fn=geometric_transform, inputs=[gt_image, gt_angle, gt_tx, gt_ty], outputs=gt_output)
+        
+        # 5. Image Thresholding
+        with gr.TabItem("Thresholding", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Apply global or adaptive thresholding.", elem_classes=["input-label"])
+                    thresh_image = gr.Image(label="Upload Image", type="pil")
+                    thresh_type = gr.Dropdown(choices=["Global", "Adaptive"], label="Threshold Type", value="Global")
+                    thresh_value = gr.Slider(0, 255, value=127, step=1, label="Threshold Value")
+                    thresh_block = gr.Slider(3, 21, value=11, step=2, label="Block Size (Adaptive)")
+                    thresh_C = gr.Slider(-10, 10, value=2, step=1, label="Constant (Adaptive)")
+                    thresh_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    thresh_output = gr.Image(label="Thresholded Image")
+            thresh_button.click(fn=thresholding, inputs=[thresh_image, thresh_type, thresh_value, thresh_block, thresh_C], outputs=thresh_output)
+        
+        # 6. Edge Detection
+        with gr.TabItem("Edge Detection", elem_classes="tab-button"):
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("Convert the image to grayscale.", elem_classes=["input-label"])
-                    grayscale_button = gr.Button("Apply Grayscale", elem_classes="btn-primary")
+                    gr.Markdown("Detect edges using Canny, Sobel, or Laplacian.", elem_classes=["input-label"])
+                    edge_image = gr.Image(label="Upload Image", type="pil")
+                    edge_type = gr.Dropdown(choices=["Canny", "Sobel", "Laplacian"], label="Edge Type", value="Canny")
+                    edge_t1 = gr.Slider(0, 500, value=100, step=10, label="Canny Threshold 1")
+                    edge_t2 = gr.Slider(0, 500, value=200, step=10, label="Canny Threshold 2")
+                    edge_button = gr.Button("Apply", elem_classes="btn-primary")
                 with gr.Column():
-                    grayscale_output = gr.Image(label="Grayscale Result")
-            grayscale_button.click(fn=process_grayscale, inputs=image_input, outputs=grayscale_output)
+                    edge_output = gr.Image(label="Edges")
+            edge_button.click(fn=edge_detection, inputs=[edge_image, edge_type, edge_t1, edge_t2], outputs=edge_output)
         
-        with gr.TabItem("Canny Edge Detection", elem_classes="tab-button"):
+        # 7. Image Filtering
+        with gr.TabItem("Image Filtering", elem_classes="tab-button"):
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("Detect edges with adjustable thresholds.", elem_classes=["input-label"])
-                    canny_t1 = gr.Slider(0, 500, value=100, step=10, label="Threshold 1")
-                    canny_t2 = gr.Slider(0, 500, value=200, step=10, label="Threshold 2")
-                    canny_button = gr.Button("Apply Canny", elem_classes="btn-primary")
+                    gr.Markdown("Apply Gaussian or median blur.", elem_classes=["input-label"])
+                    filter_image = gr.Image(label="Upload Image", type="pil")
+                    filter_type = gr.Dropdown(choices=["Gaussian", "Median"], label="Filter Type", value="Gaussian")
+                    filter_kernel = gr.Slider(3, 21, value=5, step=2, label="Kernel Size")
+                    filter_button = gr.Button("Apply", elem_classes="btn-primary")
                 with gr.Column():
-                    canny_output = gr.Image(label="Edges")
-            canny_button.click(fn=process_canny, inputs=[image_input, canny_t1, canny_t2], outputs=canny_output)
+                    filter_output = gr.Image(label="Filtered Image")
+            filter_button.click(fn=image_filtering, inputs=[filter_image, filter_type, filter_kernel], outputs=filter_output)
         
-        with gr.TabItem("Gaussian Blur", elem_classes="tab-button"):
+        # 8. Contour Detection
+        with gr.TabItem("Contour Detection", elem_classes="tab-button"):
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("Apply Gaussian blur with adjustable kernel size.", elem_classes=["input-label"])
-                    blur_kernel = gr.Slider(3, 21, value=5, step=2, label="Kernel Size")
-                    blur_button = gr.Button("Apply Blur", elem_classes="btn-primary")
+                    gr.Markdown("Detect and draw contours.", elem_classes=["input-label"])
+                    contour_image = gr.Image(label="Upload Image", type="pil")
+                    contour_button = gr.Button("Apply", elem_classes="btn-primary")
                 with gr.Column():
-                    blur_output = gr.Image(label="Blurred Image")
-            blur_button.click(fn=process_blur, inputs=[image_input, blur_kernel], outputs=blur_output)
+                    contour_output = gr.Image(label="Contours")
+            contour_button.click(fn=contour_detection, inputs=contour_image, outputs=contour_output)
         
+        # 9. Feature Detection
+        with gr.TabItem("Feature Detection", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Detect ORB keypoints.", elem_classes=["input-label"])
+                    feat_image = gr.Image(label="Upload Image", type="pil")
+                    feat_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    feat_output = gr.Image(label="Keypoints")
+            feat_button.click(fn=feature_detection, inputs=feat_image, outputs=feat_output)
+        
+        # 10. Object Detection
+        with gr.TabItem("Object Detection", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Detect cars using Haar Cascade.", elem_classes=["input-label"])
+                    obj_image = gr.Image(label="Upload Image", type="pil")
+                    obj_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    obj_output = gr.Image(label="Detected Objects")
+            obj_button.click(fn=object_detection, inputs=obj_image, outputs=obj_output)
+        
+        # 11. Face Detection
         with gr.TabItem("Face Detection", elem_classes="tab-button"):
             with gr.Row():
                 with gr.Column():
                     gr.Markdown("Detect faces using Haar Cascade.", elem_classes=["input-label"])
-                    face_button = gr.Button("Detect Faces", elem_classes="btn-primary")
+                    face_image = gr.Image(label="Upload Image", type="pil")
+                    face_button = gr.Button("Apply", elem_classes="btn-primary")
                 with gr.Column():
-                    face_output = gr.Image(label="Faces Detected")
-            face_button.click(fn=process_face_detection, inputs=image_input, outputs=face_output)
+                    face_output = gr.Image(label="Detected Faces")
+            face_button.click(fn=face_detection, inputs=face_image, outputs=face_output)
         
-        with gr.TabItem("Color Space Conversion", elem_classes="tab-button"):
+        # 12. Image Segmentation
+        with gr.TabItem("Image Segmentation", elem_classes="tab-button"):
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("Convert between RGB, HSV, and LAB color spaces.", elem_classes=["input-label"])
-                    color_space = gr.Dropdown(choices=["RGB", "HSV", "LAB"], label="Color Space", value="RGB")
-                    color_button = gr.Button("Apply Conversion", elem_classes="btn-primary")
+                    gr.Markdown("Apply GrabCut segmentation.", elem_classes=["input-label"])
+                    seg_image = gr.Image(label="Upload Image", type="pil")
+                    seg_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    seg_output = gr.Image(label="Segmented Image")
+            seg_button.click(fn=image_segmentation, inputs=seg_image, outputs=seg_output)
+        
+        # 13. Motion Analysis
+        with gr.TabItem("Motion Analysis", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Compute optical flow for video.", elem_classes=["input-label"])
+                    motion_video = gr.Video(label="Upload Video")
+                    motion_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    motion_output = gr.Image(label="Optical Flow")
+            motion_button.click(fn=optical_flow, inputs=motion_video, outputs=motion_output)
+        
+        # 14. Camera Calibration
+        with gr.TabItem("Camera Calibration", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Detect checkerboard for calibration (upload checkerboard image).", elem_classes=["input-label"])
+                    calib_image = gr.Image(label="Upload Image", type="pil")
+                    calib_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    calib_output = gr.Image(label="Calibration Result")
+            calib_button.click(fn=camera_calibration, inputs=calib_image, outputs=calib_output)
+        
+        # 15. Stereo Vision
+        with gr.TabItem("Stereo Vision", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Compute disparity map (simplified).", elem_classes=["input-label"])
+                    stereo_image = gr.Image(label="Upload Image", type="pil")
+                    stereo_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    stereo_output = gr.Image(label="Disparity Map")
+            stereo_button.click(fn=stereo_vision, inputs=stereo_image, outputs=stereo_output)
+        
+        # 16. Background Subtraction
+        with gr.TabItem("Background Subtraction", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Apply MOG2 for moving object detection.", elem_classes=["input-label"])
+                    bg_video = gr.Video(label="Upload Video")
+                    bg_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    bg_output = gr.Image(label="Foreground Mask")
+            bg_button.click(fn=background_subtraction, inputs=bg_video, outputs=bg_output)
+        
+        # 17. Image Stitching
+        with gr.TabItem("Image Stitching", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Stitch two images using ORB features.", elem_classes=["input-label"])
+                    stitch_image1 = gr.Image(label="Upload First Image", type="pil")
+                    stitch_image2 = gr.Image(label="Upload Second Image", type="pil")
+                    stitch_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    stitch_output = gr.Image(label="Stitched Image")
+            stitch_button.click(fn=image_stitching, inputs=[stitch_image1, stitch_image2], outputs=stitch_output)
+        
+        # 18. Machine Learning (K-Means)
+        with gr.TabItem("K-Means Clustering", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Apply k-means clustering for color quantization.", elem_classes=["input-label"])
+                    kmeans_image = gr.Image(label="Upload Image", type="pil")
+                    kmeans_k = gr.Slider(2, 16, value=8, step=1, label="Number of Clusters (K)")
+                    kmeans_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    kmeans_output = gr.Image(label="Clustered Image")
+            kmeans_button.click(fn=kmeans_clustering, inputs=[kmeans_image, kmeans_k], outputs=kmeans_output)
+        
+        # 19. Deep Learning
+        with gr.TabItem("Deep Learning", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Detect objects using MobileNet SSD (upload prototxt and caffemodel files).", elem_classes=["input-label"])
+                    dl_image = gr.Image(label="Upload Image", type="pil")
+                    dl_prototxt = gr.File(label="Upload Prototxt File")
+                    dl_model = gr.File(label="Upload Caffemodel File")
+                    dl_button = gr.Button("Apply", elem_classes="btn-primary")
+                with gr.Column():
+                    dl_output = gr.Image(label="Detected Objects")
+            dl_button.click(fn=deep_learning, inputs=[dl_image, dl_prototxt, dl_model], outputs=dl_output)
+        
+        # 20. Drawing and Text
+        with gr.TabItem("Drawing and Text", elem_classes="tab-button"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Draw shapes and add text to the image.", elem_classes=["input-label"])
+                    draw_image = gr.Image(label="Upload Image", type="pil")
+                    draw_shape = gr.Dropdown(choices=["Rectangle", "Circle"], label="Shape", value="Rectangle")
+                    draw_text = gr.Textbox(label="Text to Add", value="OpenCV")
+                    draw_button = gr.Button("Apply", elem_classes="btn-primary")
                 with gr.Column():
-                    color_output = gr.Image(label="Converted Image")
-            color_button.click(fn=process_color_space, inputs=[image_input, color_space], outputs=color_output)
+                    draw_output = gr.Image(label="Annotated Image")
+            draw_button.click(fn=drawing_text, inputs=[draw_image, draw_shape, draw_text], outputs=draw_output)
 
 if __name__ == "__main__":
     demo.launch()