Update controlnet_facefix.py

controlnet_facefix.py

@@ -1,13 +1,14 @@
-# controlnet_facefix.py - NUR QUALITÄTSVERBESSERUNG MIT OPENPOSE + DEPTH
+# controlnet_facefix.py - PURE QUALITY ENHANCEMENT WITH MINIMAL CHANGE
 import torch
-from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
-from PIL import Image
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, AutoencoderKL
+from PIL import Image, ImageFilter, ImageEnhance
 import time
 import cv2
 import numpy as np
+from torchvision import transforms
 
 print("="*60)
-print("FACE-FIX: QUALITÄTSVERBESSERUNG MIT OPENPOSE + DEPTH")
+print("FACE-FIX: REINE QUALITÄTSVERBESSERUNG - MINIMALE ÄNDERUNG")
 print("="*60)
 
 _components_loaded = False
@@ -16,253 +17,212 @@ _controlnet_pose = None
 _pipeline = None
 
 def _initialize_components():
-    """Lade OpenPose und Depth ControlNets"""
+    """Lade nur notwendige Komponenten"""
     global _components_loaded, _controlnet_depth, _controlnet_pose
     
     if _components_loaded:
         return True
-        
-    try:
-        print("1. Lade ControlNet Depth (für 3D-Struktur)...")
-        _controlnet_depth = ControlNetModel.from_pretrained(
-            "lllyasviel/sd-controlnet-depth",
-            torch_dtype=torch.float16
-        )
-        print("   ✅ ControlNet Depth OK")
-    except Exception as e:
-        print(f"   ❌ ControlNet Depth Fehler: {e}")
-        return False
+    
+    print("⚠️ Lade nur OpenPose (Depth wird deaktiviert)...")
     
     try:
-        print("2. Lade ControlNet OpenPose (für Pose-Erhaltung)...")
+        # NUR OPENPOSE - Depth verändert zu viel
         _controlnet_pose = ControlNetModel.from_pretrained(
             "lllyasviel/sd-controlnet-openpose",
             torch_dtype=torch.float16
         )
-        print("   ✅ ControlNet OpenPose OK")
+        print("✅ OpenPose geladen")
+        
+        # Depth wird NICHT geladen - es verändert den Hintergrund zu stark
+        _controlnet_depth = None
+        
+        _components_loaded = True
+        return True
     except Exception as e:
-        print(f"   ❌ ControlNet OpenPose Fehler: {e}")
+        print(f"❌ Fehler: {e}")
         return False
-    
-    _components_loaded = True
-    print("✅ OPENPOSE + DEPTH GELADEN")
-    return True
 
-def _extract_depth_map(image):
-    """Depth Map für maximale Strukturerhaltung"""
+def _extract_precise_pose(image):
+    """SEHR PRÄZISE Pose-Extraktion nur für Gesicht"""
     try:
         img_array = np.array(image.convert("RGB"))
-        
-        # Konvertiere zu Graustufen
         gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
         
-        # Wende Gaußschen Blur an für weichere Depth Map
-        blurred = cv2.GaussianBlur(gray, (7, 7), 0)
-        
-        # Adaptive Histogram Equalization für bessere Tiefenwahrnehmung
-        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-        enhanced = clahe.apply(blurred)
-        
-        # Invertiere für bessere Depth-Darstellung (helle = nah, dunkel = fern)
-        inverted = 255 - enhanced
+        # EXTREM NIEDRIGE Thresholds für minimale Kanten
+        edges = cv2.Canny(gray, 15, 45)  # Nur feinste Kanten
         
-        # Normalisiere
-        depth_normalized = cv2.normalize(inverted, None, 0, 255, cv2.NORM_MINMAX)
-        
-        # Zu RGB konvertieren
-        depth_rgb = cv2.cvtColor(depth_normalized.astype(np.uint8), cv2.COLOR_GRAY2RGB)
-        
-        return Image.fromarray(depth_rgb)
-    except Exception as e:
-        print(f"Depth Map Fehler: {e}")
-        # Fallback: einfache Graustufen
-        return image.convert("L").convert("RGB")
+        # Face detection für Fokus
+        face_cascade = cv2.CascadeClassifier(
+            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
+        )
+        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+        
+        # Erstelle leere Pose Map
+        pose_map = np.zeros_like(img_array)
+        
+        # Nur Gesichtskanten einfügen
+        if len(faces) > 0:
+            for (x, y, w, h) in faces:
+                # Extrahiere Gesichtsregion
+                face_region = edges[y:y+h, x:x+w]
+                # Nur 10% der stärksten Kanten behalten
+                threshold = np.percentile(face_region[face_region > 0], 90)
+                face_region[face_region < threshold] = 0
+                pose_map[y:y+h, x:x+w, 0] = face_region
+        else:
+            # Falls kein Gesicht erkannt, minimale Kanten
+            pose_map[..., 0] = edges * 0.3  # Noch schwächer
+        
+        return Image.fromarray(pose_map)
+    except:
+        # Fallback: minimale Kanten
+        gray = cv2.cvtColor(np.array(image.convert("RGB")), cv2.COLOR_RGB2GRAY)
+        edges = cv2.Canny(gray, 10, 30) * 0.2  # Sehr schwach
+        return Image.fromarray(edges).convert("RGB")
 
-def _extract_pose_map(image):
-    """Pose Map mit Fokus auf Gesichtskonturen"""
+def _apply_face_enhancement(image):
+    """EINFACHE Face Enhancement ohne AI"""
     try:
         img_array = np.array(image.convert("RGB"))
         
-        # Mehrere Canny-Ebenen für verschiedene Detailstufen
-        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
-        
-        # 1. Feine Gesichtsdetails (niedriger Threshold)
-        fine_details = cv2.Canny(gray, 20, 60)
-        
-        # 2. Mittlere Konturen
-        medium_contours = cv2.Canny(gray, 40, 100)
-        
-        # 3. Starke Kanten
-        strong_edges = cv2.Canny(gray, 80, 160)
-        
-        # Kombiniere mit Gewichtung (feine Details stärker gewichtet)
-        combined = cv2.addWeighted(fine_details, 0.6, medium_contours, 0.3, 0)
-        combined = cv2.addWeighted(combined, 0.8, strong_edges, 0.2, 0)
-        
-        # Minimal dilation für Kontinuität
-        kernel = np.ones((1, 1), np.uint8)
-        pose_edges = cv2.dilate(combined, kernel, iterations=1)
-        
-        # Konvertiere zu RGB
-        pose_rgb = cv2.cvtColor(pose_edges, cv2.COLOR_GRAY2RGB)
-        
-        return Image.fromarray(pose_rgb)
-    except Exception as e:
-        print(f"Pose Map Fehler: {e}")
-        # Fallback
-        edges = cv2.Canny(np.array(image.convert("RGB")), 50, 150)
-        return Image.fromarray(edges).convert("RGB")
+        # 1. Scharfe Kanten (nur leicht)
+        sharpened = cv2.filter2D(img_array, -1, 
+            np.array([[-0.5, -0.5, -0.5],
+                      [-0.5,  5.0, -0.5],
+                      [-0.5, -0.5, -0.5]]) / 3.0)
+        
+        # 2. Leichter De-Noise
+        denoised = cv2.fastNlMeansDenoisingColored(sharpened, None, 3, 3, 7, 21)
+        
+        # 3. Kontrast leicht erhöhen
+        lab = cv2.cvtColor(denoised, cv2.COLOR_RGB2LAB)
+        l, a, b = cv2.split(lab)
+        clahe = cv2.createCLAHE(clipLimit=1.0, tileGridSize=(8,8))
+        l = clahe.apply(l)
+        enhanced = cv2.merge([l, a, b])
+        enhanced = cv2.cvtColor(enhanced, cv2.COLOR_LAB2RGB)
+        
+        return Image.fromarray(enhanced)
+    except:
+        return image
 
 def apply_facefix(image: Image.Image, prompt: str, negative_prompt: str, seed: int, model_id: str):
     """
-    QUALITÄTSVERBESSERUNG MIT MAXIMALER INHALTSERHALTUNG
+    SUPER-SUBTILE QUALITÄTSVERBESSERUNG
     
-    Verwendet:
-    1. OpenPose: Behält exakte Pose und Gesichtsstruktur
-    2. Depth: Behält 3D-Struktur und räumliche Anordnung
-    
-    Strategie: MAXIMALE ControlNet-Stärke + Qualitäts-prompts
+    Strategie:
+    1. NUR OpenPose (kein Depth - das verändert zu viel)
+    2. SEHR niedrige ControlNet-Stärke
+    3. Fast kein CFG Scale
+    4. Identischer Prompt
     """
-    print("\n" + "🔧"*50)
-    print("FACE-FIX: QUALITÄTSVERBESSERUNG MIT OPENPOSE+DEPTH")
-    print(f"  Original: {image.size}")
-    print(f"  Seed: {seed}")
-    print("🔧"*50)
+    print("\n" + "🎯"*50)
+    print("SUBTILE QUALITÄTSVERBESSERUNG")
+    print(f"  Größe: {image.size}")
+    print("🎯"*50)
     
     start_time = time.time()
     
-    # 1. Komponenten initialisieren
+    # OPTION 1: Einfache non-AI Verbesserung (empfohlen)
+    print("\n⚡ OPTION 1: Einfache non-AI Verbesserung...")
+    enhanced = _apply_face_enhancement(image)
+    
+    # Optional: AI-Verbesserung nur wenn nötig
+    use_ai_enhancement = False  # Auf False setzen für minimale Änderung
+    
+    if not use_ai_enhancement:
+        duration = time.time() - start_time
+        print(f"✅ Non-AI Verbesserung in {duration:.1f}s")
+        return enhanced
+    
+    # OPTION 2: Minimale AI-Verbesserung (falls gewünscht)
+    print("⚠️  Starte MINIMALE AI-Verbesserung...")
+    
     if not _initialize_components():
-        print("❌ OpenPose/Depth konnten nicht geladen werden")
-        return image
+        return enhanced
     
-    # 2. Control Maps erstellen
-    print("\n📐 Erstelle Control Maps...")
+    # Control Map vorbereiten
     original_size = image.size
-    
-    # Standardgröße für ControlNet
     control_size = (512, 512)
     resized_image = image.resize(control_size, Image.Resampling.LANCZOS)
     
-    # Depth Map (für 3D-Struktur)
-    depth_img = _extract_depth_map(resized_image)
-    
-    # Pose Map (für Gesichts- und Körperstruktur)
-    pose_img = _extract_pose_map(resized_image)
-    
-    # Optional: Debug speichern
-    depth_img.save("debug_depth_enhanced.png")
-    pose_img.save("debug_pose_enhanced.png")
+    # MINIMALE Pose Map
+    pose_img = _extract_precise_pose(resized_image)
+    pose_img.save("debug_minimal_pose.png")
     
-    # 3. Pipeline erstellen
+    # Pipeline (nur falls nicht geladen)
     global _pipeline
     if _pipeline is None:
         try:
-            print("🔄 Lade Pipeline mit OpenPose + Depth...")
+            print("🔄 Lade Pipeline...")
             _pipeline = StableDiffusionControlNetPipeline.from_pretrained(
                 model_id,
-                controlnet=[_controlnet_pose, _controlnet_depth],  # OpenPose zuerst, dann Depth
+                controlnet=[_controlnet_pose],  # NUR OpenPose!
                 torch_dtype=torch.float16,
                 safety_checker=None,
                 requires_safety_checker=False,
             )
             
-            # Optimierungen
             _pipeline.enable_attention_slicing()
             _pipeline.enable_vae_slicing()
             
-            print("✅ Pipeline mit OpenPose+Depth geladen")
+            print("✅ Pipeline geladen")
         except Exception as e:
             print(f"❌ Pipeline Fehler: {e}")
-            return image
+            return enhanced
     
     try:
-        # 4. Auf Device bewegen
         device = "cuda" if torch.cuda.is_available() else "cpu"
         print(f"  Device: {device}")
         pipeline = _pipeline.to(device)
         
-        # 5. PROMPT-STRATEGIE FÜR QUALITÄTSVERBESSERUNG:
-        # Original-Prompt + Qualitäts-Keywords, ABER KEINE neuen Inhalte
+        # KRITISCHE ÄNDERUNGEN:
+        # 1. GLEICHER PROMPT wie ursprünglich
+        # 2. SEHR niedrige ControlNet-Stärke
+        # 3. FAST KEIN CFG
         
-        # Basierend auf originalem Prompt, aber fokus auf Qualität
-        if "face" in prompt.lower() or "portrait" in prompt.lower():
-            quality_prompt = f"{prompt}, professional portrait, sharp focus, detailed skin, perfect face, clear eyes, high resolution, 8k"
-        else:
-            quality_prompt = f"{prompt}, high quality, sharp focus, detailed, professional photography, no artifacts"
-        
-        # Negative Prompts für Qualitätsverbesserung
-        quality_negative = (
-            f"{negative_prompt}, "
-            "blurry, out of focus, lowres, low quality, jpeg artifacts, "
-            "compression artifacts, pixelated, grainy, noisy, "
-            "deformed, distorted, bad anatomy, mutation, ugly"
-        )
-        
-        # 6. KRITISCHE PARAMETER FÜR INHALTSERHALTUNG:
-        # Hohe ControlNet-Stärken für maximale Kontrolle
-        # OpenPose: Hoch für Pose-Erhaltung
-        # Depth: Hoch für Strukturerhaltung
-        
-        print("\n⚙️  Starte Qualitätsverbesserung mit Parametern:")
-        print(f"   • OpenPose Strength: 0.95 (sehr hoch für Pose-Erhaltung)")
-        print(f"   • Depth Strength: 0.85 (hoch für 3D-Struktur)")
-        print(f"   • Steps: 25")
-        print(f"   • CFG: 5.0 (niedrig für weniger 'Kreativität')")
+        print("\n⚙️  EXTREM SUBTILE PARAMETER:")
+        print("   • OpenPose Strength: 0.3 (SEHR NIEDRIG)")
+        print("   • Steps: 15 (wenig)")
+        print("   • CFG: 2.0 (fast kein Guidance)")
+        print("   • Gleicher Seed")
         
         result = pipeline(
-            prompt=quality_prompt,
-            negative_prompt=quality_negative,
-            image=[pose_img, depth_img],  # OpenPose zuerst, dann Depth
-            controlnet_conditioning_scale=[0.95, 0.85],  # SEHR HOHE WERTE
-            num_inference_steps=25,                      # Ausreichend für Qualität
-            guidance_scale=5.0,                         # NIEDRIG für minimale Änderung
-            generator=torch.Generator(device).manual_seed(seed),  # GLEICHER SEED
+            prompt=prompt,  # WICHTIG: GLEICHER PROMPT!
+            negative_prompt=f"{negative_prompt}, deformed, blurry",
+            image=[pose_img],  # Nur Pose
+            controlnet_conditioning_scale=[0.3],  # EXTREM NIEDRIG
+            num_inference_steps=15,               # WENIG Steps
+            guidance_scale=2.0,                   # FAST KEIN CFG
+            generator=torch.Generator(device).manual_seed(seed + 100),  # Leicht anderer Seed
             height=512,
             width=512,
         ).images[0]
         
-        # 7. Zurück auf Originalgröße
+        # Zurück auf Originalgröße
         if original_size != (512, 512):
             result = result.resize(original_size, Image.Resampling.LANCZOS)
         
-        duration = time.time() - start_time
+        # 50/50 Blend mit Original für noch weniger Änderung
+        result_array = np.array(result).astype(float)
+        original_array = np.array(image).astype(float)
         
-        print(f"\n" + "✅"*50)
-        print("✅ QUALITÄTSVERBESSERUNG ABGESCHLOSSEN")
-        print(f"✅ Dauer: {duration:.1f}s")
-        print(f"✅ Parameter: OpenPose=0.95, Depth=0.85")
-        print(f"✅ Gleicher Seed: {seed}")
-        print(f"✅ Größe: {original_size} → {result.size}")
-        print("✅"*50)
+        # 70% Original, 30% AI-result
+        blended = (original_array * 0.7 + result_array * 0.3).astype(np.uint8)
+        final_result = Image.fromarray(blended)
         
-        # Optional: Vergleich erstellen
-        try:
-            comparison = Image.new('RGB', (original_size[0] * 2, original_size[1]))
-            comparison.paste(image, (0, 0))
-            comparison.paste(result, (original_size[0], 0))
-            
-            # Füge Beschriftung hinzu
-            from PIL import ImageDraw, ImageFont
-            draw = ImageDraw.Draw(comparison)
-            
-            # Einfache Beschriftung
-            draw.text((10, 10), "Vorher", fill=(255, 255, 255))
-            draw.text((original_size[0] + 10, 10), "Nachher", fill=(255, 255, 255))
-            
-            comparison.save("quality_improvement_comparison.png")
-            print(f"📊 Vergleich gespeichert: quality_improvement_comparison.png")
-        except Exception as e:
-            print(f"⚠️  Konnte Vergleich nicht speichern: {e}")
+        duration = time.time() - start_time
+        print(f"\n✅ SUBTILE VERBESSERUNG in {duration:.1f}s")
+        print(f"   • 70% Original, 30% AI")
+        print(f"   • OpenPose: 0.3")
+        print(f"   • CFG: 2.0")
         
-        return result
+        return final_result
         
     except Exception as e:
-        print(f"\n❌ FEHLER: {e}")
-        import traceback
-        traceback.print_exc()
-        return image
+        print(f"\n❌ AI-Verbesserung fehlgeschlagen: {e}")
+        return enhanced
 
 print("="*60)
-print("FACE-FIX BEREIT (OpenPose + Depth)")
+print("FACE-FIX: REINE QUALITÄTSVERBESSERUNG")
 print("="*60)