green channel

app.py

@@ -226,7 +226,6 @@
 #         theme=gr.themes.Soft(),
 #         ssr_mode=False
 #     )
-
 import gradio as gr
 import cv2
 import numpy as np
@@ -316,7 +315,6 @@ def scan_edges(image):
     """
     Edge detection with CLAHE preprocessing to recover edges lost in
     shadowed regions (e.g. bearing saddle arcs on engine blocks).
-
     Pipeline:
         RGB → Grayscale → Gaussian Blur → CLAHE → Canny
     """
@@ -349,6 +347,57 @@ def scan_edges(image):
     return edges_rgb
 
 
+def extract_green_channel(image):
+    """
+    Extract the green channel from an RGB image.
+    Green channel often provides good contrast for vegetation and certain materials.
+    """
+    # 1. Convert PIL image to numpy array if needed
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # 2. Extract green channel (index 1 in RGB)
+    green_channel = image[:, :, 1]
+    
+    # 3. Convert to RGB for display (all channels = green)
+    green_rgb = cv2.cvtColor(green_channel, cv2.COLOR_GRAY2RGB)
+    
+    return green_rgb
+
+
+def green_bilateral_edges(image):
+    """
+    Edge detection using green channel with bilateral filtering.
+    Pipeline:
+        RGB → Green Channel → Bilateral Filter → Canny Edge Detection
+    
+    Bilateral filtering preserves edges while reducing noise, making it ideal
+    for edge detection on noisy or textured surfaces.
+    """
+    # 1. Convert PIL image to numpy array if needed
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # 2. Extract green channel
+    green_channel = image[:, :, 1]
+    
+    # 3. Apply bilateral filter
+    #    d=9           : diameter of pixel neighborhood
+    #    sigmaColor=75 : filter sigma in the color space (larger = more colors mixed)
+    #    sigmaSpace=75 : filter sigma in the coordinate space (larger = farther pixels influence)
+    #    Bilateral filtering smooths flat regions while preserving sharp edges
+    bilateral = cv2.bilateralFilter(green_channel, d=9, sigmaColor=75, sigmaSpace=75)
+    
+    # 4. Apply Canny edge detection
+    #    Using moderate thresholds for balanced edge detection
+    edges = cv2.Canny(bilateral, 50, 150)
+    
+    # 5. Convert back to RGB for Gradio display
+    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
+    
+    return edges_rgb
+
+
 def process_image(image, mode):
     """
     Process image based on selected mode
@@ -358,16 +407,42 @@ def process_image(image, mode):
         
     if mode == "Object Detection":
         return detect_objects(image)
-    else:  # Edge Detection
+    elif mode == "Edge Detection":
         edges = scan_edges(image)
-        return edges, "Edge detection completed"
+        return edges, "Edge detection completed (CLAHE + Canny)"
+    elif mode == "Green Channel":
+        green = extract_green_channel(image)
+        return green, "Green channel extracted"
+    elif mode == "Green + Bilateral Edges":
+        edges = green_bilateral_edges(image)
+        return edges, "Edge detection completed (Green Channel + Bilateral Filter + Canny)"
+    else:
+        return image, "Unknown mode selected"
+
+
+def process_live_stream(image, mode):
+    """
+    Process live stream based on selected mode
+    """
+    if image is None:
+        return None
+        
+    if mode == "Edge Detection":
+        return scan_edges(image)
+    elif mode == "Green Channel":
+        return extract_green_channel(image)
+    elif mode == "Green + Bilateral Edges":
+        return green_bilateral_edges(image)
+    else:
+        return scan_edges(image)  # Default to edge detection
+
 
 # Create Gradio interface
 with gr.Blocks(title="Object Scanner") as demo:
-    gr.Markdown("Detect objects or scan edges using your camera or uploaded images")
+    gr.Markdown("# 🔍 Object Scanner\nDetect objects, scan edges, or extract green channel using your camera or uploaded images")
     
     with gr.Tabs():
-        with gr.TabItem(" Image Scanner"):
+        with gr.TabItem("📷 Image Scanner"):
             with gr.Row():
                 with gr.Column():
                     input_image = gr.Image(
@@ -376,11 +451,16 @@ with gr.Blocks(title="Object Scanner") as demo:
                         label="Upload or Capture Image"
                     )
                     mode = gr.Radio(
-                        choices=["Object Detection", "Edge Detection"],
+                        choices=[
+                            "Object Detection", 
+                            "Edge Detection", 
+                            "Green Channel",
+                            "Green + Bilateral Edges"
+                        ],
                         value="Object Detection",
                         label="Scanning Mode"
                     )
-                    scan_btn = gr.Button(" Process Image", variant="primary")
+                    scan_btn = gr.Button("🔍 Process Image", variant="primary")
                 
                 with gr.Column():
                     output_image = gr.Image(type="numpy", label="Processed Result")
@@ -392,6 +472,8 @@ with gr.Blocks(title="Object Scanner") as demo:
                     examples=[
                         ["examples/sample1.jpg", "Object Detection"],
                         ["examples/sample2.jpg", "Edge Detection"],
+                        ["examples/sample1.jpg", "Green Channel"],
+                        ["examples/sample2.jpg", "Green + Bilateral Edges"],
                     ],
                     inputs=[input_image, mode],
                     outputs=[output_image, output_text],
@@ -399,8 +481,8 @@ with gr.Blocks(title="Object Scanner") as demo:
                     cache_examples=False,
                 )
 
-        with gr.TabItem("🎥 Live Edge Scan"):
-            gr.Markdown("### Real-time Edge Detection")
+        with gr.TabItem("🎥 Live Processing"):
+            gr.Markdown("### Real-time Image Processing")
             with gr.Row():
                 with gr.Column():
                     camera_input = gr.Image(
@@ -409,15 +491,24 @@ with gr.Blocks(title="Object Scanner") as demo:
                         type="numpy",
                         label="Live Feed"
                     )
+                    live_mode = gr.Radio(
+                        choices=[
+                            "Edge Detection",
+                            "Green Channel",
+                            "Green + Bilateral Edges"
+                        ],
+                        value="Edge Detection",
+                        label="Processing Mode"
+                    )
                 with gr.Column():
                     camera_output = gr.Image(
-                        label="Edge Stream"
+                        label="Processed Stream"
                     )
             
-            # Live stream logic for edges
+            # Live stream logic
             camera_input.stream(
-                fn=scan_edges,
-                inputs=camera_input,
+                fn=lambda img, mode: process_live_stream(img, mode),
+                inputs=[camera_input, live_mode],
                 outputs=camera_output
             )
     
@@ -427,6 +518,21 @@ with gr.Blocks(title="Object Scanner") as demo:
         inputs=[input_image, mode],
         outputs=[output_image, output_text]
     )
+    
+    # Info section
+    with gr.Accordion("ℹ️ Mode Information", open=False):
+        gr.Markdown("""
+        ### Available Modes:
+        
+        **Object Detection** - Uses DETR model to detect and label objects with bounding boxes
+        
+        **Edge Detection** - CLAHE-enhanced Canny edge detection for shadowed regions
+        
+        **Green Channel** - Extracts the green channel, useful for vegetation and certain materials
+        
+        **Green + Bilateral Edges** - Combines green channel extraction with bilateral filtering before edge detection. 
+        Bilateral filtering preserves edges while reducing noise, ideal for textured surfaces.
+        """)
 
 if __name__ == "__main__":
     demo.launch(