Update app.py

app.py

@@ -4,7 +4,7 @@ import numpy as np
 from PIL import Image
 import cv2
 
-print("🚀 Starting SAM2 App v2.1 - OPTIMIZED...")
+print("🚀 Starting SAM2 App v2.2 - SMART & FAST...")
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"📱 Using device: {device}")
@@ -61,16 +61,16 @@ def refine_mask(mask, kernel_size=5):
     mask_refined = cv2.morphologyEx(mask_closed, cv2.MORPH_OPEN, kernel)
     return mask_refined > 0
 
-def segment_automatic(image, quality="high", merge_parts=True):
+def segment_automatic(image, quality="high", filter_largest=True):
     """
-    OPTIMIERTE Automatische Segmentierung
-    Schnell & präzise - kombiniert mehrere Masken
+    SMART Segmentierung - Filtert nur Hauptobjekt
+    Keine Jacke, kein Hintergrund!
     """
     if image is None:
         return None, {"error": "Kein Bild hochgeladen"}
     
     try:
-        print(f"🔄 Starting segmentation (quality: {quality}, merge: {merge_parts})...")
+        print(f"🔄 Starting SMART segmentation...")
         model, processor = load_model()
         
         image_pil, image_np = prepare_image(image)
@@ -78,7 +78,6 @@ def segment_automatic(image, quality="high", merge_parts=True):
         
         center_x, center_y = w // 2, h // 2
         
-        # Single point inference mit multimask_output
         inputs = processor(
             image_pil,
             input_points=[[[center_x, center_y]]],
@@ -102,56 +101,62 @@ def segment_automatic(image, quality="high", merge_parts=True):
         
         print(f"✅ Got {len(scores)} masks with scores: {scores}")
         
-        # SMART MERGING: Kombiniere alle guten Masken
-        if merge_parts:
-            combined_mask = np.zeros((h, w), dtype=bool)
-            masks_used = 0
-            
-            for idx, score in enumerate(scores):
-                if score > 0.5:  # Nur Masken mit gutem Score
-                    if masks.ndim == 4:
-                        mask = masks[0, idx].numpy()
-                    else:
-                        mask = masks[idx].numpy()
-                    
-                    # OR-Kombination (super schnell!)
-                    combined_mask = combined_mask | (mask > 0)
-                    masks_used += 1
-                    print(f"  ✅ Added mask {idx} (score: {score:.3f})")
-            
-            final_mask = combined_mask
-            print(f"🔗 Combined {masks_used} masks into one!")
+        # SMART: Nimm mittlere Maske (nicht höchste = zu weit)
+        if len(scores) >= 3:
+            sorted_indices = np.argsort(scores)
+            best_idx = sorted_indices[1]  # Mittlere
+            print(f"📊 Using MIDDLE mask (score: {scores[best_idx]:.3f})")
         else:
-            # Nur beste Maske
             best_idx = np.argmax(scores)
-            if masks.ndim == 4:
-                final_mask = masks[0, best_idx].numpy() > 0
+        
+        if masks.ndim == 4:
+            selected_mask = masks[0, best_idx].numpy() > 0
+        else:
+            selected_mask = masks[best_idx].numpy() > 0
+        
+        # FILTER: Nur größte zusammenhängende Komponente
+        if filter_largest:
+            print("🔍 Filtering: Keeping only LARGEST component...")
+            
+            num_labels, labels = cv2.connectedComponents(selected_mask.astype(np.uint8))
+            
+            if num_labels > 1:
+                largest_component = 0
+                largest_size = 0
+                
+                for i in range(1, num_labels):
+                    size = np.sum(labels == i)
+                    if size > largest_size:
+                        largest_size = size
+                        largest_component = i
+                
+                final_mask = (labels == largest_component)
+                print(f"  ✅ Removed {num_labels - 2} small parts (Jacke, etc.)")
             else:
-                final_mask = masks[best_idx].numpy() > 0
-            masks_used = 1
-            print(f"✅ Using best mask (score: {scores[best_idx]:.3f})")
+                final_mask = selected_mask
+        else:
+            final_mask = selected_mask
         
-        # Refinement für glatte Kanten
+        # Refinement
         if quality == "high":
-            print("🎨 Refining mask...")
+            print("🎨 Refining edges...")
             final_mask = refine_mask(final_mask, kernel_size=7)
         
-        # Overlay erstellen
+        # Overlay
         overlay = image_np.copy()
-        color = np.array([255, 80, 180])  # Rosa/Pink
+        color = np.array([255, 80, 180])
         
         mask_float = final_mask.astype(float)
         if quality == "high":
             mask_float = cv2.GaussianBlur(mask_float, (5, 5), 0)
         
-        # Farbiges Overlay
         for c in range(3):
             overlay[:, :, c] = (
                 overlay[:, :, c] * (1 - mask_float * 0.65) +
                 color[c] * mask_float * 0.65
             )
         
-        # Gelbe Kontur zeichnen
+        # Kontur
         contours, _ = cv2.findContours(
             final_mask.astype(np.uint8),
             cv2.RETR_EXTERNAL,
@@ -161,9 +166,10 @@ def segment_automatic(image, quality="high", merge_parts=True):
         
         metadata = {
             "success": True,
-            "mode": "automatic_plus" if merge_parts else "automatic",
+            "mode": "automatic_smart",
             "quality": quality,
-            "masks_combined": masks_used,
+            "filtered": filter_largest,
+            "selected_mask_score": float(scores[best_idx]),
             "all_scores": scores.tolist(),
             "image_size": [w, h],
             "mask_area": int(np.sum(final_mask)),
@@ -172,7 +178,7 @@ def segment_automatic(image, quality="high", merge_parts=True):
             "device": device
         }
         
-        print("✅ Segmentation complete!")
+        print(f"✅ Done! Contours: {len(contours)}")
         return Image.fromarray(overlay.astype(np.uint8)), metadata
         
     except Exception as e:
@@ -180,26 +186,28 @@ def segment_automatic(image, quality="high", merge_parts=True):
         print(f"❌ ERROR:\n{traceback.format_exc()}")
         return image, {"error": str(e)}
 
-def segment_multi_dense(image, density="medium"):
-    """Multi-Object Segmentierung mit Grid"""
+def segment_multi_dense(image, density="low"):
+    """
+    Multi-Region OPTIMIERT für CPU
+    Reduzierte Punktanzahl = schneller!
+    """
     if image is None:
         return None, {"error": "Kein Bild"}
     
     try:
-        print(f"🎯 Starting multi-region segmentation (density: {density})...")
+        print(f"🎯 Starting multi-region (density: {density})...")
         model, processor = load_model()
         image_pil, image_np = prepare_image(image)
         h, w = image_np.shape[:2]
         
-        # Grid-Größe basierend auf Density
+        # OPTIMIERTE Grid-Größen für CPU
         if density == "high":
-            grid_size = 5
+            grid_size = 4  # 4x4 = 16
         elif density == "medium":
-            grid_size = 4
+            grid_size = 3  # 3x3 = 9
         else:
-            grid_size = 3
+            grid_size = 2  # 2x2 = 4
         
-        # Grid-Punkte generieren
         points = []
         for i in range(1, grid_size + 1):
             for j in range(1, grid_size + 1):
@@ -207,13 +215,17 @@ def segment_multi_dense(image, density="medium"):
                 y = int(h * j / (grid_size + 1))
                 points.append([x, y])
         
-        print(f"📍 Using {len(points)} grid points ({grid_size}x{grid_size})...")
+        total_points = len(points)
+        estimated_time = total_points * 10
+        print(f"📍 Using {total_points} points ({grid_size}x{grid_size})")
+        print(f"⏱️ Estimated time: ~{estimated_time}s")
         
         all_masks = []
         all_scores = []
         
-        # Segmentiere jeden Punkt
         for idx, point in enumerate(points):
+            print(f"  Point {idx+1}/{total_points}...")
+            
             inputs = processor(
                 image_pil,
                 input_points=[[point]],
@@ -222,7 +234,7 @@ def segment_multi_dense(image, density="medium"):
             ).to(device)
             
             with torch.no_grad():
-                outputs = model(**inputs, multimask_output=True)
+                outputs = model(**inputs, multimask_output=False)
             
             masks = processor.image_processor.post_process_masks(
                 outputs.pred_masks.cpu(),
@@ -231,24 +243,24 @@ def segment_multi_dense(image, density="medium"):
             )[0]
             
             scores = outputs.iou_scores.cpu().numpy().flatten()
-            best_idx = np.argmax(scores)
+            best_idx = 0 if len(scores) == 1 else np.argmax(scores)
             
             if masks.ndim == 4:
                 mask = masks[0, best_idx].numpy()
-            else:
+            elif masks.ndim == 3:
                 mask = masks[best_idx].numpy()
+            else:
+                mask = masks.numpy()
             
-            # Nur Masken mit gutem Score
             if scores[best_idx] > 0.7:
-                all_masks.append(refine_mask(mask))
+                all_masks.append(mask > 0)
                 all_scores.append(scores[best_idx])
         
         print(f"✅ Got {len(all_masks)} quality masks")
         
-        # Overlay mit verschiedenen Farben
         overlay = image_np.copy()
         
-        # HSV-basierte Farbgenerierung
+        # Farben
         colors = []
         for i in range(len(all_masks)):
             hue = int(180 * i / max(len(all_masks), 1))
@@ -256,15 +268,13 @@ def segment_multi_dense(image, density="medium"):
             color_rgb = cv2.cvtColor(color_hsv, cv2.COLOR_HSV2RGB)[0][0]
             colors.append(color_rgb)
         
-        # Masken anwenden
         for mask, color, score in zip(all_masks, colors, all_scores):
-            alpha = 0.4 + (score - 0.7) * 0.2  # Höherer Score = stärkere Farbe
+            alpha = 0.5
             overlay[mask] = (
                 overlay[mask] * (1 - alpha) +
                 np.array(color) * alpha
             ).astype(np.uint8)
             
-            # Kontur
             contours, _ = cv2.findContours(
                 mask.astype(np.uint8),
                 cv2.RETR_EXTERNAL,
@@ -274,10 +284,10 @@ def segment_multi_dense(image, density="medium"):
         
         metadata = {
             "success": True,
-            "mode": "multi_object_dense",
+            "mode": "multi_object_fast",
             "density": density,
             "grid_size": f"{grid_size}x{grid_size}",
-            "total_points": len(points),
+            "total_points": total_points,
             "quality_masks": len(all_masks),
             "avg_score": float(np.mean(all_scores)) if all_scores else 0,
             "scores": [float(s) for s in all_scores]
@@ -296,10 +306,10 @@ demo = gr.Blocks(title="SAM2 Boostly", theme=gr.themes.Soft())
 
 with demo:
     gr.Markdown("# 🎨 SAM2 Segmentierung - Boostly Edition")
-    gr.Markdown("### ⚡ Optimierte Zero-Shot Object Segmentation")
+    gr.Markdown("### ⚡ Smart Filtering & CPU Optimized")
     
-    with gr.Tab("🤖 Automatisch PLUS"):
-        gr.Markdown("**Smart Multi-Mask Combining** - Kombiniert automatisch alle Objektteile!")
+    with gr.Tab("🤖 Automatisch SMART"):
+        gr.Markdown("**Intelligente Filterung** - Nur das Hauptobjekt, keine Jacke/Hintergrund!")
         
         with gr.Row():
             with gr.Column():
@@ -309,23 +319,25 @@ with demo:
                     choices=["high", "fast"],
                     value="high",
                     label="⚙️ Qualität",
-                    info="High = präzisere Kanten, Fast = schneller"
+                    info="High = glattere Kanten"
                 )
                 
-                merge_checkbox = gr.Checkbox(
+                filter_checkbox = gr.Checkbox(
                     value=True,
-                    label="🔗 Teile zusammenfügen",
-                    info="Kombiniert alle erkannten Bereiche (Fisch + Flosse = 1 Objekt)"
+                    label="🔍 Nur größtes Objekt",
+                    info="Filtert Jacke, Hintergrund, kleine Teile"
                 )
                 
                 btn_auto = gr.Button("🚀 Segmentieren", variant="primary", size="lg")
                 
                 gr.Markdown("""
-                **✨ Funktionsweise:**
-                - SAM generiert 3 verschiedene Masken
-                - Wenn "Teile zusammenfügen" AN: Alle kombiniert → vollständiges Objekt
-                - Wenn AUS: Nur präziseste Maske
-                - ⚡ Optimiert: ~10-30 Sekunden statt 25 Minuten!
+                **✨ Smart Features:**
+                - Nimmt MITTLERE Maske (vermeidet Over-Segmentation)
+                - Connected Components Filtering
+                - Entfernt automatisch Jacke/Hintergrund
+                - ⚡ Schnell: ~10-20 Sekunden
+                
+                **Perfekt für:** Einzelne Objekte (Fische, Tiere, Menschen)
                 """)
             
             with gr.Column():
@@ -334,18 +346,12 @@ with demo:
         
         btn_auto.click(
             fn=segment_automatic,
-            inputs=[input_auto, quality_radio, merge_checkbox],
+            inputs=[input_auto, quality_radio, filter_checkbox],
             outputs=[output_auto, json_auto]
         )
-        
-        gr.Examples(
-            examples=[],
-            inputs=input_auto,
-            label="💡 Tipp: Objekt sollte zentral im Bild sein"
-        )
     
-    with gr.Tab("🎯 Multi-Region"):
-        gr.Markdown("**Grid-basierte Segmentierung** - Für mehrere separate Objekte")
+    with gr.Tab("🎯 Multi-Region (Schnell)"):
+        gr.Markdown("**CPU-Optimiert** - Reduzierte Punkte für schnellere Verarbeitung")
         
         with gr.Row():
             with gr.Column():
@@ -353,20 +359,22 @@ with demo:
                 
                 density_radio = gr.Radio(
                     choices=["high", "medium", "low"],
-                    value="medium",
+                    value="low",
                     label="📊 Punkt-Dichte",
-                    info="Mehr Punkte = mehr Details, aber langsamer"
+                    info="Start mit LOW für Tests!"
                 )
                 
-                btn_multi = gr.Button("🎯 Alle Bereiche segmentieren", variant="primary", size="lg")
+                btn_multi = gr.Button("🎯 Segmentieren", variant="primary", size="lg")
                 
                 gr.Markdown("""
-                **Grid-Größen:**
-                - 🔥 High: 5x5 = 25 Erkennungspunkte
-                - ⚡ Medium: 4x4 = 16 Punkte (empfohlen)
-                - 💨 Low: 3x3 = 9 Punkte
+                **⚡ Optimierte Grid-Größen:**
+                - 💨 Low: 2x2 = 4 Punkte (~40s) ← Empfohlen für Tests!
+                - ⚡ Medium: 3x3 = 9 Punkte (~90s)
+                - 🔥 High: 4x4 = 16 Punkte (~160s = 2.5 Min)
                 
-                Jedes Objekt bekommt eigene Farbe!
+                **Perfekt für:** Mehrere separate Objekte
+                
+                **Tipp:** Jedes erkannte Objekt bekommt eigene Farbe!
                 """)
             
             with gr.Column():
@@ -381,18 +389,15 @@ with demo:
     
     with gr.Tab("📡 API Dokumentation"):
         gr.Markdown("### 🔗 API Endpoint")
-        gr.Code(
-            "https://EnginDev-Boostly.hf.space/api/predict",
-            label="Base URL"
-        )
+        gr.Code("https://EnginDev-Boostly.hf.space/api/predict", label="Base URL")
         
-        gr.Markdown("### 📝 JavaScript Integration (für Lovable)")
+        gr.Markdown("### 📝 JavaScript Integration")
         gr.Code('''
-// Segmentation Service
-const HUGGINGFACE_API = 'https://EnginDev-Boostly.hf.space';
+// Segmentation Service für Lovable
+const API_URL = 'https://EnginDev-Boostly.hf.space';
 
 async function segmentImage(imageFile, mode = 'automatic') {
-  // File zu Base64 konvertieren
+  // File zu Base64
   const base64 = await new Promise((resolve) => {
     const reader = new FileReader();
     reader.onloadend = () => resolve(reader.result);
@@ -400,11 +405,11 @@ async function segmentImage(imageFile, mode = 'automatic') {
   });
   
   // API Call
-  const response = await fetch(`${HUGGINGFACE_API}/api/predict`, {
+  const response = await fetch(`${API_URL}/api/predict`, {
     method: 'POST',
     headers: {'Content-Type': 'application/json'},
     body: JSON.stringify({
-      data: [base64, "high", true],  // [image, quality, merge]
+      data: [base64, "high", true],
       fn_index: mode === 'automatic' ? 0 : 1
     })
   });
@@ -412,53 +417,46 @@ async function segmentImage(imageFile, mode = 'automatic') {
   const result = await response.json();
   
   return {
-    segmentedImage: result.data[0],  // Base64 segmentiertes Bild
-    metadata: result.data[1]          // JSON mit Details
+    image: result.data[0],     // Base64 segmentiertes Bild
+    metadata: result.data[1]    // JSON Details
   };
 }
 
-// Verwendung:
-const result = await segmentImage(myImageFile, 'automatic');
-console.log('Mask covers:', result.metadata.mask_percentage + '%');
+// Verwendung
+const result = await segmentImage(myFile, 'automatic');
+console.log('Objekt erkannt:', result.metadata.mask_percentage + '%');
         ''', language="javascript")
         
         gr.Markdown("### ⚙️ Parameter")
         gr.Markdown("""
         **fn_index:**
-        - `0` = Automatisch PLUS (empfohlen für einzelne Objekte)
-        - `1` = Multi-Region (für mehrere Objekte)
+        - `0` = Automatisch SMART (einzelnes Objekt, gefiltert)
+        - `1` = Multi-Region (mehrere Objekte, bunte Farben)
         
-        **quality:**
-        - `"high"` = Präzise Kanten, Gaussian Blur, Refinement (~20-30s)
-        - `"fast"` = Schneller, weniger Nachbearbeitung (~10-15s)
+        **quality:** `"high"` oder `"fast"`
         
-        **merge (nur fn_index=0):**
-        - `true` = Kombiniert alle Masken → vollständiges Objekt
-        - `false` = Nur beste Maske → nur Hauptteil
+        **filter_largest (fn_index=0):** `true` = Nur Hauptobjekt, `false` = Alles
         
-        **density (nur fn_index=1):**
-        - `"high"` = 5x5 Grid = 25 Punkte
-        - `"medium"` = 4x4 Grid = 16 Punkte
-        - `"low"` = 3x3 Grid = 9 Punkte
+        **density (fn_index=1):** `"low"`, `"medium"`, `"high"`
         """)
         
-        gr.Markdown("### 📊 Response Format")
+        gr.Markdown("### 📊 Response Beispiel")
         gr.Code('''
 {
   "data": [
-    "data:image/png;base64,iVBORw0KGgo...",  // Segmentiertes Bild
+    "data:image/png;base64,iVBORw...",
     {
       "success": true,
-      "mode": "automatic_plus",
-      "masks_combined": 3,
-      "mask_percentage": 12.5,
+      "mode": "automatic_smart",
+      "selected_mask_score": 0.864,
+      "mask_percentage": 7.2,
       "num_contours": 1,
-      "all_scores": [0.998, 0.583, 0.864]
+      "filtered": true
     }
   ]
 }
         ''', language="json")
 
 if __name__ == "__main__":
-    print("🌐 Launching Boostly SAM2 v2.1...")
+    print("🌐 Launching Boostly SAM2 v2.2...")
     demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)