Update controlnet_module.py

controlnet_module.py

@@ -293,91 +293,95 @@ class ControlNetProcessor:
                     cv2.rectangle(mask_array, (fb_x1, fb_y1), (fb_x2, fb_y2), 0, -1) 
 
                 # Damit wird die Rohmaske für die UI-Anzeige gespeichert
-                raw_mask_array = mask_array.copy()      
+                raw_mask_array = mask_array.copy()     
 
+                ##########################################################
+                #   POSTPROCESSING
+                ##########################################################
                 print("🌳 ENVIRONMENT-CHANGE POSTPROCESSING")   
         
                 # Konvertierung zu PIL, hochskalieren auf Originalgröße (korrekte Überlagerung mit O-Bild), 
                 # Konvertierung NumPy für weitere Verarbeitung da mathematisch korrekter als PIL.
-                if image.size != original_image.size:
+                if image.size != original_image.size:  #Vergleich SAM-Maskengröße und Original-Bildgröße
                     print(f"   ⚠️  Bildgröße angepasst: {image.size} → {original_image.size}")
-                    temp_mask = Image.fromarray(mask_array).convert("L")
-                    temp_mask = temp_mask.resize(original_image.size, Image.Resampling.NEAREST)
-                    mask_array = np.array(temp_mask)
+                    temp_mask = Image.fromarray(mask_array).convert("L")  #wandelt NumPy-Array in PIL-Bild
+                    temp_mask = temp_mask.resize(original_image.size, Image.Resampling.NEAREST)  #skaliert auf Originalgröße
+                    mask_array = np.array(temp_mask)  #np. heißt mache aus PIL-Image wieder numPy-Array
                     print(f"   ✅ Maske auf Originalgröße skaliert: {mask_array.shape}")
-             
-                # Maske invertieren (Person wird schwarz, Hintergrund weiß)
-                mask_array = 255 - mask_array
-                print("   ✅ Maske invertiert (Person schwarz, Hintergrund weiß)")
-
-                # Weiße Punkte in der Person (schwarz) entfernen
-                print("🧹 Entferne weiße Punkte in der Person...")
-                kernel_open = np.ones((3, 3), np.uint8)
-                mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_OPEN, kernel_open, iterations=3)
-                print("   ✅ MORPH_OPEN entfernt weiße Punkte in der Person")
-
-                # DEBUG nach MORPH_OPEN
-                print(f"   Nach MORPH_OPEN - Weiße Pixel: {np.sum(mask_array > 127)}")
-        
-                # Morphologische Operationen für saubere Umgebung - entfernt schwarze Pixel aus Umgebung
-                print("🔧 Verbessere Umgebungsmaske...")
-                kernel_close = np.ones((5, 5), np.uint8)
-                mask_array = cv2.morphologyEx(mask_array, cv2.MORPH_CLOSE, kernel_close)
-                print("   ✅ MORPH_CLOSE für zusammenhängende Umgebung")
-        
-                # DEBUG nach MORPH_CLOSE
-                print(f"   Nach MORPH_CLOSE - Weiße Pixel: {np.sum(mask_array > 127)}")
-        
-                # Weiche Ränder für bessere Integration der Person
-                print("🌈 Erstelle weiche Übergänge...")
-                mask_array = cv2.GaussianBlur(mask_array, (9, 9), 2.0) #2.0 bestimmt wie stark die Unschärfe ist
-                print("   ✅ Gaussian Blur für weiche Übergänge")
-        
-                # DEBUG nach Gaussian Blur
-                print(f"   Nach Gaussian Blur - Min/Max: {mask_array.min()}/{mask_array.max()}")
-                print(f"   Nach Gaussian Blur - dtype: {mask_array.dtype}")
-        
-                # Gamma-Korrektur für präzisere Ränder
-                print("🎛️  Wende Gamma-Korrektur an...")
-                mask_array = mask_array.astype(np.float32) / 255.0
-                print(f"   Konvertiert zu Float32: Min={mask_array.min():.3f}, Max={mask_array.max():.3f}")
-        
-                mask_array = np.clip(mask_array, 0.0, 1.0)  #begrenzt alle Werte auf 0 und 1
-                mask_array = mask_array ** 0.85  # Gamma-Korrektur Werte > 0.5 werden abgedunkelt, <0.5 aufgehellt-erzeugt natürliche Maskenübergänge
-                print(f"   Nach Gamma 0.85: Min={mask_array.min():.3f}, Max={mask_array.max():.3f}")
-        
-                mask_array = (mask_array * 255).astype(np.uint8)
-                print("   ✅ Gamma-Korrektur (0.85) gegen milchige Ränder")
-        
-                # FINALE QUALITÄTSKONTROLLE
-                print("-" * 60)
-                print("📊 FINALE MASKEN-STATISTIK (ENVIRONMENT_CHANGE)")
-        
-                white_pixels = np.sum(mask_array > 127)
-                black_pixels = np.sum(mask_array <= 127)
-                total_pixels = mask_array.size
-        
-                white_ratio = white_pixels / total_pixels * 100
-                black_ratio = black_pixels / total_pixels * 100
+
+
+                # DILATE auf der weißen Person - daduch wird Person etwas vergrößert
+                kernel_dilate = np.ones((5, 5), np.uint8)
+                working_mask = cv2.dilate(working_mask, kernel_dilate, iterations=1)
+                print(f"   ✅ Dilate (5x5) - Person leicht erweitert")
+
+
+                # MORPH_CLOSE auf dem schwarzen Hintergrund (feine Löcher)- kleiner Kernel filigrane Heranarbeitung an Person,
+                # es werden aber nur kleine Löcher in Umgebung von weiß nach schwarz geändert!
+                kernel_close_small = np.ones((3, 3), np.uint8)
+                working_mask = cv2.morphologyEx(working_mask, cv2.MORPH_CLOSE, kernel_close_small, iterations=1)
+                print(f"   ✅ MORPH_CLOSE (3x3) - Feine Löcher im Hintergrund geschlossen")
+
+                
+                # KONTURENFILTER auf der weißen Person - arbeitet filigraner als MORPH-CLOSE
+                # Finde Konturen (nur äußere)
+                contours, _ = cv2.findContours(working_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
         
-                print(f"   Weiße Pixel (HINTERGRUND - Veränderung): {white_pixels:,} ({white_ratio:.1f}%)")
-                print(f"   Schwarze Pixel (PERSON - Erhaltung): {black_pixels:,} ({black_ratio:.1f}%)")
-                print(f"   Gesamtpixel: {total_pixels:,}")
+                if len(contours) > 0:
+                    # Finde die größte Kontur (sollte die Person sein)
+                    largest_contour = max(contours, key=cv2.contourArea)
+            
+                    # Erstelle eine saubere Maske mit nur der größten Kontur
+                    clean_mask = np.zeros_like(working_mask)
+                    cv2.drawContours(clean_mask, [largest_contour], -1, 255, -1)
+            
+                    # Optional: Kleine weiße Punkte IN der Person entfernen
+                    # Dazu invertieren wir temporär, um "Löcher" (schwarze Pixel) in der Person zu finden
+                    temp_inverted = 255 - clean_mask
+                    hole_contours, _ = cv2.findContours(temp_inverted, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+            
+                    for hole in hole_contours:
+                        area = cv2.contourArea(hole)
+                        if area < 100:  # Sehr kleine Löcher füllen
+                            cv2.drawContours(clean_mask, [hole], -1, 255, -1)
+            
+                    working_mask = clean_mask
+                    print(f"   ✅ Konturenfilter - Größte Kontur behalten, {len(contours)-1} kleine entfernt")
+                
+                    
 
-                # Warnungen basierend auf Verhältnis
-                if white_ratio < 30:
-                    print(f"   ⚠️  WARNUNG: Sehr wenig Hintergrund ({white_ratio:.1f}%)")
-                    print(f"   ℹ️  Das könnte bedeuten, dass die Person zu groß segmentiert wurde")
-                elif white_ratio > 90:
-                    print(f"   ⚠️  WARNUNG: Sehr viel Hintergrund ({white_ratio:.1f}%)")
-                    print(f"   ℹ️  Das könnte bedeuten, dass die Person zu klein segmentiert wurde")
-                elif 50 <= white_ratio <= 80:
-                    print(f"   ✅ OPTIMALES Verhältnis ({white_ratio:.1f}%)")
-                else:
-                    print(f"   ℹ️  Normales Verhältnis ({white_ratio:.1f}%)")
+                # Gaussian-BLUR für weiche Kanten
+                working_mask = cv2.GaussianBlur(working_mask, (5, 5), 1.2)
+                print(f"   ✅ Gaussian Blur (5x5, sigma=1.2) für weiche Kanten")
+
+            
+
+                # GAMMA-Korrektur für präzisere Ränder
+                working_mask_float = working_mask.astype(np.float32) / 255.0
+                working_mask_float = np.clip(working_mask_float, 0.0, 1.0)
+                working_mask_float = working_mask_float ** 0.85  # Gamma 0.85
+                working_mask = (working_mask_float * 255).astype(np.uint8)
+                print(f"   ✅ Gamma-Korrektur (0.85) gegen milchige Ränder")
+
+
+
+                # Für environment_change: JETZT invertieren
+                final_mask = 255 - working_mask
+                print(f"   ✅ Finale Invertierung für environment_change")
+
+
+                # Qualitätskontrolle - Debug
+                white_pixels = np.sum(final_mask > 127)
+                black_pixels = np.sum(final_mask <= 127)
+                total_pixels = final_mask.size
+        
+                print(f"   📊 FINALE MASKE:")
+                print(f"     • Weiße Pixel (Hintergrund): {white_pixels:,} ({white_pixels/total_pixels*100:.1f}%)")
+                print(f"     • Schwarze Pixel (Person): {black_pixels:,} ({black_pixels/total_pixels*100:.1f}%)")
+                    
                     
                 # Zurück zu PIL Image
-                mask = Image.fromarray(mask_array).convert("L")
+                mask = Image.fromarray(final_mask).convert("L")
                 raw_mask = Image.fromarray(raw_mask_array).convert("L")
 
                 print("#" * 80)
@@ -386,7 +390,7 @@ class ControlNetProcessor:
                 print(f"🎛️  Verwendeter Modus: {mode}")
                 print("#" * 80)            
                             
-                return mask, raw_mask  # in mask steht die invertierte nachbearbeitete Maske, in raw_mask die Rohmaske. In app.py wird mask immer auf 512 skaliert.
+                return mask, raw_mask  # in mask steht die invertierte nachbearbeitete Maske, in raw_mask die Rohmaske. In app.py wird mask immer auf 512 skaliert
                 
             # ============================================================
             # BLOCK 2: FOCUS_CHANGE