Update app.py

app.py

@@ -28,129 +28,6 @@ def load_flux_model():
 flux_pipe = None
 
 # Initialize object detection using proven working models
-class AdvancedObjectDetector:
-    def __init__(self):
-        # Using proven working object detection models on Hugging Face Inference API
-        self.api_url = "https://api-inference.huggingface.co/models/hustvl/yolos-small"
-        # Fallback models in order of preference (all tested and working):
-        self.fallback_models = [
-            "https://api-inference.huggingface.co/models/facebook/detr-resnet-50",
-            "https://api-inference.huggingface.co/models/hustvl/yolos-tiny",
-            "https://api-inference.huggingface.co/models/microsoft/DiNAT-Large-ImageNet-1K",
-            "https://api-inference.huggingface.co/models/google/owlvit-base-patch32"
-        ]
-        
-    def detect(self, image, hf_token=None):
-        import base64
-    
-        # Try multiple ways to get HF token
-        token = hf_token or os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_HUB_TOKEN")
-        if not token:
-            raise Exception("HF Token required. Please set HF_TOKEN in Space secrets or environment variables")
-    
-        headers = {
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json"
-        }
-    
-        # Convert PIL image to base64 string
-        img_buffer = io.BytesIO()
-        image.save(img_buffer, format='JPEG', quality=95)
-        img_bytes = img_buffer.getvalue()
-        img_base64 = base64.b64encode(img_bytes).decode("utf-8")
-    
-        payload = {"inputs": img_base64}
-        
-        # Try main model first, then fallbacks
-        models_to_try = [self.api_url] + self.fallback_models
-        
-        for model_url in models_to_try:
-            try:
-                response = requests.post(
-                    model_url, 
-                    headers=headers, 
-                    json=payload,
-                    timeout=45
-                )
-                
-                if response.status_code == 503:
-                    # Model is loading, wait and retry once
-                    import time
-                    time.sleep(15)
-                    response = requests.post(
-                        model_url, 
-                        headers=headers, 
-                        json=payload,
-                        timeout=45
-                    )
-                
-                if response.status_code == 200:
-                    result = response.json()
-                    if isinstance(result, list) and len(result) > 0:
-                        print(f"✅ Successfully used model: {model_url.split('/')[-1]}")
-                        return result
-                    elif isinstance(result, dict) and 'error' not in result:
-                        return []
-                elif response.status_code == 503:
-                    print(f"Model {model_url.split('/')[-1]} is loading...")
-                else:
-                    print(f"Model {model_url.split('/')[-1]} failed with status {response.status_code}: {response.text[:200]}")
-                
-                # If this model failed, try next one
-                continue
-                
-            except requests.exceptions.Timeout:
-                print(f"Timeout with model {model_url}, trying next...")
-                continue
-            except requests.exceptions.RequestException as e:
-                print(f"Network error with model {model_url}: {str(e)}, trying next...")
-                continue
-        
-        # If all models failed
-        raise Exception("All object detection models are currently unavailable. This usually means:\n" +
-                       "1. Models are loading (wait 2-3 minutes and try again)\n" +
-                       "2. High API traffic - try again in a few minutes\n" +
-                       "3. Check your HF token is valid and has sufficient quota")
-
-object_detector = AdvancedObjectDetector()
-
-# Extended object class names including common variations and synonyms
-COMMON_OBJECTS = [
-    # People and body parts
-    'person', 'people', 'human', 'man', 'woman', 'child', 'baby', 'face', 'head',
-    
-    # Animals
-    'cat', 'dog', 'bird', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
-    'lion', 'tiger', 'monkey', 'rabbit', 'mouse', 'rat', 'pig', 'goat', 'deer', 'fox',
-    
-    # Vehicles
-    'car', 'truck', 'bus', 'motorcycle', 'bicycle', 'bike', 'airplane', 'plane', 'boat', 
-    'ship', 'train', 'van', 'taxi', 'ambulance', 'fire truck', 'police car',
-    
-    # Furniture and household items
-    'chair', 'table', 'couch', 'sofa', 'bed', 'desk', 'shelf', 'cabinet', 'drawer',
-    'tv', 'television', 'laptop', 'computer', 'monitor', 'phone', 'mobile', 'tablet',
-    
-    # Food and drinks
-    'bottle', 'cup', 'glass', 'bowl', 'plate', 'fork', 'knife', 'spoon', 'banana', 'apple',
-    'orange', 'pizza', 'sandwich', 'cake', 'donut', 'hot dog', 'hamburger', 'coffee',
-    
-    # Sports and recreation
-    'ball', 'football', 'basketball', 'tennis ball', 'baseball', 'soccer ball',
-    'skateboard', 'surfboard', 'skis', 'bicycle', 'kite', 'frisbee',
-    
-    # Clothing and accessories
-    'hat', 'cap', 'glasses', 'sunglasses', 'bag', 'backpack', 'handbag', 'purse',
-    'umbrella', 'tie', 'shoe', 'boot', 'shirt', 'jacket', 'coat',
-    
-    # Tools and objects
-    'scissors', 'hammer', 'screwdriver', 'knife', 'pen', 'pencil', 'book', 'paper',
-    'clock', 'watch', 'key', 'remote', 'controller', 'camera', 'microphone',
-    
-    # Nature and outdoor
-    'tree', 'flower', 'plant', 'grass', 'rock', 'stone', 'mountain', 'cloud', 'sun',
-    'bench', 'sign', 'pole', 'fence', 'gate', 'building', 'house', 'window', 'door'
-]
 
 def fuzzy_match_object(user_input, detected_labels):
     """
@@ -206,97 +83,11 @@ def fuzzy_match_object(user_input, detected_labels):
     
     return matches
 
-def detect_objects(image, target_object, confidence_threshold, hf_token=None):
-    """
-    Detect any object in the image using advanced detection models and return bounding boxes
-    """
-    try:
-        if not target_object or not target_object.strip():
-            raise gr.Error("Please enter an object name to detect and remove")
-            
-        # Use advanced detection for object detection
-        results = object_detector.detect(image, hf_token)
-        
-        if not results or not isinstance(results, list):
-            return []
-        
-        # Apply confidence threshold first
-        filtered_detections = []
-        for detection in results:
-            if isinstance(detection, dict) and detection.get('score', 0) >= confidence_threshold:
-                filtered_detections.append(detection)
-        
-        # Use fuzzy matching to find target objects
-        target_detections = fuzzy_match_object(target_object, filtered_detections)
-        
-        # Process and validate bounding boxes
-        valid_detections = []
-        image_width, image_height = image.size
-        
-        for detection in target_detections:
-            box = detection.get('box', {})
-            
-            if box and all(key in box for key in ['xmin', 'ymin', 'xmax', 'ymax']):
-                # Convert coordinates
-                xmin = box['xmin']
-                ymin = box['ymin'] 
-                xmax = box['xmax']
-                ymax = box['ymax']
-                
-                # Handle normalized coordinates (0-1 range)
-                if xmax <= 1.0 and ymax <= 1.0:
-                    xmin = int(xmin * image_width)
-                    ymin = int(ymin * image_height)
-                    xmax = int(xmax * image_width)
-                    ymax = int(ymax * image_height)
-                
-                # Ensure coordinates are within bounds and valid
-                xmin = max(0, min(int(xmin), image_width))
-                ymin = max(0, min(int(ymin), image_height))
-                xmax = max(xmin, min(int(xmax), image_width))
-                ymax = max(ymin, min(int(ymax), image_height))
-                
-                # Only add if box has valid area
-                if xmax > xmin and ymax > ymin:
-                    detection_copy = detection.copy()
-                    detection_copy['box'] = {
-                        'xmin': xmin, 'ymin': ymin, 
-                        'xmax': xmax, 'ymax': ymax
-                    }
-                    valid_detections.append(detection_copy)
-        
-        return valid_detections
         
     except Exception as e:
         print(f"Detection error: {str(e)}")
         raise gr.Error(f"Object detection failed: {str(e)}")
 
-def create_mask_from_detections(image, detections, mask_expansion=10):
-    """
-    Create a binary mask from object detections with smart expansion
-    """
-    width, height = image.size
-    mask = Image.new('L', (width, height), 0)  # Black mask
-    draw = ImageDraw.Draw(mask)
-    
-    for detection in detections:
-        box = detection['box']
-        
-        # Calculate expansion based on object size
-        box_width = box['xmax'] - box['xmin']
-        box_height = box['ymax'] - box['ymin']
-        adaptive_expansion = min(mask_expansion, max(5, int(min(box_width, box_height) * 0.1)))
-        
-        # Expand the bounding box
-        x1 = max(0, box['xmin'] - adaptive_expansion)
-        y1 = max(0, box['ymin'] - adaptive_expansion)
-        x2 = min(width, box['xmax'] + adaptive_expansion)
-        y2 = min(height, box['ymax'] + adaptive_expansion)
-        
-        # Draw white rectangle on mask (255 = area to inpaint)
-        draw.rectangle([x1, y1, x2, y2], fill=255)
-    
-    return mask
 
 @spaces.GPU
 def flux_inpainting(image, object_name, guidance_scale=2.5, steps=28):
@@ -334,19 +125,9 @@ def flux_inpainting(image, object_name, guidance_scale=2.5, steps=28):
         print(f"FLUX inpainting error: {str(e)}")
         return None, False
 
-def create_mask_overlay(image, mask):
-    """Create a visualization showing the mask overlay on the original image"""
-    result_image = image.copy()
-    overlay = Image.new('RGBA', image.size, (255, 0, 0, 100))
-    mask_rgba = mask.convert('RGBA')
-    result_image = Image.alpha_composite(
-        result_image.convert('RGBA'), 
-        Image.composite(overlay, Image.new('RGBA', image.size, (0,0,0,0)), mask)
-    )
-    return result_image.convert('RGB')
 
 @spaces.GPU
-def remove_objects(image, object_name, confidence_threshold, mask_expansion, guidance_scale, steps, hf_token):
+def remove_objects(image, object_name, guidance_scale, steps):
     """
     Main function to remove any specified object using advanced detection + FLUX inpainting
     """
@@ -358,7 +139,7 @@ def remove_objects(image, object_name, confidence_threshold, mask_expansion, gui
             raise gr.Error("Please enter the name of the object you want to remove")
         
         # Try to get token from multiple sources
-        token = hf_token or os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_HUB_TOKEN")
+        token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_HUB_TOKEN")
         if not token:
             raise gr.Error("Please provide your Hugging Face token or set HF_TOKEN in Space secrets")
         
@@ -367,20 +148,14 @@ def remove_objects(image, object_name, confidence_threshold, mask_expansion, gui
         result_image, flux_success = flux_inpainting(image, object_name, guidance_scale, steps)
         
         if flux_success and result_image:
-            detected_labels = [d.get('label', 'unknown') for d in detections]
-            status_msg = f"✅ Successfully removed {len(detections)} '{object_name}' object(s)\n"
-            status_msg += f"🎯 Detected as: {', '.join(detected_labels)}\n"
-            status_msg += f"🚀 Used: FLUX.1 Kontext for professional-quality removal\n"
+            status_msg = f"✅ Successfully removed '{object_name}' object(s)\n"
             status_msg += f"⚙️ Settings: Guidance={guidance_scale}, Steps={steps}"
-            return result_image, mask, status_msg
+            return result_image, status_msg
         else:
             # Fallback: show detection areas
-            result_image = create_mask_overlay(image, mask)
-            status_msg = f"⚠️ FLUX inpainting failed, but detection was successful\n"
-            status_msg += f"🎯 Found {len(detections)} '{object_name}' object(s)\n"
-            status_msg += f"📍 Showing detected areas in red overlay\n"
+            status_msg = f"⚠️ Inpainting failed, but detection was successful\n"
             status_msg += f"💡 Try adjusting guidance scale or steps, or check GPU availability"
-            return result_image, mask, status_msg
+            return result_image, status_msg
         
     except Exception as e:
         return image, None, f"❌ Error: {str(e)}"
@@ -428,23 +203,6 @@ with gr.Blocks(
                 )
             
             with gr.Accordion("⚙️ Advanced Settings", open=False):
-                confidence_threshold = gr.Slider(
-                    minimum=0.1,
-                    maximum=1.0,
-                    value=0.3,
-                    step=0.05,
-                    label="🎚️ Detection Confidence",
-                    info="Lower = more detections, higher = fewer but more confident"
-                )
-                
-                mask_expansion = gr.Slider(
-                    minimum=0,
-                    maximum=50,
-                    value=20,
-                    step=5,
-                    label="📏 Mask Expansion (pixels)",
-                    info="Expand mask around detected objects for debugging"
-                )
                 
                 guidance_scale = gr.Slider(
                     minimum=1.0,
@@ -490,63 +248,13 @@ with gr.Blocks(
         inputs=[
             input_image,
             object_name,
-            confidence_threshold,
-            mask_expansion,
             guidance_scale,
             steps,
         ],
         outputs=[output_image, status_text]
     )
     
-    # Instructions and examples
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("""
-            ## 📚 Instructions
-            
-            1. **Upload an image** containing objects you want to remove
-            2. **Enter ANY object name** in the text box - no restrictions!
-            3. **Adjust detection settings** if needed:
-               - **Confidence**: Start with 0.3, increase if too many false detections
-               - **Mask expansion**: For debugging - shows detection areas
-            4. **Fine-tune FLUX settings**:
-               - **Guidance Scale**: 2.5 is optimal for most cases
-               - **Steps**: 28 gives good quality/speed balance
-            5. **Click "Remove Objects"** and wait for professional AI processing
-            
-            ### 💡 Smart Object Recognition:
-            - **Handles variations**: "car" = "vehicle" = "automobile"
-            - **Plural support**: "person" matches "people"
-            - **Common synonyms**: "phone" = "mobile" = "smartphone"
-            - **Fuzzy matching**: Partial name matches work too!
-            """)
         
-        with gr.Column():
-            gr.Markdown("""
-            ## 🎯 What Can Be Removed?
-            
-            **✅ ANY Object You Can Think Of!**
-            
-            **Popular Examples:**
-            - **People**: person, human, man, woman, child, face
-            - **Animals**: dog, cat, bird, horse, any animal name
-            - **Vehicles**: car, truck, bike, plane, boat, motorcycle
-            - **Objects**: bottle, bag, phone, chair, table, sign
-            - **Nature**: tree, flower, rock, cloud, mountain
-            - **And literally thousands more!**
-            
-            ### ⚡ FLUX.1 Kontext Advantages:
-            - **🎨 Professional Quality**: State-of-the-art contextual editing
-            - **🧠 Intelligent Fill**: Understands scene context and lighting
-            - **⚡ GPU Accelerated**: Fast processing with high quality
-            - **🎯 Precise Control**: Fine-tunable guidance and steps
-            - **🔧 No API Limits**: Runs locally without external dependencies
-            
-            **System Requirements:**
-            - GPU-enabled environment (automatically handled in Spaces)
-            - HF token for object detection API access
-            - Processing time: 30-90 seconds depending on image size
-            """)
 
 if __name__ == "__main__":
     demo.launch()