Update app.py

app.py

@@ -46,6 +46,7 @@ def deactivate_loras(pipe):
     pipe.unload_lora_weights()
     return pipe
 
+
 def calculate_optimal_dimensions(image):
     original_width, original_height = image.size
     MIN_ASPECT_RATIO = 9 / 16
@@ -70,13 +71,13 @@ def calculate_optimal_dimensions(image):
 
     return width, height
 
+
 @spaces.GPU(duration=45)
 def inpaint(
     image,
     mask,
     prompt: str = "",
     preserve_unmasked: bool = True,
-    feather_radius: int = 0,  # NUEVO: 0 = sin blur, >0 = suavizado en píxeles
     seed: int = 0,
     num_inference_steps: int = 28,
     guidance_scale: int = 40,
@@ -90,7 +91,7 @@ def inpaint(
     mask = mask.convert("L")
     width, height = calculate_optimal_dimensions(image)
 
-    # Guardar imagen original redimensionada
+    # Guardar imagen original redimensionada ANTES de cualquier procesamiento
     original_resized = image.resize((width, height), Image.Resampling.LANCZOS)
     original_array = np.array(original_resized).astype(np.float32)
     
@@ -98,15 +99,14 @@ def inpaint(
     mask_resized = mask.resize((width, height), Image.Resampling.LANCZOS)
     
     if preserve_unmasked:
-        if feather_radius > 0:
-            # Aplicar suavizado solo si se solicita
-            mask_processed = mask_resized.filter(ImageFilter.GaussianBlur(radius=feather_radius))
-            mask_array = np.array(mask_processed).astype(np.float32) / 255.0
-        else:
-            # Sin suavizado: binarización estricta
-            mask_array = np.array(mask_resized).astype(np.float32) / 255.0
-            # Umbral duro: todo lo que sea >50% gris se considera máscara
-            mask_array = (mask_array > 0.5).astype(np.float32)
+        # Opción 1: Máscara binaria estricta (sin blur, preservación perfecta)
+        mask_array = np.array(mask_resized).astype(np.float32) / 255.0
+        # Binarizar la máscara con umbral para eliminar grises
+        mask_array = (mask_array > 0.5).astype(np.float32)
+        
+        # Opción 2: Con feathering mínimo solo en el borde (descomenta si prefieres esto)
+        # mask_blurred = mask_resized.filter(ImageFilter.GaussianBlur(radius=1))
+        # mask_array = np.array(mask_blurred).astype(np.float32) / 255.0
     else:
         mask_array = np.array(mask_resized).astype(np.float32) / 255.0
 
@@ -125,65 +125,42 @@ def inpaint(
         generator=torch.Generator(device="cuda").manual_seed(seed),
     ).images[0]
 
-    # Composición final
+    # Preservación PERFECTA de áreas no enmascaradas
     if preserve_unmasked:
         result_array = np.array(result).astype(np.float32)
+        
+        # Expandir máscara a 3 canales RGB
         mask_3channel = np.stack([mask_array] * 3, axis=-1)
         
-        # Mezcla controlada
+        # Reemplazo EXACTO pixel por pixel:
+        # donde mask=1.0 (blanco/área a inpaint) -> usar resultado del modelo
+        # donde mask=0.0 (negro/área a preservar) -> usar imagen original EXACTA
         blended = result_array * mask_3channel + original_array * (1.0 - mask_3channel)
+        
+        # Convertir de vuelta sin pérdida
         result = Image.fromarray(np.clip(blended, 0, 255).astype(np.uint8), mode='RGB')
 
     return result.convert("RGBA"), prompt, seed
 
 
-# ============================================
-# ACTUALIZACIÓN de inpaint_api
-# ============================================
 def inpaint_api(
-    image,
-    mask,
-    prompt: str = "",  
-    preserve_unmasked: bool = True,
-    feather_radius: int = 0,  # NUEVO parámetro
-    seed: int = 0,
-    num_inference_steps: int = 28,
-    guidance_scale: int = 40,
-    strength: float = 1.0,    
-    flux_keywords: List[str] = None,
-    loras_selected: List[Tuple[str, float]] = None
+        image,
+        mask,
+        prompt: str = "",
+        preserve_unmasked: bool = True,
+        seed: int = 0,
+        num_inference_steps: int = 28,
+        guidance_scale: int = 40,
+        strength: float = 1.0,
+        flux_keywords: List[str] = None,
+        loras_selected: List[Tuple[str, float]] = None
 ):
     flux_keywords = flux_keywords or []
     loras_selected = loras_selected or []
 
-    # Validar parámetros
-    if seed is None or not isinstance(seed, (int, float)):
-        seed = -1
-    seed = int(seed)
-    
-    if num_inference_steps is None:
-        num_inference_steps = 28
-    num_inference_steps = int(num_inference_steps)
-    
-    if guidance_scale is None:
-        guidance_scale = 40
-    guidance_scale = float(guidance_scale)
-    
-    if strength is None:
-        strength = 1.0
-    strength = float(strength)
-    
-    if feather_radius is None:
-        feather_radius = 0
-    feather_radius = max(0, min(10, int(feather_radius)))  # Limitar entre 0-10
-    
-    # Rangos válidos
-    num_inference_steps = max(1, min(100, num_inference_steps))
-    guidance_scale = max(0.0, min(50.0, guidance_scale))
-    strength = max(0.0, min(1.0, strength))
-
-    # LoRAs
+    # Convertir nombres a objetos LoRA
     selected_loras_with_weights = []
+
     for name, weight in loras_selected:
         lora_obj = next((l for l in loras if l.display_name == name), None)
         if lora_obj and weight != 0:
@@ -193,21 +170,24 @@ def inpaint_api(
     if selected_loras_with_weights:
         activate_loras(pipe, selected_loras_with_weights)
 
-    # Construir prompt
+    # Construir prompt final
     final_prompt = ""
+
     if flux_keywords:
         final_prompt += ", ".join(flux_keywords) + ", "
+
     for lora, _ in selected_loras_with_weights:
         if lora.keyword:
             if isinstance(lora.keyword, str):
                 final_prompt += lora.keyword + ", "
             else:
                 final_prompt += ", ".join(lora.keyword) + ", "
+
     if final_prompt:
         final_prompt += "\n\n"
     final_prompt += prompt
 
-    if seed < 0:
+    if not isinstance(seed, int) or seed < 0:
         seed = random.randint(0, MAX_SEED)
 
     return inpaint(
@@ -215,7 +195,6 @@ def inpaint_api(
         mask=mask,
         prompt=final_prompt,
         preserve_unmasked=preserve_unmasked,
-        feather_radius=feather_radius,
         seed=seed,
         num_inference_steps=num_inference_steps,
         guidance_scale=guidance_scale,
@@ -223,9 +202,9 @@ def inpaint_api(
     )
 
 
-# ============================================
-# ACTUALIZACIÓN de la UI de Gradio
-# ============================================
+# ========================
+# UI DIRECTA A inpaint_api
+# ========================
 with gr.Blocks(title="Flux.1 Fill dev Inpainting with LoRAs", theme=gr.themes.Soft()) as demo:
     gr.api(get_loras, api_name="get_loras")
     with gr.Row():
@@ -234,57 +213,14 @@ with gr.Blocks(title="Flux.1 Fill dev Inpainting with LoRAs", theme=gr.themes.So
             preserve_unmasked_checkbox = gr.Checkbox(
                 label="Preserve unmasked areas", value=True
             )
-            
-            # NUEVO: Control de feathering
-            feather_radius_slider = gr.Slider(
-                label="Feather Radius (edge smoothing)",
-                minimum=0,
-                maximum=10,
-                step=1,
-                value=0,
-                info="0 = Sharp edges (perfect preservation), higher = smoother blend",
-                interactive=True
-            )
-            
-            seed_slider = gr.Slider(
-                label="Seed", 
-                minimum=-1, 
-                maximum=MAX_SEED, 
-                step=1,
-                value=-1, 
-                info="(-1 = Random)", 
-                interactive=True
-            )
-            num_inference_steps_input = gr.Number(
-                label="Inference steps", 
-                value=28,
-                minimum=1,
-                maximum=100,
-                step=1,
-                interactive=True
-            )
-            guidance_scale_input = gr.Number(
-                label="Guidance scale", 
-                value=40,
-                minimum=0,
-                maximum=50,
-                step=0.5,
-                interactive=True
-            )
-            strength_input = gr.Number(
-                label="Strength", 
-                value=1.0, 
-                minimum=0.0,
-                maximum=1.0,
-                step=0.05,
-                interactive=True
-            )
+            seed_slider = gr.Slider(label="Seed", minimum=-1, maximum=MAX_SEED, step=1,
+                                    value=-1, info="(-1 = Random)", interactive=True)
+            num_inference_steps_input = gr.Number(label="Inference steps", value=40, interactive=True)
+            guidance_scale_input = gr.Number(label="Guidance scale", value=28, interactive=True)
+            strength_input = gr.Number(label="Strength", value=1.0, interactive=True, maximum=1.0)
 
             gr.Markdown("### Flux Keywords")
-            flux_keywords_input = gr.CheckboxGroup(
-                choices=flux_keywords_available, 
-                label="Flux Keywords"
-            )
+            flux_keywords_input = gr.CheckboxGroup(choices=flux_keywords_available, label="Flux Keywords")
 
             if loras:
                 gr.Markdown("### Available LoRAs")
@@ -293,8 +229,8 @@ with gr.Blocks(title="Flux.1 Fill dev Inpainting with LoRAs", theme=gr.themes.So
                     type="array",
                     headers=["LoRA", "Weight"],
                     value=[[name, 0.0] for name in lora_names],
-                    datatype=["str", "number"],
-                    interactive=[False, True],
+                    datatype=["str", "number"],  # Primera columna string, segunda número
+                    interactive=[False, True],  # Solo la segunda columna editable
                     static_columns=[0],
                     label="LoRA selection (Weight 0 = disable)"
                 )
@@ -316,7 +252,6 @@ with gr.Blocks(title="Flux.1 Fill dev Inpainting with LoRAs", theme=gr.themes.So
             mask_input,
             prompt_input,
             preserve_unmasked_checkbox,
-            feather_radius_slider,  # NUEVO input
             seed_slider,
             num_inference_steps_input,
             guidance_scale_input,