Upload 14 files

app_gradio.py

@@ -521,14 +521,107 @@ def create_layered_furniture_mask(image):
 
 # Keep the old function for compatibility
 def create_precise_furniture_mask(image):
-    """Legacy function - redirects to layered approach"""
-    return create_layered_furniture_mask(image)
+    """Create ultra-conservative mask that ONLY targets floor center - preserves ALL walls and windows"""
+    import cv2
+    
+    print("🎯 Creating ULTRA-CONSERVATIVE furniture mask...")
+    
+    img_array = np.array(image)
+    h, w = img_array.shape[:2]
+    gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+    
+    # Create conservative mask - ONLY center floor area
+    mask = np.zeros((h, w), dtype=np.uint8)
+    
+    # ULTRA CONSERVATIVE: Only center 30% of image, bottom 40% (floor only)
+    safe_x_start = int(w * 0.35)  # 35% from left
+    safe_x_end = int(w * 0.65)    # 35% from right  
+    safe_y_start = int(h * 0.6)   # 60% from top (avoid walls/windows)
+    safe_y_end = int(h * 0.85)    # 15% from bottom
+    
+    # Create small circular mask in safe center floor area
+    center_x, center_y = w // 2, int(h * 0.72)  # Lower center for floor
+    
+    # SMALL ellipse parameters - very conservative
+    ellipse_w = int(w * 0.18)  # Only 18% of width (very small area)
+    ellipse_h = int(h * 0.15)  # Only 15% of height (very small area)
+    
+    # Draw small ellipse mask
+    Y, X = np.ogrid[:h, :w]
+    ellipse_mask = ((X - center_x) / ellipse_w) ** 2 + ((Y - center_y) / ellipse_h) ** 2 <= 1
+    
+    # Apply soft gradient within ellipse - strong at center, fade at edges
+    for y in range(h):
+        for x in range(w):
+            if ellipse_mask[y, x]:
+                # Distance from center
+                dist = np.sqrt(((x - center_x) / ellipse_w) ** 2 + ((y - center_y) / ellipse_h) ** 2)
+                # Very conservative gradient
+                strength = max(0, (1 - dist) ** 2) * 200  # Softer, max 200 not 255
+                mask[y, x] = int(strength)
+    
+    # HARD EXCLUSIONS - absolutely no modification near walls/windows
+    
+    # Exclude all bright areas (windows) completely
+    windows = gray > 180  # Lower threshold to catch more window areas
+    mask[windows] = 0
+    
+    # Exclude all dark areas (corners/shadows)
+    dark_areas = gray < 60
+    mask[dark_areas] = 0
+    
+    # Exclude outer 25% of image (wall areas)
+    wall_margin = 0.25
+    mask[:int(h*wall_margin), :] = 0  # Top 25%
+    mask[-int(h*wall_margin):, :] = 0  # Bottom 25%
+    mask[:, :int(w*wall_margin)] = 0  # Left 25%
+    mask[:, -int(w*wall_margin):] = 0  # Right 25%
+    
+    # Exclude top 50% completely (ceiling/wall area)
+    mask[:int(h*0.5), :] = 0
+    
+    # Apply strong blur for very smooth transitions
+    mask = cv2.GaussianBlur(mask, (31, 31), 0)
+    
+    # Final safety check - make sure mask is very conservative
+    mask = np.clip(mask, 0, 150)  # Lower maximum intensity
+    
+    # Statistics
+    furniture_pixels = np.count_nonzero(mask)
+    coverage = (furniture_pixels / (h * w)) * 100
+    
+    print(f"🛡️ ULTRA-CONSERVATIVE mask stats:")
+    print(f"  - Total coverage: {furniture_pixels} pixels ({coverage:.1f}%)")
+    print(f"  - Max intensity: {mask.max()}")
+    print(f"  - Center: ({center_x}, {center_y}), Size: {ellipse_w}x{ellipse_h}")
+    print(f"  - Coverage should be < 15% for wall preservation")
+    
+    return Image.fromarray(mask).convert("RGB")
 
 def get_prompt_preview(room_type, design_style, inpainting_mode):
     """Generate preview of prompt and negative prompt that will be used"""
     
     # Create positive prompt based on mode
-    if inpainting_mode == "smart":
+    if inpainting_mode == "layered":
+        # Layered furniture generation
+        if room_type == "Living Room":
+            furniture_items = "modern sofa, coffee table, side table, floor lamp"
+        elif room_type == "Bedroom" or room_type == "Master Bedroom":
+            furniture_items = "bed with headboard, two nightstands, dresser"
+        elif room_type == "Kitchen":
+            furniture_items = "kitchen island, bar stools"
+        elif room_type == "Dining Room":
+            furniture_items = "dining table, dining chairs"
+        elif room_type == "Home Office":
+            furniture_items = "desk, office chair, bookshelf"
+        elif room_type == "Bathroom":
+            furniture_items = "vanity, mirror, storage cabinet"
+        else:
+            furniture_items = "appropriate furniture"
+            
+        positive_prompt = f"LAYERED APPROACH: same room layout, preserve perspective, layout preserving realistic interior design - Generate realistic {furniture_items}, {design_style.lower()} style, photorealistic furniture placement, maintain room proportions, professional furniture photography, clean lighting, realistic materials and shadows"
+        
+    elif inpainting_mode == "smart":
         # Simple, direct furniture prompt for smart mode
         if room_type == "Living Room":
             furniture_items = "sofa, coffee table, side tables, floor lamp, dining table with chairs"
@@ -545,18 +638,185 @@ def get_prompt_preview(room_type, design_style, inpainting_mode):
         else:
             furniture_items = "appropriate furniture"
         
-        positive_prompt = f"LAYERED FURNITURE DESIGN: add {furniture_items}, {design_style.lower()} style, photorealistic, place furniture naturally on floor and against walls, add wall decorations like artwork and shelves, preserve existing room structure, no structural changes to walls windows or ceiling, layer furniture over existing surfaces, professional interior design, ultra-realistic lighting and shadows"
+        positive_prompt = f"FURNITURE ONLY: add {furniture_items} on floor center, {design_style.lower()} style, photorealistic furniture objects, PRESERVE: keep all walls unchanged, keep ceiling unchanged, keep floor color unchanged, keep window unchanged, no structural changes, no wall modifications, only place furniture objects in room center, professional furniture placement, realistic shadows"
     else:
         # Get detailed template-based prompt for full mode
         detailed_prompt = DETAILED_PROMPTS.get((room_type, design_style), 
                                              DETAILED_PROMPTS[("Living Room", "Modern")])
         positive_prompt = f"photorealistic interior design, {detailed_prompt}, keep existing windows unchanged, preserve original window placement, professionally photographed, architectural photography, natural lighting, ultra-realistic, high resolution, sharp focus, interior design magazine quality, realistic textures, realistic materials"
     
-    # LAYERED DESIGN negative prompt
-    negative_prompt = "STRUCTURAL REPLACEMENT FORBIDDEN: changing wall color, different wall texture, new walls, removing walls, changing ceiling, different ceiling, new windows, different windows, removing windows, changing floor material, different floor, PRESERVE STRUCTURE: keep original room architecture, floating furniture, unrealistic placement, furniture in ceiling, lowres, watermark, banner, logo, contactinfo, text, deformed, blurry, blur, out of focus, surreal, ugly"
+    # Updated negative prompt
+    if inpainting_mode == "layered":
+        negative_prompt = "distortion, warped structure, perspective distortion, room layout changes, architectural changes, structural modifications, empty room, no furniture, floating furniture, unrealistic placement, bad proportions, distorted furniture, warped perspective, gray background, neutral background, plain background, lowres, watermark, blurry, deformed"
+    elif inpainting_mode == "smart":
+        negative_prompt = "FORBIDDEN CHANGES: changing walls, different wall color, wall texture changes, new wall paint, different walls, wall modifications, changing windows, different window, new windows, window alterations, changing ceiling, different ceiling, ceiling changes, changing floor, different floor material, floor changes, structural modifications, architectural changes, room alterations, wall decorations, wall art, curtains, blinds, wall shelves, wall mounted items, lowres, watermark, blurry, deformed, floating furniture, unrealistic placement"
+    else:
+        negative_prompt = "STRUCTURAL REPLACEMENT FORBIDDEN: changing wall color, different wall texture, new walls, removing walls, changing ceiling, different ceiling, new windows, different windows, removing windows, changing floor material, different floor, PRESERVE STRUCTURE: keep original room architecture, floating furniture, unrealistic placement, furniture in ceiling, lowres, watermark, banner, logo, contactinfo, text, deformed, blurry, blur, out of focus, surreal, ugly"
     
     return positive_prompt, negative_prompt
 
+def generate_furniture_layer(original_image, room_type, design_style, num_steps, guidance_scale, strength):
+    """Generate furniture objects using neutral background, then extract for layering"""
+    global pipe, seg_processor, seg_model, mlsd_processor
+    
+    print("🪑 Generating furniture layer...")
+    
+    # Create neutral gray background same size as original for furniture generation
+    w, h = original_image.size
+    neutral_bg = Image.new('RGB', (w, h), (128, 128, 128))  # Neutral gray
+    
+    # Create furniture mask (center area only)
+    furniture_mask = create_precise_furniture_mask(neutral_bg)
+    
+    # Create furniture prompt
+    if room_type == "Living Room":
+        furniture_items = "modern sofa, coffee table, side table, floor lamp"
+    elif room_type == "Bedroom":
+        furniture_items = "bed with headboard, two nightstands, dresser"
+    elif room_type == "Kitchen":
+        furniture_items = "kitchen island, bar stools"
+    elif room_type == "Dining Room":
+        furniture_items = "dining table, dining chairs"
+    elif room_type == "Home Office":
+        furniture_items = "desk, office chair, bookshelf"
+    else:
+        furniture_items = "appropriate furniture"
+    
+    furniture_prompt = f"same room layout, preserve perspective, layout preserving realistic interior design: {furniture_items}, {design_style.lower()} style, photorealistic furniture placement, natural floor positioning, professional furniture photography, clean professional lighting, realistic materials and textures, high quality furniture catalog, maintain room proportions, realistic shadows and reflections"
+    
+    # Generate furniture on neutral background
+    try:
+        if pipe is None:
+            print("❌ Pipeline not loaded")
+            return Image.new('RGBA', (w, h), (0, 0, 0, 0))
+        
+        # Resize for processing
+        max_size = 768
+        if max(w, h) > max_size:
+            if w > h:
+                new_w, new_h = max_size, int(max_size * h / w)
+            else:
+                new_w, new_h = int(max_size * w / h), max_size
+        else:
+            new_w, new_h = w, h
+            
+        resized_neutral = neutral_bg.resize((new_w, new_h))
+        resized_mask = furniture_mask.resize((new_w, new_h))
+        
+        # Generate furniture with inpainting
+        seg_control = resized_neutral.copy()
+        mlsd_image = resized_neutral.copy()
+        
+        # Optimized parameters based on user feedback
+        optimized_guidance = max(7.0, min(10.0, float(guidance_scale)))  # Clamp 7-10
+        optimized_strength = max(0.4, min(0.6, float(strength)))  # Clamp 0.4-0.6
+        
+        result = pipe(
+            prompt=furniture_prompt,
+            negative_prompt="distortion, warped structure, perspective distortion, room layout changes, architectural changes, structural modifications, empty room, no furniture, floating furniture, unrealistic placement, bad proportions, distorted furniture, warped perspective",
+            num_inference_steps=int(num_steps),
+            strength=optimized_strength,  # Optimized strength range
+            guidance_scale=optimized_guidance,  # Optimized guidance range
+            image=resized_neutral,
+            mask_image=resized_mask,
+            control_image=[seg_control, mlsd_image],
+            controlnet_conditioning_scale=[0.5, 0.3],  # Stronger control for layout preservation
+            control_guidance_start=[0, 0],
+            control_guidance_end=[0.7, 0.5],  # Extended guidance for better control
+        ).images[0]
+        
+        # Restore original size
+        furniture_generated = result.resize((w, h), Image.Resampling.LANCZOS)
+        
+        print("✅ Furniture generated on neutral background")
+        return furniture_generated
+        
+    except Exception as e:
+        print(f"❌ Furniture layer generation failed: {e}")
+        return Image.new('RGBA', (w, h), (0, 0, 0, 0))
+
+def extract_furniture_from_generated(furniture_generated, original_neutral_bg):
+    """Extract furniture from generated image by removing neutral background"""
+    import cv2
+    
+    print("✂️ Extracting furniture from generated image...")
+    
+    # Convert to numpy arrays
+    furniture_array = np.array(furniture_generated)
+    neutral_array = np.array(original_neutral_bg)
+    
+    h, w = furniture_array.shape[:2]
+    
+    # Create mask for furniture areas (areas that changed from neutral gray)
+    # Neutral gray is (128, 128, 128)
+    gray_tolerance = 30
+    
+    # Calculate difference from neutral gray
+    diff = np.abs(furniture_array.astype(np.float32) - 128.0)
+    diff_magnitude = np.sqrt(np.sum(diff**2, axis=2))
+    
+    # Create furniture mask - areas significantly different from gray
+    furniture_mask = diff_magnitude > gray_tolerance
+    
+    # Refine mask - remove small noise
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    furniture_mask = cv2.morphologyEx(furniture_mask.astype(np.uint8), cv2.MORPH_OPEN, kernel)
+    furniture_mask = cv2.morphologyEx(furniture_mask, cv2.MORPH_CLOSE, kernel)
+    
+    # Create RGBA image with transparency
+    furniture_rgba = np.zeros((h, w, 4), dtype=np.uint8)
+    furniture_rgba[:, :, :3] = furniture_array  # Copy RGB
+    furniture_rgba[:, :, 3] = furniture_mask * 255  # Alpha channel
+    
+    # Apply gaussian blur to alpha for smoother edges
+    furniture_rgba[:, :, 3] = cv2.GaussianBlur(furniture_rgba[:, :, 3], (3, 3), 0)
+    
+    furniture_layer = Image.fromarray(furniture_rgba, 'RGBA')
+    
+    print(f"✅ Extracted furniture layer with {np.count_nonzero(furniture_mask)} furniture pixels")
+    
+    return furniture_layer
+
+def composite_layers(background, furniture_generated, furniture_mask=None):
+    """Composite furniture layer onto background with realistic placement"""
+    print("🎨 Compositing layers...")
+    
+    # Step 1: Extract furniture from generated image
+    neutral_bg = Image.new('RGB', background.size, (128, 128, 128))
+    furniture_layer = extract_furniture_from_generated(furniture_generated, neutral_bg)
+    
+    # Step 2: Composite furniture onto original background
+    if background.mode != 'RGBA':
+        background = background.convert('RGBA')
+    
+    # Alpha composite
+    result = Image.alpha_composite(background, furniture_layer)
+    
+    # Convert back to RGB
+    final = Image.new('RGB', result.size, (255, 255, 255))
+    final.paste(result, mask=result.split()[-1])
+    
+    return final
+
+def create_layered_design(input_image, room_type, design_style, num_steps, guidance_scale, strength):
+    """LAYERED APPROACH: Generate furniture separately and composite onto preserved background"""
+    print("🏗️  Starting layered design generation...")
+    print(f"📊 Optimized parameters - Guidance: {guidance_scale} → {max(7.0, min(10.0, float(guidance_scale)))}, Strength: {strength} → {max(0.4, min(0.6, float(strength)))}")
+    
+    # Step 1: Preserve original background completely
+    background_layer = input_image.copy()
+    print("✅ Background layer preserved")
+    
+    # Step 2: Generate furniture objects separately  
+    furniture_layer = generate_furniture_layer(input_image, room_type, design_style, num_steps, guidance_scale, strength)
+    print("✅ Furniture layer generated")
+    
+    # Step 3: Composite layers
+    final_image = composite_layers(background_layer, furniture_layer)
+    print("✅ Layers composited")
+    
+    return final_image
+
 def post_process_blend(original, generated):
     """Post-process to reduce seam artifacts between original and generated areas"""
     from PIL import ImageFilter
@@ -642,7 +902,15 @@ def design_space(input_image, room_type, design_style, inpainting_mode, num_step
             mlsd_image = resized_image.copy()
         
         # Create mask based on selected mode
-        if inpainting_mode == "smart":
+        if inpainting_mode == "layered":
+            # Use new layered approach
+            final_image = create_layered_design(resized_image, room_type, design_style, num_steps, guidance_scale, strength)
+            # Restore original size
+            final_image = final_image.resize((orig_w, orig_h), Image.Resampling.LANCZOS)
+            success_msg = f"✅ Layered {room_type} in {design_style} style completed!"
+            return final_image, success_msg
+            
+        elif inpainting_mode == "smart":
             # Use precise smart mask for furniture-only placement
             mask_image = create_precise_furniture_mask(resized_image)
             
@@ -662,7 +930,7 @@ def design_space(input_image, room_type, design_style, inpainting_mode, num_step
             else:
                 furniture_items = "appropriate furniture"
             
-            prompt = f"add {furniture_items} to this room, {design_style.lower()} style furniture, photorealistic, keep all walls ceiling floor windows unchanged, preserve all existing room structure, only add furniture objects on the floor, do not modify room architecture, professional interior design, ultra-realistic, high quality"
+            prompt = f"FURNITURE ONLY: add {furniture_items} on floor center, {design_style.lower()} style, photorealistic furniture objects, PRESERVE: keep all walls unchanged, keep ceiling unchanged, keep floor color unchanged, keep window unchanged, no structural changes, no wall modifications, only place furniture objects in room center, professional furniture placement, realistic shadows"
             print(f"Smart mode prompt: {prompt}")
         else:
             mask_image = create_full_mask(resized_image)
@@ -671,8 +939,8 @@ def design_space(input_image, room_type, design_style, inpainting_mode, num_step
         
         # Generate image with optimized strength for furniture generation
         if inpainting_mode == "smart":
-            # Higher strength for better furniture generation in smart mode
-            actual_strength = min(0.85, float(strength) * 1.1)  # Boost by 10%, cap at 0.85
+            # Lower strength for better structure preservation in smart mode
+            actual_strength = min(0.65, float(strength) * 0.8)  # Reduce by 20%, cap at 0.65
         else:
             actual_strength = float(strength)
         
@@ -685,16 +953,16 @@ def design_space(input_image, room_type, design_style, inpainting_mode, num_step
         
         result = pipe(
             prompt=prompt,
-            negative_prompt="lowres, watermark, banner, logo, watermark, contactinfo, text, deformed, blurry, blur, out of focus, out of frame, surreal, extra, ugly, upholstered walls, fabric walls, plush walls, mirror, mirrored, functional, realistic, new windows, extra windows, additional windows, changing windows, modifying windows, different windows, window alterations, removing windows, changing walls, modifying walls, different walls, new walls, changing ceiling, modifying ceiling, different ceiling, changing floor, modifying floor, different floor, structural changes, architectural changes, room alterations",
+            negative_prompt="FORBIDDEN CHANGES: changing walls, different wall color, wall texture changes, new wall paint, different walls, wall modifications, changing windows, different window, new windows, window alterations, changing ceiling, different ceiling, ceiling changes, changing floor, different floor material, floor changes, structural modifications, architectural changes, room alterations, wall decorations, wall art, curtains, blinds, wall shelves, wall mounted items, lowres, watermark, blurry, deformed, floating furniture, unrealistic placement",
             num_inference_steps=int(num_steps),
             strength=actual_strength,
             guidance_scale=float(guidance_scale),
             image=resized_image,
             mask_image=mask_image,
             control_image=[seg_control, mlsd_image],
-            controlnet_conditioning_scale=[0.4, 0.2],
-            control_guidance_start=[0, 0.1],
-            control_guidance_end=[0.5, 0.25],
+            controlnet_conditioning_scale=[0.8, 0.6] if inpainting_mode == "smart" else [0.4, 0.2],
+            control_guidance_start=[0, 0] if inpainting_mode == "smart" else [0, 0.1],
+            control_guidance_end=[0.9, 0.8] if inpainting_mode == "smart" else [0.5, 0.25],
         ).images[0]
         
         # Restore original size
@@ -745,9 +1013,10 @@ def create_interface():
                 inpainting_mode = gr.Radio(
                     choices=[
                         ("Complete Room Redesign", "full"),
-                        ("Add Furniture Only (Preserve Walls)", "smart")
+                        ("Add Furniture Only (Preserve Walls)", "smart"),
+                        ("🆕 Layered Furniture (Background + Furniture Overlay)", "layered")
                     ],
-                    value="smart",
+                    value="layered",
                     label="🎨 Design Mode",
                     info="Choose how to modify your image"
                 )
@@ -758,12 +1027,12 @@ def create_interface():
                         label="Number of denoising steps"
                     )
                     guidance_scale = gr.Slider(
-                        minimum=1, maximum=50, value=18, step=0.5,
-                        label="Scale for classifier-free guidance"
+                        minimum=1, maximum=50, value=8, step=0.5,
+                        label="Scale for classifier-free guidance (7-10 optimal for Layered mode)"
                     )
                     strength = gr.Slider(
-                        minimum=0, maximum=1, value=0.8, step=0.05,
-                        label="Prompt strength for inpainting"
+                        minimum=0, maximum=1, value=0.5, step=0.05,
+                        label="Prompt strength for inpainting (0.4-0.6 optimal for Layered mode)"
                     )
                 
                 generate_btn = gr.Button("🎨 Generate Design", variant="primary", size="lg")