Update app.py

app.py

@@ -60,70 +60,152 @@ 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"):
+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!
+    """
     if image is None:
         return None, {"error": "Kein Bild hochgeladen"}
     
     try:
-        print(f"🔄 Starting segmentation (quality: {quality})...")
+        print(f"🔄 Starting segmentation (quality: {quality}, merge: {merge_parts})...")
         model, processor = load_model()
         
         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
+        ]
         
-        inputs = processor(
-            image_pil,
-            input_points=[[[center_x, center_y]]],
-            input_labels=[[1]],
-            return_tensors="pt"
-        ).to(device)
-        
-        print("🧠 Running inference...")
-        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]
+        all_masks = []
+        all_scores = []
         
-        scores = outputs.iou_scores.cpu().numpy()
-        if scores.ndim > 1:
-            scores = scores.flatten()
+        print(f"🎯 Using {len(points)} detection points...")
         
-        print(f"✅ Got {len(scores)} masks with scores: {scores}")
+        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]
+            
+            scores = outputs.iou_scores.cpu().numpy()
+            if scores.ndim > 1:
+                scores = scores.flatten()
+            
+            # Beste Maske von diesem Punkt
+            best_idx = np.argmax(scores)
+            
+            if masks.ndim == 4:
+                mask = masks[0, best_idx].numpy()
+            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}")
         
-        best_idx = np.argmax(scores)
-        best_score = scores[best_idx]
+        print(f"✅ Got {len(all_masks)} quality masks")
         
-        if masks.ndim == 4:
-            best_mask = masks[0, best_idx].numpy()
+        # 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:
-            best_mask = masks[best_idx].numpy()
+            combined_mask = np.zeros((h, w), dtype=bool)
+            for mask in all_masks:
+                combined_mask = combined_mask | mask
         
+        # Refinement
         if quality == "high":
-            best_mask_refined = refine_mask(best_mask, kernel_size=7)
-        else:
-            best_mask_refined = best_mask > 0
+            combined_mask = refine_mask(combined_mask, kernel_size=9)
         
+        # Overlay
         overlay = image_np.copy()
-        color = np.array([255, 50, 150])
+        color = np.array([255, 80, 180])  # Rosa/Pink
         
-        mask_float = best_mask_refined.astype(float)
+        mask_float = combined_mask.astype(float)
         if quality == "high":
-            mask_float = cv2.GaussianBlur(mask_float, (5, 5), 0)
+            mask_float = cv2.GaussianBlur(mask_float, (7, 7), 0)
         
         for c in range(3):
             overlay[:, :, c] = (
-                overlay[:, :, c] * (1 - mask_float * 0.6) +
-                color[c] * mask_float * 0.6
+                overlay[:, :, c] * (1 - mask_float * 0.65) +
+                color[c] * mask_float * 0.65
             )
         
+        # Kontur
         contours, _ = cv2.findContours(
-            best_mask_refined.astype(np.uint8),
+            combined_mask.astype(np.uint8),
             cv2.RETR_EXTERNAL,
             cv2.CHAIN_APPROX_SIMPLE
         )
@@ -131,18 +213,20 @@ def segment_automatic(image, quality="high"):
         
         metadata = {
             "success": True,
-            "mode": "automatic",
+            "mode": "automatic_plus" if merge_parts else "automatic",
             "quality": quality,
-            "score": float(best_score),
-            "all_scores": scores.tolist(),
+            "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],
             "image_size": [w, h],
-            "mask_area": int(np.sum(best_mask_refined)),
-            "mask_percentage": float(np.sum(best_mask_refined) / (h * w) * 100),
+            "mask_area": int(np.sum(combined_mask)),
+            "mask_percentage": float(np.sum(combined_mask) / (h * w) * 100),
             "num_contours": len(contours),
             "device": device
         }
         
-        print("✅ Segmentation complete!")
+        print(f"✅ Segmentation complete! {len(contours)} contours")
         return Image.fromarray(overlay.astype(np.uint8)), metadata
         
     except Exception as e:
@@ -151,6 +235,7 @@ def segment_automatic(image, quality="high"):
         return image, {"error": str(e)}
 
 def segment_multi_dense(image, density="medium"):
+    """Multi-Object mit dichterem Grid"""
     if image is None:
         return None, {"error": "Kein Bild"}
     
@@ -251,47 +336,73 @@ def segment_multi_dense(image, density="medium"):
         return image, {"error": str(e)}
 
 # Gradio Interface
-demo = gr.Blocks(title="SAM2 v2.0", theme=gr.themes.Soft())
+demo = gr.Blocks(title="SAM2 Boostly", theme=gr.themes.Soft())
 
 with demo:
-    gr.Markdown("# 🎨 SAM2 Segmentierung v2.0")
-    gr.Markdown("### Verbesserte Qualität mit Large Model")
+    gr.Markdown("# 🎨 SAM2 Segmentierung - Boostly Edition")
+    gr.Markdown("### Zero-Shot Object Segmentation powered by Meta SAM")
     
-    with gr.Tab("🤖 Automatisch"):
+    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")
+        
         with gr.Row():
             with gr.Column():
-                input_auto = gr.Image(type="pil", label="Bild hochladen")
+                input_auto = gr.Image(type="pil", label="📸 Bild hochladen")
+                
                 quality_radio = gr.Radio(
                     choices=["high", "fast"],
                     value="high",
                     label="Qualität"
                 )
-                btn_auto = gr.Button("Segmentieren", variant="primary", size="lg")
+                
+                merge_checkbox = gr.Checkbox(
+                    value=True,
+                    label="✅ Teile zusammenfügen (Empfohlen!)"
+                )
+                
+                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!
+                """)
             
             with gr.Column():
-                output_auto = gr.Image(label="Ergebnis")
-                json_auto = gr.JSON(label="Details")
+                output_auto = gr.Image(label="✨ Ergebnis")
+                json_auto = gr.JSON(label="📊 Details")
         
         btn_auto.click(
             fn=segment_automatic,
-            inputs=[input_auto, quality_radio],
+            inputs=[input_auto, quality_radio, merge_checkbox],
             outputs=[output_auto, json_auto]
         )
     
     with gr.Tab("🎯 Multi-Region"):
+        gr.Markdown("**Grid-basierte Segmentierung** - Für mehrere separate Objekte")
+        
         with gr.Row():
             with gr.Column():
-                input_multi = gr.Image(type="pil", label="Bild hochladen")
+                input_multi = gr.Image(type="pil", label="📸 Bild hochladen")
                 density_radio = gr.Radio(
                     choices=["high", "medium", "low"],
                     value="medium",
                     label="Punkt-Dichte"
                 )
-                btn_multi = gr.Button("Alle Bereiche", variant="primary", size="lg")
+                btn_multi = gr.Button("🎯 Alle Bereiche", variant="primary", size="lg")
+                
+                gr.Markdown("""
+                **Grid-Größen:**
+                - 🔥 High: 5x5 = 25 Punkte
+                - ⚡ Medium: 4x4 = 16 Punkte  
+                - 💨 Low: 3x3 = 9 Punkte
+                """)
             
             with gr.Column():
-                output_multi = gr.Image(label="Ergebnis")
-                json_multi = gr.JSON(label="Details")
+                output_multi = gr.Image(label="✨ Ergebnis")
+                json_multi = gr.JSON(label="📊 Details")
         
         btn_multi.click(
             fn=segment_multi_dense,
@@ -299,28 +410,35 @@ with demo:
             outputs=[output_multi, json_multi]
         )
     
-    with gr.Tab("📡 API"):
-        gr.Markdown("### API Endpoint")
-        gr.Markdown("URL: https://EnginDev-Boostly.hf.space/api/predict")
+    with gr.Tab("📡 API Integration"):
+        gr.Markdown("### API Endpoint für Lovable/externe Apps")
+        gr.Code(
+            "https://EnginDev-Boostly.hf.space/api/predict",
+            label="API URL"
+        )
+        
         gr.Markdown("### JavaScript Beispiel")
         gr.Code('''
-fetch('https://EnginDev-Boostly.hf.space/api/predict', {
+const response = await fetch('https://EnginDev-Boostly.hf.space/api/predict', {
     method: 'POST',
     headers: {'Content-Type': 'application/json'},
     body: JSON.stringify({
-        data: [imageBase64, "high"],
-        fn_index: 0
+        data: [imageBase64, "high", true],  // [image, quality, merge]
+        fn_index: 0  // 0 = Automatisch PLUS, 1 = Multi-Region
     })
-})
-.then(r => r.json())
-.then(result => console.log(result.data));
+});
+
+const result = await response.json();
+const segmentedImage = result.data[0];  // Base64 Image
+const metadata = result.data[1];        // JSON Details
         ''', language="javascript")
         
         gr.Markdown("### Parameter")
-        gr.Markdown("- fn_index: 0 = Automatisch, 1 = Multi-Region")
-        gr.Markdown("- quality: high oder fast")
-        gr.Markdown("- density: high, medium, low")
+        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)")
 
 if __name__ == "__main__":
-    print("🌐 Launching v2.0...")
+    print("🌐 Launching Boostly SAM2...")
     demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)