Update controlnet_module.py

controlnet_module.py

@@ -1152,42 +1152,42 @@ class ControlNetProcessor:
                 raw_mask_array = mask_array.copy()
 
                 # ============================================================
-                #        POSTPROCESSING auf Crop-Größe
+                #        POSTPROCESSING unterschiedlich für Crop/Original
                 # ============================================================
-
-                print("👤 POSTPROCESSING AUF CROP-GRÖSSE")
+                if use_crop_strategy:
+                    print("👤 POSTPROCESSING AUF CROP-GRÖSSE")
         
-                # 1. Größte zusammenhängende Komponente finden
-                labeled_array, num_features = ndimage.label(mask_array)
+                    # 1. Größte zusammenhängende Komponente finden
+                    labeled_array, num_features = ndimage.label(mask_array)
         
-                if num_features > 0:
-                    print(f"   🔍 Gefundene Komponenten: {num_features}")
+                    if num_features > 0:
+                        print(f"   🔍 Gefundene Komponenten: {num_features}")
             
-                    sizes = ndimage.sum(mask_array, labeled_array, range(1, num_features + 1))
-                    largest_component_idx = np.argmax(sizes) + 1
+                        sizes = ndimage.sum(mask_array, labeled_array, range(1, num_features + 1))
+                        largest_component_idx = np.argmax(sizes) + 1
             
-                    print(f"   👑 Größte Komponente: Nr. {largest_component_idx} mit {sizes[largest_component_idx-1]:,} Pixel")
+                        print(f"   👑 Größte Komponente: Nr. {largest_component_idx} mit {sizes[largest_component_idx-1]:,} Pixel")
             
-                    # NUR die größte Komponente behalten (der Kopf)
-                    mask_array = np.where(labeled_array == largest_component_idx, mask_array, 0)
+                        # NUR die größte Komponente behalten (der Kopf)
+                        mask_array = np.where(labeled_array == largest_component_idx, mask_array, 0)
             
-                    # MORPHOLOGISCHE OPERATIONEN FÜR SAUBEREN KOPF
-                    print("   ⚙️  Morphologische Operationen für sauberen Kopf")
+                        # MORPHOLOGISCHE OPERATIONEN FÜR SAUBEREN KOPF
+                        print("   ⚙️  Morphologische Operationen für sauberen Kopf")
             
-                    # Zuerst CLOSE, um kleine Löcher im Kopf zu füllen
-                    kernel_close = np.ones((7, 7), np.uint8)
-                    mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_CLOSE, kernel_close, iterations=1)
-                    print("     • MORPH_CLOSE (7x7) - Löcher im Kopf füllen")
+                        # Zuerst CLOSE, um kleine Löcher im Kopf zu füllen
+                        kernel_close = np.ones((7, 7), np.uint8)
+                        mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_CLOSE, kernel_close, iterations=1)
+                        print("     • MORPH_CLOSE (7x7) - Löcher im Kopf füllen")
             
-                    # Dann OPEN, um kleine Ausreißer zu entfernen
-                    kernel_open = np.ones((5, 5), np.uint8)
-                    mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_OPEN, kernel_open, iterations=1)
-                    print("     • MORPH_OPEN (5x5) - Rauschen entfernen")
+                        # Dann OPEN, um kleine Ausreißer zu entfernen
+                        kernel_open = np.ones((5, 5), np.uint8)
+                        mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_OPEN, kernel_open, iterations=1)
+                        print("     • MORPH_OPEN (5x5) - Rauschen entfernen")
 
-                    # LEICHTER DILATE FÜR MEHR ABDECKUNG (wichtig für Gesicht!)
-                    print("   🔲 Leichter Dilate für natürliche Abdeckung")
-                    kernel_dilate = np.ones((5, 5), np.uint8)  # Größerer Kernel für Gesicht
-                    mask_array = cv2.dilate(mask_array, kernel_dilate, iterations=1)
+                        # LEICHTER DILATE FÜR MEHR ABDECKUNG (wichtig für Gesicht!)
+                        print("   🔲 Leichter Dilate für natürliche Abdeckung")
+                        kernel_dilate = np.ones((5, 5), np.uint8)  # Größerer Kernel für Gesicht
+                        mask_array = cv2.dilate(mask_array, kernel_dilate, iterations=1)
 
 
                     #Speicherung der Binärmaske für Inpaint da keine Graupixel
@@ -1228,35 +1228,97 @@ class ControlNetProcessor:
                         # Nochmal weichzeichnen
                         mask_array = cv2.GaussianBlur(mask_array, (11, 11), 2.0)
 
-                # ============================================================
-                # Maske und Rohmaske auf Originalgröße transformieren
-                # ============================================================
-                print("🔄 MASKE AUF ORIGINALGRÖSSE TRANSFORMIEREN")
+                    # ============================================================
+                    # Maske und Rohmaske auf Originalgröße transformieren (nur für Crop)
+                    # ============================================================
+                    print("🔄 MASKE AUF ORIGINALGRÖSSE TRANSFORMIEREN")
                 
-                # 1. Maske in Crop-Größe wird konveriert von NumPy nach PIL
-                mask_crop_pil = Image.fromarray(mask_array).convert("L")
+                    # 1. Maske in Crop-Größe wird konveriert von NumPy nach PIL
+                    mask_crop_pil = Image.fromarray(mask_array).convert("L")
     
-                # Leere Maske in Originalgröße
-                mask_original = Image.new("L", original_image.size, 0)
+                    # Leere Maske in Originalgröße
+                    mask_original = Image.new("L", original_image.size, 0)
     
-                # Crop-Maske an richtiger Position in leerem Originalbild einfügen
-                # da Hauptprogramm Originalgröße erwartet.
-                mask_original.paste(mask_crop_pil, (crop_x1, crop_y1))
+                    # Crop-Maske an richtiger Position in leerem Originalbild einfügen
+                    # da Hauptprogramm Originalgröße erwartet.
+                    mask_original.paste(mask_crop_pil, (crop_x1, crop_y1))
     
-                # 2. Rohmaske ebenfalls transformieren
-                raw_mask_crop_pil = Image.fromarray(raw_mask_array).convert("L")
-                raw_mask_original = Image.new("L", original_image.size, 0)
-                raw_mask_original.paste(raw_mask_crop_pil, (crop_x1, crop_y1))
-
-                #Binärmaske für Inpaint auf Originalgröße bringen
-                #konvertieren zu PIL-Image
-                inpaint_binary_crop_pil = Image.fromarray(inpaint_binary_mask).convert("L")
-                #Leeres schwarzes Bild in Originalgröße erstellen
-                inpaint_binary_original = Image.new("L", original_image.size, 0)
-                #Klebe Crop-SAM-Maske auf schwarzes Bild in Originalgröße
-                inpaint_binary_original.paste(inpaint_binary_crop_pil, (crop_x1, crop_y1))
-
-                         
+                    # 2. Rohmaske ebenfalls transformieren
+                    raw_mask_crop_pil = Image.fromarray(raw_mask_array).convert("L")
+                    raw_mask_original = Image.new("L", original_image.size, 0)
+                    raw_mask_original.paste(raw_mask_crop_pil, (crop_x1, crop_y1))
+
+                    #Binärmaske für Inpaint auf Originalgröße bringen
+                    #konvertieren zu PIL-Image
+                    inpaint_binary_crop_pil = Image.fromarray(inpaint_binary_mask).convert("L")
+                    #Leeres schwarzes Bild in Originalgröße erstellen
+                    inpaint_binary_original = Image.new("L", original_image.size, 0)
+                    #Klebe Crop-SAM-Maske auf schwarzes Bild in Originalgröße
+                    inpaint_binary_original.paste(inpaint_binary_crop_pil, (crop_x1, crop_y1))
+
+                else: #keine use_crop_stategy Bild<=512
+                    print("👤 POSTPROCESSING AUF ORIGINALGRÖSSE (≤512px)")
+                    
+                    # POSTPROCESSING-LOGIK FÜR ORIGINALGRÖSSE
+                    labeled_array, num_features = ndimage.label(mask_array)
+        
+                    if num_features > 0:
+                        print(f"   🔍 Gefundene Komponenten: {num_features}")
+                        sizes = ndimage.sum(mask_array, labeled_array, range(1, num_features + 1))
+                        largest_component_idx = np.argmax(sizes) + 1
+                        print(f"   👑 Größte Komponente: Nr. {largest_component_idx} mit {sizes[largest_component_idx-1]:,} Pixel")
+            
+                        mask_array = np.where(labeled_array == largest_component_idx, mask_array, 0)
+            
+                        # ANGEPASSTE Morphologische Operationen für Originalgröße
+                        kernel_close = np.ones((5, 5), np.uint8)
+                        mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_CLOSE, kernel_close, iterations=1)
+                        print("     • MORPH_CLOSE (5x5) - Löcher im Kopf füllen")
+            
+                        kernel_open = np.ones((3, 3), np.uint8)
+                        mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_OPEN, kernel_open, iterations=1)
+                        print("     • MORPH_OPEN (3x3) - Rauschen entfernen")
+
+                        # Leichter Dilate für mehr Abdeckung
+                        kernel_dilate = np.ones((3, 3), np.uint8)
+                        mask_array = cv2.dilate(mask_array, kernel_dilate, iterations=1)
+                        print("     • DILATE (3x3) - Natürliche Abdeckung")
+
+                    # Binärmaske für Inpaint speichern (vor Blur)
+                    inpaint_binary_mask = mask_array.copy()
+                    
+                    # ANGEPASSTER Gaussian Blur für Originalgröße
+                    mask_array = cv2.GaussianBlur(mask_array, (11, 11), 2.0)
+                    print("     • GAUSSIAN BLUR (11x11, sigma=2.0) - Weiche Übergänge")
+
+                    # Gamma-Korrektur
+                    mask_array_float = mask_array.astype(np.float32) / 255.0
+                    mask_array_float = np.clip(mask_array_float, 0.0, 1.0)
+                    mask_array_float = mask_array_float ** 0.8
+                    mask_array = (mask_array_float * 255).astype(np.uint8)
+                    print("     • GAMMA (0.8) - Glatte Übergänge")
+
+                    # Finaler weicher Blur
+                    mask_array = cv2.GaussianBlur(mask_array, (7, 7), 1.0)
+                    print("     • FINALER BLUR (7x7, sigma=1.0)")
+
+                    # Prüfe Maskendichte
+                    white_pixels = np.sum(mask_array > 128)
+                    coverage_ratio = white_pixels / heur_bbox_area if heur_bbox_area > 0 else 0
+                    print(f"   📊 Aktuelle Abdeckung: {white_pixels:,}px / {heur_bbox_area:,}px = {coverage_ratio:.1%}")
+
+                    if coverage_ratio < 0.9:
+                        print(f"   ⚠️  Maske zu dünn für Gesicht (<90%)")
+                        kernel_extra = np.ones((5, 5), np.uint8)
+                        mask_array = cv2.dilate(mask_array, kernel_extra, iterations=1)
+                        mask_array = cv2.GaussianBlur(mask_array, (7, 7), 1.5)
+
+                    # Masken sind bereits in Originalgröße
+                    mask_original = Image.fromarray(mask_array).convert("L")
+                    raw_mask_original = Image.fromarray(raw_mask_array).convert("L")
+                    inpaint_binary_original = Image.fromarray(inpaint_binary_mask).convert("L")
+          
+                                       
                 # ============================================================
                 # ABSCHLIESSENDE STATISTIK
                 # ============================================================