updated code

README.md

@@ -9,4 +9,84 @@ app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Object Difference Highlighter
+
+## Overview
+The **Object Difference Highlighter** is a computer vision application that identifies and isolates new objects in a scene. Given two images of the same scene—one without an object and another with an added object (taken seconds apart)—the app intelligently detects what has changed while filtering out environmental noise like moving foliage, slight shadows, or minor lighting changes.
+
+## Key Features
+- **Intelligent Object Detection**: Identifies real, meaningful changes between two similar images
+- **Noise Filtering**: Eliminates false positives from environmental variations (wind-moved objects, minor lighting changes)
+- **Multiple Detection Algorithms**:
+  - **SSIM (Structural Similarity Index Measure)**: Detects structural differences
+  - **Background Subtraction**: Filters out background to focus on foreground changes
+  - **Optical Flow**: Detects motion-based changes between frames
+- **Comprehensive Visualization**: Six different views to analyze and understand the changes
+
+## Visual Outputs
+The application provides six different views arranged in three rows:
+
+### Row 1: Base Comparison
+- **Blended Image**: A 50/50 blend of both input images
+- **Raw Difference Overlay**: Unprocessed pixel differences shown in magenta on the original image
+
+### Row 2: Algorithm Results
+- **Highlighted Differences**: Areas identified as changed by the selected algorithm
+- **Black & White Mask**: Binary mask showing exactly what areas the algorithm detected as changed
+
+### Row 3: Final Composition
+- **Composite Image**: Scene from the first image with only the detected object from the second image
+- **Final Difference Overlay**: Differences between the original scene and the composite image shown in magenta
+
+## Use Cases
+- **Photography**: Remove unwanted elements from otherwise perfect shots
+- **Surveillance**: Detect new objects in monitored areas
+- **Research**: Analyze scene changes in controlled environments
+- **Wildlife Monitoring**: Detect animals in natural settings
+- **Retail/Inventory**: Track object placement and removal
+
+## Installation & Setup
+### **1. Clone the Repository**
+```bash
+git clone https://github.com/your-username/object-difference-highlighter.git
+cd object-difference-highlighter
+```
+
+### **2. Install Dependencies**
+Ensure you have Python installed, then run:
+```bash
+pip install -r requirements.txt
+```
+
+### **3. Run the Application**
+```bash
+python app.py
+```
+The application will launch in your default web browser via **Gradio**.
+
+## Usage Guide
+### **Step 1: Upload Images**
+- Upload two images:
+  1. **Image Without Object (Scene)**: The base scene without the object of interest
+  2. **Image With Object**: The same scene with the added object
+
+### **Step 2: Configure Parameters**
+- **Comparison Method**: Select the algorithm best suited for your images
+  - SSIM works well for most cases
+  - Background Subtraction is good for static cameras
+  - Optical Flow works well for slight camera movements
+- **Gaussian Blur**: Adjust to reduce noise (higher values for noisier images)
+- **Thresholding Technique**: When using SSIM, determines how differences are identified
+
+### **Step 3: Process & Review Results**
+- Click **Process** to generate all six visualizations
+- Compare the different views to understand how well the algorithm detected the new object
+- Use the mask and highlighted differences to evaluate detection quality
+- The composite image shows the final result with only the detected object added to the scene
+
+## Dependencies
+- Python 3.7+
+- OpenCV
+- NumPy
+- Scikit-Image
+- Gradio

app.py

@@ -15,8 +15,33 @@ def background_subtraction(image1, image2):
     fgmask1 = subtractor.apply(image1)
     fgmask2 = subtractor.apply(image2)
     diff = cv2.absdiff(fgmask1, fgmask2)
-    unchanged = cv2.bitwise_and(image1, image1, mask=255 - diff)
-    return cv2.cvtColor(diff, cv2.COLOR_GRAY2BGR), unchanged
+    
+    # Create a binary mask
+    _, mask = cv2.threshold(diff, 30, 255, cv2.THRESH_BINARY)
+    
+    # Create highlighted differences
+    highlighted = cv2.bitwise_and(image2, image2, mask=mask)
+    
+    # Create raw difference overlay
+    diff_colored = cv2.cvtColor(diff, cv2.COLOR_GRAY2BGR)
+    diff_colored[:, :, 0] = 0  # Remove blue
+    diff_colored[:, :, 1] = 0  # Remove green
+    overlay = cv2.addWeighted(image1, 0.6, diff_colored, 0.6, 0)
+    
+    # Create a blended image
+    blended = cv2.addWeighted(image1, 0.5, image2, 0.5, 0)
+    
+    # Create a composite using the mask
+    composite = image1.copy()
+    composite[mask > 0] = image2[mask > 0]
+    
+    # Create final difference overlay
+    composite_diff = cv2.absdiff(image1, composite)
+    composite_diff[:, :, 0] = 0  # Remove blue
+    composite_diff[:, :, 1] = 0  # Remove green
+    final_overlay = cv2.addWeighted(image1, 0.6, composite_diff, 0.6, 0)
+    
+    return blended, overlay, highlighted, mask, composite, final_overlay
 
 def optical_flow(image1, image2):
     gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
@@ -27,28 +52,39 @@ def optical_flow(image1, image2):
     hsv[..., 1] = 255
     hsv[..., 0] = ang * 180 / np.pi / 2
     hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
-    unchanged = cv2.bitwise_and(image1, image1, mask=255 - hsv[..., 2].astype(np.uint8))
-    return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR), unchanged
+    
+    # Create mask from magnitude
+    mask = cv2.threshold(hsv[..., 2], 30, 255, cv2.THRESH_BINARY)[1].astype(np.uint8)
+    
+    # Create highlighted differences
+    highlighted = cv2.bitwise_and(image2, image2, mask=mask)
+    
+    # Create raw difference overlay
+    diff_colored = cv2.absdiff(image1, image2)
+    diff_colored[:, :, 0] = 0  # Remove blue
+    diff_colored[:, :, 1] = 0  # Remove green
+    overlay = cv2.addWeighted(image1, 0.6, diff_colored, 0.6, 0)
+    
+    # Create a blended image
+    blended = cv2.addWeighted(image1, 0.5, image2, 0.5, 0)
+    
+    # Create a composite using the mask
+    composite = image1.copy()
+    composite[mask > 0] = image2[mask > 0]
+    
+    # Create final difference overlay
+    composite_diff = cv2.absdiff(image1, composite)
+    composite_diff[:, :, 0] = 0  # Remove blue
+    composite_diff[:, :, 1] = 0  # Remove green
+    final_overlay = cv2.addWeighted(image1, 0.6, composite_diff, 0.6, 0)
+    
+    return blended, overlay, highlighted, mask, composite, final_overlay
 
 def feature_matching(image1, image2):
-    orb = cv2.ORB_create()
-    kp1, des1 = orb.detectAndCompute(image1, None)
-    kp2, des2 = orb.detectAndCompute(image2, None)
-    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
-    matches = bf.match(des1, des2)
-    matches = sorted(matches, key=lambda x: x.distance)
-    result = cv2.drawMatches(image1, kp1, image2, kp2, matches[:20], None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
-    unchanged = cv2.addWeighted(image1, 0.7, image2, 0.3, 0)
-    return result, unchanged
+    # Use SSIM as a fallback for feature matching since the original implementation doesn't give us a good mask
+    return compare_ssim(image1, image2, 5, "Adaptive Threshold", 30)
 
-def compare_images(image1, image2, blur_value, technique, threshold_value, method):
-    if method == "Background Subtraction":
-        return background_subtraction(image1, image2)
-    elif method == "Optical Flow":
-        return optical_flow(image1, image2)
-    elif method == "Feature Matching":
-        return feature_matching(image1, image2)
-    
+def compare_ssim(image1, image2, blur_value, technique, threshold_value):
     gray1 = preprocess_image(image1, blur_value)
     gray2 = preprocess_image(image2, blur_value)
     score, diff = ssim(gray1, gray2, full=True)
@@ -63,20 +99,45 @@ def compare_images(image1, image2, blur_value, technique, threshold_value, metho
     
     contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     filtered_contours = [cnt for cnt in contours if cv2.contourArea(cnt) > 500]
-    mask = np.zeros_like(image1, dtype=np.uint8)
-    cv2.drawContours(mask, filtered_contours, -1, (255, 255, 255), thickness=cv2.FILLED)
-    highlighted = cv2.bitwise_and(image2, mask)
+    mask = np.zeros_like(gray1, dtype=np.uint8)
+    cv2.drawContours(mask, filtered_contours, -1, 255, thickness=cv2.FILLED)
+    
+    # Create highlighted differences
+    highlighted = cv2.bitwise_and(image2, image2, mask=mask)
     
+    # Create raw difference overlay
     diff_colored = cv2.absdiff(image1, image2)
     diff_colored[:, :, 0] = 0  # Remove blue
     diff_colored[:, :, 1] = 0  # Remove green
+    overlay = cv2.addWeighted(image1, 0.6, diff_colored, 0.6, 0)
     
-    overlayed = cv2.addWeighted(image1, 0.6, diff_colored, 0.6, 0)
+    # Create a blended image
+    blended = cv2.addWeighted(image1, 0.5, image2, 0.5, 0)
     
-    blended_with_object = cv2.addWeighted(image1, 0.4, image2, 0.6, 0)
-    blended_without_object = cv2.bitwise_and(image1, image1, mask=255 - thresh)
+    # Create a composite using the mask
+    composite = image1.copy()
+    mask_3channel = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
+    masked_obj = cv2.bitwise_and(image2, mask_3channel)
+    masked_bg = cv2.bitwise_and(image1, cv2.bitwise_not(mask_3channel))
+    composite = cv2.add(masked_bg, masked_obj)
     
-    return highlighted, overlayed, blended_with_object, blended_without_object
+    # Create final difference overlay
+    composite_diff = cv2.absdiff(image1, composite)
+    composite_diff[:, :, 0] = 0  # Remove blue
+    composite_diff[:, :, 1] = 0  # Remove green
+    final_overlay = cv2.addWeighted(image1, 0.6, composite_diff, 0.6, 0)
+    
+    return blended, overlay, highlighted, mask, composite, final_overlay
+
+def compare_images(image1, image2, blur_value, technique, threshold_value, method):
+    if method == "Background Subtraction":
+        return background_subtraction(image1, image2)
+    elif method == "Optical Flow":
+        return optical_flow(image1, image2)
+    elif method == "Feature Matching":
+        return feature_matching(image1, image2)
+    else:  # SSIM
+        return compare_ssim(image1, image2, blur_value, technique, threshold_value)
 
 def update_threshold_visibility(technique):
     return gr.update(visible=(technique == "Simple Binary"))
@@ -85,7 +146,7 @@ with gr.Blocks() as demo:
     gr.Markdown("# Object Difference Highlighter\nUpload two images: one without an object and one with an object. The app will highlight only the newly added object and show the real differences in magenta overlayed on the original image.")
     
     with gr.Row():
-        img1 = gr.Image(type="numpy", label="Image Without Object")
+        img1 = gr.Image(type="numpy", label="Image Without Object (Scene)")
         img2 = gr.Image(type="numpy", label="Image With Object")
     
     blur_slider = gr.Slider(minimum=1, maximum=15, step=1, value=5, label="Gaussian Blur")
@@ -95,15 +156,22 @@ with gr.Blocks() as demo:
     
     technique_dropdown.change(update_threshold_visibility, inputs=[technique_dropdown], outputs=[threshold_slider])
     
+    # Row 1 - Blend and Raw Difference
     with gr.Row():
-        output1 = gr.Image(type="numpy", label="Highlighted Differences")
+        output1 = gr.Image(type="numpy", label="Blended Image")
         output2 = gr.Image(type="numpy", label="Raw Difference Overlay (Magenta)")
     
+    # Row 2 - Algorithmic Differences and Mask
+    with gr.Row():
+        output3 = gr.Image(type="numpy", label="Highlighted Differences")
+        output4 = gr.Image(type="numpy", label="Black & White Mask")
+    
+    # Row 3 - Composite and Final Difference
     with gr.Row():
-        output3 = gr.Image(type="numpy", label="Blended with Object")
-        output4 = gr.Image(type="numpy", label="Blended without Object")
+        output5 = gr.Image(type="numpy", label="Composite (Scene + Masked Object)")
+        output6 = gr.Image(type="numpy", label="Final Difference Overlay (Magenta)")
     
     btn = gr.Button("Process")
-    btn.click(compare_images, inputs=[img1, img2, blur_slider, technique_dropdown, threshold_slider, method_dropdown], outputs=[output1, output2, output3, output4])
+    btn.click(compare_images, inputs=[img1, img2, blur_slider, technique_dropdown, threshold_slider, method_dropdown], outputs=[output1, output2, output3, output4, output5, output6])
 
 demo.launch()