Update app.py

app.py

@@ -4,7 +4,7 @@ import numpy as np
 from PIL import Image
 import cv2
 
-print("🚀 Starting SAM2 App v2.0...")
+print("🚀 Starting SAM2 App v2.1 - OPTIMIZED...")
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"📱 Using device: {device}")
@@ -54,66 +54,17 @@ def prepare_image(image, max_size=1024):
     return image_pil, image_np
 
 def refine_mask(mask, kernel_size=5):
+    """Glättet Maskenkanten"""
     mask_uint8 = (mask > 0).astype(np.uint8) * 255
     kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
     mask_closed = cv2.morphologyEx(mask_uint8, cv2.MORPH_CLOSE, kernel)
     mask_refined = cv2.morphologyEx(mask_closed, cv2.MORPH_OPEN, kernel)
     return mask_refined > 0
 
-def merge_nearby_masks(masks, scores, distance_threshold=100):
-    """
-    Kombiniert Masken die nah beieinander sind
-    → Fisch + Flosse werden EINS!
-    """
-    if len(masks) == 0:
-        return np.zeros_like(masks[0]) if len(masks) > 0 else None
-    
-    # Finde Zentren aller Masken
-    centers = []
-    for mask in masks:
-        y_coords, x_coords = np.where(mask)
-        if len(x_coords) > 0:
-            center_x = int(np.mean(x_coords))
-            center_y = int(np.mean(y_coords))
-            centers.append((center_x, center_y))
-        else:
-            centers.append(None)
-    
-    # Gruppiere Masken die nah beieinander sind
-    combined = np.zeros_like(masks[0], dtype=bool)
-    
-    for i, mask in enumerate(masks):
-        if centers[i] is None:
-            continue
-        
-        # Checke ob diese Maske nah an bereits kombinierten Masken ist
-        if np.sum(combined) > 0:
-            # Distanz zwischen Masken
-            combined_coords = np.argwhere(combined)
-            mask_coords = np.argwhere(mask)
-            
-            if len(combined_coords) > 0 and len(mask_coords) > 0:
-                # Minimale Distanz zwischen den Masken
-                min_dist = float('inf')
-                for mc in mask_coords[::10]:  # Sample alle 10 Punkte
-                    for cc in combined_coords[::10]:
-                        dist = np.linalg.norm(mc - cc)
-                        min_dist = min(min_dist, dist)
-                
-                # Wenn nah genug: kombinieren!
-                if min_dist < distance_threshold:
-                    combined = combined | mask
-                    print(f"  ✅ Merged mask {i} (dist: {min_dist:.1f})")
-        else:
-            # Erste Maske
-            combined = mask
-    
-    return combined
-
 def segment_automatic(image, quality="high", merge_parts=True):
     """
-    Automatische Segmentierung mit Multi-Point Detection
-    merge_parts=True → Kombiniert getrennte Teile wie Flossen!
+    OPTIMIERTE Automatische Segmentierung
+    Schnell & präzise - kombiniert mehrere Masken
     """
     if image is None:
         return None, {"error": "Kein Bild hochgeladen"}
@@ -125,87 +76,84 @@ def segment_automatic(image, quality="high", merge_parts=True):
         image_pil, image_np = prepare_image(image)
         h, w = image_np.shape[:2]
         
-        # MEHRERE Punkte für bessere Abdeckung!
         center_x, center_y = w // 2, h // 2
-        points = [
-            [center_x, center_y],           # Mitte
-            [center_x, center_y - h//4],    # Oben
-            [center_x, center_y + h//4],    # Unten
-            [center_x - w//4, center_y],    # Links
-            [center_x + w//4, center_y]     # Rechts
-        ]
         
-        all_masks = []
-        all_scores = []
+        # Single point inference mit multimask_output
+        inputs = processor(
+            image_pil,
+            input_points=[[[center_x, center_y]]],
+            input_labels=[[1]],
+            return_tensors="pt"
+        ).to(device)
         
-        print(f"🎯 Using {len(points)} detection points...")
+        print("🧠 Running inference...")
+        with torch.no_grad():
+            outputs = model(**inputs, multimask_output=True)
         
-        for idx, point in enumerate(points):
-            inputs = processor(
-                image_pil,
-                input_points=[[point]],
-                input_labels=[[1]],
-                return_tensors="pt"
-            ).to(device)
-            
-            with torch.no_grad():
-                outputs = model(**inputs, multimask_output=True)
-            
-            masks = processor.image_processor.post_process_masks(
-                outputs.pred_masks.cpu(),
-                inputs["original_sizes"].cpu(),
-                inputs["reshaped_input_sizes"].cpu()
-            )[0]
+        masks = processor.image_processor.post_process_masks(
+            outputs.pred_masks.cpu(),
+            inputs["original_sizes"].cpu(),
+            inputs["reshaped_input_sizes"].cpu()
+        )[0]
+        
+        scores = outputs.iou_scores.cpu().numpy()
+        if scores.ndim > 1:
+            scores = scores.flatten()
+        
+        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
             
-            scores = outputs.iou_scores.cpu().numpy()
-            if scores.ndim > 1:
-                scores = scores.flatten()
+            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})")
             
-            # Beste Maske von diesem Punkt
+            final_mask = combined_mask
+            print(f"🔗 Combined {masks_used} masks into one!")
+        else:
+            # Nur beste Maske
             best_idx = np.argmax(scores)
-            
             if masks.ndim == 4:
-                mask = masks[0, best_idx].numpy()
+                final_mask = masks[0, best_idx].numpy() > 0
             else:
-                mask = masks[best_idx].numpy()
-            
-            # Nur gute Masken
-            if scores[best_idx] > 0.6:
-                all_masks.append(mask > 0)
-                all_scores.append(scores[best_idx])
-                print(f"  ✅ Point {idx}: Score {scores[best_idx]:.3f}")
-        
-        print(f"✅ Got {len(all_masks)} quality masks")
-        
-        # MERGE: Kombiniere nahe Masken
-        if merge_parts and len(all_masks) > 0:
-            combined_mask = merge_nearby_masks(all_masks, all_scores, distance_threshold=100)
-        else:
-            combined_mask = np.zeros((h, w), dtype=bool)
-            for mask in all_masks:
-                combined_mask = combined_mask | mask
+                final_mask = masks[best_idx].numpy() > 0
+            masks_used = 1
+            print(f"✅ Using best mask (score: {scores[best_idx]:.3f})")
         
-        # Refinement
+        # Refinement für glatte Kanten
         if quality == "high":
-            combined_mask = refine_mask(combined_mask, kernel_size=9)
+            print("🎨 Refining mask...")
+            final_mask = refine_mask(final_mask, kernel_size=7)
         
-        # Overlay
+        # Overlay erstellen
         overlay = image_np.copy()
         color = np.array([255, 80, 180])  # Rosa/Pink
         
-        mask_float = combined_mask.astype(float)
+        mask_float = final_mask.astype(float)
         if quality == "high":
-            mask_float = cv2.GaussianBlur(mask_float, (7, 7), 0)
+            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
             )
         
-        # Kontur
+        # Gelbe Kontur zeichnen
         contours, _ = cv2.findContours(
-            combined_mask.astype(np.uint8),
+            final_mask.astype(np.uint8),
             cv2.RETR_EXTERNAL,
             cv2.CHAIN_APPROX_SIMPLE
         )
@@ -215,18 +163,16 @@ def segment_automatic(image, quality="high", merge_parts=True):
             "success": True,
             "mode": "automatic_plus" if merge_parts else "automatic",
             "quality": quality,
-            "detection_points": len(points),
-            "masks_found": len(all_masks),
-            "avg_score": float(np.mean(all_scores)) if all_scores else 0,
-            "all_scores": [float(s) for s in all_scores],
+            "masks_combined": masks_used,
+            "all_scores": scores.tolist(),
             "image_size": [w, h],
-            "mask_area": int(np.sum(combined_mask)),
-            "mask_percentage": float(np.sum(combined_mask) / (h * w) * 100),
+            "mask_area": int(np.sum(final_mask)),
+            "mask_percentage": float(np.sum(final_mask) / (h * w) * 100),
             "num_contours": len(contours),
             "device": device
         }
         
-        print(f"✅ Segmentation complete! {len(contours)} contours")
+        print("✅ Segmentation complete!")
         return Image.fromarray(overlay.astype(np.uint8)), metadata
         
     except Exception as e:
@@ -235,15 +181,17 @@ def segment_automatic(image, quality="high", merge_parts=True):
         return image, {"error": str(e)}
 
 def segment_multi_dense(image, density="medium"):
-    """Multi-Object mit dichterem Grid"""
+    """Multi-Object Segmentierung mit Grid"""
     if image is None:
         return None, {"error": "Kein Bild"}
     
     try:
+        print(f"🎯 Starting multi-region segmentation (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
         if density == "high":
             grid_size = 5
         elif density == "medium":
@@ -251,6 +199,7 @@ def segment_multi_dense(image, density="medium"):
         else:
             grid_size = 3
         
+        # Grid-Punkte generieren
         points = []
         for i in range(1, grid_size + 1):
             for j in range(1, grid_size + 1):
@@ -258,11 +207,12 @@ def segment_multi_dense(image, density="medium"):
                 y = int(h * j / (grid_size + 1))
                 points.append([x, y])
         
-        print(f"📍 Using {len(points)} points for segmentation")
+        print(f"📍 Using {len(points)} grid points ({grid_size}x{grid_size})...")
         
         all_masks = []
         all_scores = []
         
+        # Segmentiere jeden Punkt
         for idx, point in enumerate(points):
             inputs = processor(
                 image_pil,
@@ -288,14 +238,17 @@ def segment_multi_dense(image, density="medium"):
             else:
                 mask = masks[best_idx].numpy()
             
+            # Nur Masken mit gutem Score
             if scores[best_idx] > 0.7:
                 all_masks.append(refine_mask(mask))
                 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
         colors = []
         for i in range(len(all_masks)):
             hue = int(180 * i / max(len(all_masks), 1))
@@ -303,13 +256,15 @@ 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
+            alpha = 0.4 + (score - 0.7) * 0.2  # Höherer Score = stärkere Farbe
             overlay[mask] = (
                 overlay[mask] * (1 - alpha) +
                 np.array(color) * alpha
             ).astype(np.uint8)
             
+            # Kontur
             contours, _ = cv2.findContours(
                 mask.astype(np.uint8),
                 cv2.RETR_EXTERNAL,
@@ -328,6 +283,7 @@ def segment_multi_dense(image, density="medium"):
             "scores": [float(s) for s in all_scores]
         }
         
+        print("✅ Multi-region complete!")
         return Image.fromarray(overlay), metadata
         
     except Exception as e:
@@ -340,11 +296,10 @@ demo = gr.Blocks(title="SAM2 Boostly", theme=gr.themes.Soft())
 
 with demo:
     gr.Markdown("# 🎨 SAM2 Segmentierung - Boostly Edition")
-    gr.Markdown("### Zero-Shot Object Segmentation powered by Meta SAM")
+    gr.Markdown("### ⚡ Optimierte Zero-Shot Object Segmentation")
     
     with gr.Tab("🤖 Automatisch PLUS"):
-        gr.Markdown("**Intelligent Multi-Point Detection** - Erkennt und kombiniert alle Objektteile!")
-        gr.Markdown("✨ Perfekt für: Fische mit Flossen, Menschen mit Armen/Beinen, komplexe Objekte")
+        gr.Markdown("**Smart Multi-Mask Combining** - Kombiniert automatisch alle Objektteile!")
         
         with gr.Row():
             with gr.Column():
@@ -353,32 +308,41 @@ with demo:
                 quality_radio = gr.Radio(
                     choices=["high", "fast"],
                     value="high",
-                    label="Qualität"
+                    label="⚙️ Qualität",
+                    info="High = präzisere Kanten, Fast = schneller"
                 )
                 
                 merge_checkbox = gr.Checkbox(
                     value=True,
-                    label="✅ Teile zusammenfügen (Empfohlen!)"
+                    label="🔗 Teile zusammenfügen",
+                    info="Kombiniert alle erkannten Bereiche (Fisch + Flosse = 1 Objekt)"
                 )
                 
                 btn_auto = gr.Button("🚀 Segmentieren", variant="primary", size="lg")
                 
                 gr.Markdown("""
-                **So funktioniert's:**
-                - 🎯 5 Erkennungspunkte (Mitte + 4 Richtungen)
-                - 🔗 Intelligentes Merging naher Bereiche
-                - 🎨 Fisch + Flosse = EIN zusammenhängendes Objekt!
+                **✨ 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!
                 """)
             
             with gr.Column():
-                output_auto = gr.Image(label="✨ Ergebnis")
-                json_auto = gr.JSON(label="📊 Details")
+                output_auto = gr.Image(label="✨ Segmentiertes Bild")
+                json_auto = gr.JSON(label="📊 Metadata")
         
         btn_auto.click(
             fn=segment_automatic,
             inputs=[input_auto, quality_radio, merge_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")
@@ -386,23 +350,28 @@ with demo:
         with gr.Row():
             with gr.Column():
                 input_multi = gr.Image(type="pil", label="📸 Bild hochladen")
+                
                 density_radio = gr.Radio(
                     choices=["high", "medium", "low"],
                     value="medium",
-                    label="Punkt-Dichte"
+                    label="📊 Punkt-Dichte",
+                    info="Mehr Punkte = mehr Details, aber langsamer"
                 )
-                btn_multi = gr.Button("🎯 Alle Bereiche", variant="primary", size="lg")
+                
+                btn_multi = gr.Button("🎯 Alle Bereiche segmentieren", variant="primary", size="lg")
                 
                 gr.Markdown("""
                 **Grid-Größen:**
-                - 🔥 High: 5x5 = 25 Punkte
-                - ⚡ Medium: 4x4 = 16 Punkte  
+                - 🔥 High: 5x5 = 25 Erkennungspunkte
+                - ⚡ Medium: 4x4 = 16 Punkte (empfohlen)
                 - 💨 Low: 3x3 = 9 Punkte
+                
+                Jedes Objekt bekommt eigene Farbe!
                 """)
             
             with gr.Column():
-                output_multi = gr.Image(label="✨ Ergebnis")
-                json_multi = gr.JSON(label="📊 Details")
+                output_multi = gr.Image(label="✨ Segmentiertes Bild")
+                json_multi = gr.JSON(label="📊 Metadata")
         
         btn_multi.click(
             fn=segment_multi_dense,
@@ -410,35 +379,86 @@ with demo:
             outputs=[output_multi, json_multi]
         )
     
-    with gr.Tab("📡 API Integration"):
-        gr.Markdown("### API Endpoint für Lovable/externe Apps")
+    with gr.Tab("📡 API Dokumentation"):
+        gr.Markdown("### 🔗 API Endpoint")
         gr.Code(
             "https://EnginDev-Boostly.hf.space/api/predict",
-            label="API URL"
+            label="Base URL"
         )
         
-        gr.Markdown("### JavaScript Beispiel")
+        gr.Markdown("### 📝 JavaScript Integration (für Lovable)")
         gr.Code('''
-const response = await fetch('https://EnginDev-Boostly.hf.space/api/predict', {
+// Segmentation Service
+const HUGGINGFACE_API = 'https://EnginDev-Boostly.hf.space';
+
+async function segmentImage(imageFile, mode = 'automatic') {
+  // File zu Base64 konvertieren
+  const base64 = await new Promise((resolve) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolve(reader.result);
+    reader.readAsDataURL(imageFile);
+  });
+  
+  // API Call
+  const response = await fetch(`${HUGGINGFACE_API}/api/predict`, {
     method: 'POST',
     headers: {'Content-Type': 'application/json'},
     body: JSON.stringify({
-        data: [imageBase64, "high", true],  // [image, quality, merge]
-        fn_index: 0  // 0 = Automatisch PLUS, 1 = Multi-Region
+      data: [base64, "high", true],  // [image, quality, merge]
+      fn_index: mode === 'automatic' ? 0 : 1
     })
-});
+  });
+  
+  const result = await response.json();
+  
+  return {
+    segmentedImage: result.data[0],  // Base64 segmentiertes Bild
+    metadata: result.data[1]          // JSON mit Details
+  };
+}
 
-const result = await response.json();
-const segmentedImage = result.data[0];  // Base64 Image
-const metadata = result.data[1];        // JSON Details
+// Verwendung:
+const result = await segmentImage(myImageFile, 'automatic');
+console.log('Mask covers:', result.metadata.mask_percentage + '%');
         ''', language="javascript")
         
-        gr.Markdown("### Parameter")
-        gr.Markdown("- **fn_index**: 0 = Automatisch PLUS, 1 = Multi-Region")
-        gr.Markdown("- **quality**: 'high' (präzise) oder 'fast' (schnell)")
-        gr.Markdown("- **merge**: true (Teile kombinieren) oder false")
-        gr.Markdown("- **density**: 'high', 'medium', 'low' (nur Multi-Region)")
+        gr.Markdown("### ⚙️ Parameter")
+        gr.Markdown("""
+        **fn_index:**
+        - `0` = Automatisch PLUS (empfohlen für einzelne Objekte)
+        - `1` = Multi-Region (für mehrere Objekte)
+        
+        **quality:**
+        - `"high"` = Präzise Kanten, Gaussian Blur, Refinement (~20-30s)
+        - `"fast"` = Schneller, weniger Nachbearbeitung (~10-15s)
+        
+        **merge (nur fn_index=0):**
+        - `true` = Kombiniert alle Masken → vollständiges Objekt
+        - `false` = Nur beste Maske → nur Hauptteil
+        
+        **density (nur fn_index=1):**
+        - `"high"` = 5x5 Grid = 25 Punkte
+        - `"medium"` = 4x4 Grid = 16 Punkte
+        - `"low"` = 3x3 Grid = 9 Punkte
+        """)
+        
+        gr.Markdown("### 📊 Response Format")
+        gr.Code('''
+{
+  "data": [
+    "data:image/png;base64,iVBORw0KGgo...",  // Segmentiertes Bild
+    {
+      "success": true,
+      "mode": "automatic_plus",
+      "masks_combined": 3,
+      "mask_percentage": 12.5,
+      "num_contours": 1,
+      "all_scores": [0.998, 0.583, 0.864]
+    }
+  ]
+}
+        ''', language="json")
 
 if __name__ == "__main__":
-    print("🌐 Launching Boostly SAM2...")
+    print("🌐 Launching Boostly SAM2 v2.1...")
     demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)