Delete app.py

app.py

@@ -1,443 +0,0 @@
-import gradio as gr
-import torch
-import numpy as np
-from PIL import Image
-import cv2
-
-print("🚀 Starting SAM2 App v2.0...")
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"📱 Using device: {device}")
-
-model = None
-processor = None
-
-def load_model():
-    global model, processor
-    if model is None:
-        print("📦 Loading SAM model...")
-        try:
-            from transformers import SamModel, SamProcessor
-            
-            model_name = "facebook/sam-vit-large"
-            
-            processor = SamProcessor.from_pretrained(model_name)
-            model = SamModel.from_pretrained(model_name)
-            model.to(device)
-            print(f"✅ Model loaded: {model_name}")
-        except Exception as e:
-            print(f"❌ Error: {e}, falling back to base model")
-            model_name = "facebook/sam-vit-base"
-            processor = SamProcessor.from_pretrained(model_name)
-            model = SamModel.from_pretrained(model_name)
-            model.to(device)
-    return model, processor
-
-def prepare_image(image, max_size=1024):
-    if isinstance(image, np.ndarray):
-        image_pil = Image.fromarray(image)
-    else:
-        image_pil = image
-    
-    if image_pil.mode != 'RGB':
-        image_pil = image_pil.convert('RGB')
-    
-    image_np = np.array(image_pil)
-    h, w = image_np.shape[:2]
-    
-    if max(h, w) > max_size:
-        scale = max_size / max(h, w)
-        new_h, new_w = int(h * scale), int(w * scale)
-        image_pil = image_pil.resize((new_w, new_h), Image.Resampling.LANCZOS)
-        image_np = np.array(image_pil)
-    
-    return image_pil, image_np
-
-def refine_mask(mask, kernel_size=5):
-    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!
-    """
-    if image is None:
-        return None, {"error": "Kein Bild hochgeladen"}
-    
-    try:
-        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
-        ]
-        
-        all_masks = []
-        all_scores = []
-        
-        print(f"🎯 Using {len(points)} detection points...")
-        
-        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}")
-        
-        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
-        
-        # Refinement
-        if quality == "high":
-            combined_mask = refine_mask(combined_mask, kernel_size=9)
-        
-        # Overlay
-        overlay = image_np.copy()
-        color = np.array([255, 80, 180])  # Rosa/Pink
-        
-        mask_float = combined_mask.astype(float)
-        if quality == "high":
-            mask_float = cv2.GaussianBlur(mask_float, (7, 7), 0)
-        
-        for c in range(3):
-            overlay[:, :, c] = (
-                overlay[:, :, c] * (1 - mask_float * 0.65) +
-                color[c] * mask_float * 0.65
-            )
-        
-        # Kontur
-        contours, _ = cv2.findContours(
-            combined_mask.astype(np.uint8),
-            cv2.RETR_EXTERNAL,
-            cv2.CHAIN_APPROX_SIMPLE
-        )
-        cv2.drawContours(overlay, contours, -1, (255, 255, 0), 3)
-        
-        metadata = {
-            "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],
-            "image_size": [w, h],
-            "mask_area": int(np.sum(combined_mask)),
-            "mask_percentage": float(np.sum(combined_mask) / (h * w) * 100),
-            "num_contours": len(contours),
-            "device": device
-        }
-        
-        print(f"✅ Segmentation complete! {len(contours)} contours")
-        return Image.fromarray(overlay.astype(np.uint8)), metadata
-        
-    except Exception as e:
-        import traceback
-        print(f"❌ ERROR:\n{traceback.format_exc()}")
-        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"}
-    
-    try:
-        model, processor = load_model()
-        image_pil, image_np = prepare_image(image)
-        h, w = image_np.shape[:2]
-        
-        if density == "high":
-            grid_size = 5
-        elif density == "medium":
-            grid_size = 4
-        else:
-            grid_size = 3
-        
-        points = []
-        for i in range(1, grid_size + 1):
-            for j in range(1, grid_size + 1):
-                x = int(w * i / (grid_size + 1))
-                y = int(h * j / (grid_size + 1))
-                points.append([x, y])
-        
-        print(f"📍 Using {len(points)} points for segmentation")
-        
-        all_masks = []
-        all_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().flatten()
-            best_idx = np.argmax(scores)
-            
-            if masks.ndim == 4:
-                mask = masks[0, best_idx].numpy()
-            else:
-                mask = masks[best_idx].numpy()
-            
-            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 = image_np.copy()
-        
-        colors = []
-        for i in range(len(all_masks)):
-            hue = int(180 * i / max(len(all_masks), 1))
-            color_hsv = np.uint8([[[hue, 255, 200]]])
-            color_rgb = cv2.cvtColor(color_hsv, cv2.COLOR_HSV2RGB)[0][0]
-            colors.append(color_rgb)
-        
-        for mask, color, score in zip(all_masks, colors, all_scores):
-            alpha = 0.4 + (score - 0.7) * 0.2
-            overlay[mask] = (
-                overlay[mask] * (1 - alpha) +
-                np.array(color) * alpha
-            ).astype(np.uint8)
-            
-            contours, _ = cv2.findContours(
-                mask.astype(np.uint8),
-                cv2.RETR_EXTERNAL,
-                cv2.CHAIN_APPROX_SIMPLE
-            )
-            cv2.drawContours(overlay, contours, -1, color.tolist(), 2)
-        
-        metadata = {
-            "success": True,
-            "mode": "multi_object_dense",
-            "density": density,
-            "grid_size": f"{grid_size}x{grid_size}",
-            "total_points": len(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]
-        }
-        
-        return Image.fromarray(overlay), metadata
-        
-    except Exception as e:
-        import traceback
-        print(f"❌ ERROR:\n{traceback.format_exc()}")
-        return image, {"error": str(e)}
-
-# Gradio Interface
-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")
-    
-    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")
-                
-                quality_radio = gr.Radio(
-                    choices=["high", "fast"],
-                    value="high",
-                    label="Qualität"
-                )
-                
-                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")
-        
-        btn_auto.click(
-            fn=segment_automatic,
-            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")
-                density_radio = gr.Radio(
-                    choices=["high", "medium", "low"],
-                    value="medium",
-                    label="Punkt-Dichte"
-                )
-                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")
-        
-        btn_multi.click(
-            fn=segment_multi_dense,
-            inputs=[input_multi, density_radio],
-            outputs=[output_multi, json_multi]
-        )
-    
-    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('''
-const response = await fetch('https://EnginDev-Boostly.hf.space/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
-    })
-});
-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 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 Boostly SAM2...")
-    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)