Update app.py

app.py

@@ -1,570 +1,625 @@
-import gradio_client.utils
-
-# Store the original function
-original_get_type = gradio_client.utils.get_type
-
-def patched_get_type(schema):
-    """Patched version that handles boolean schemas properly"""
-    # If schema is a boolean, return appropriate type
-    if isinstance(schema, bool):
-        return "bool"
-    
-    # If schema is not a dict, return a default or handle appropriately
-    if not isinstance(schema, dict):
-        return "any"
-    
-    # Call original function for dict schemas
-    return original_get_type(schema)
-
-# Apply the patch
-gradio_client.utils.get_type = patched_get_type
-
-# Now import and use gradio normally
-
+import os
 import gradio as gr
 import torch
-from PIL import Image, ImageDraw, ImageFilter
-import numpy as np
-from transformers import (
-    DetrImageProcessor, 
-    DetrForObjectDetection,
-    BlipProcessor, 
-    BlipForConditionalGeneration,
-    pipeline
-)
-from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, StableDiffusionInpaintPipeline
 import cv2
-import os
-from typing import List, Tuple
+import numpy as np
+from PIL import Image, ImageEnhance
 import warnings
+from typing import Tuple, Optional, Dict
+import logging
+import traceback
+
+# Suppress warnings for cleaner output
 warnings.filterwarnings("ignore")
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-# Force CPU usage for free tier
-device = "cpu"
-torch.set_num_threads(2)
+# Configuration
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+DTYPE = torch.float16 if DEVICE == "cuda" else torch.float32
+MAX_RESOLUTION = 512  # Reduced for better compatibility
+MIN_RESOLUTION = 256
 
-# Global variables for models
-detector_processor = None
-detector_model = None
-caption_processor = None
-caption_model = None
-controlnet_pipe = None
-inpaint_pipe = None
+# HuggingFace token from environment
+HF_TOKEN = os.environ.get('HF_TOKEN')
 
-def load_models():
-    """Load models optimized for interior design room transformation"""
-    global detector_processor, detector_model
-    global caption_processor, caption_model, controlnet_pipe, inpaint_pipe
-    
-    try:
-        print("Loading furniture detection model...")
-        try:
-            detector_processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
-            detector_model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
-            detector_model.eval()
-            print("✅ DETR model loaded successfully")
-        except Exception as detr_error:
-            print(f"⚠️ DETR failed: {detr_error}")
-            detector_processor = None
-            detector_model = None
-        
-        print("Loading image captioning model...")
-        caption_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
-        caption_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
-        caption_model.eval()
-        print("✅ BLIP model loaded successfully")
-        
-        print("Loading ControlNet for room layout preservation...")
-        controlnet = ControlNetModel.from_pretrained(
-            "lllyasviel/sd-controlnet-canny",
-            torch_dtype=torch.float32
-        )
-        
-        controlnet_pipe = StableDiffusionControlNetPipeline.from_pretrained(
-            "runwayml/stable-diffusion-v1-5",
-            controlnet=controlnet,
-            torch_dtype=torch.float32,
-            safety_checker=None,
-            requires_safety_checker=False
-        )
+class InteriorDesignPipeline:
+    def __init__(self):
+        self.device = DEVICE
+        self.dtype = DTYPE
+        self.pipe = None
+        self.controlnet = None
+        self.canny_detector = None
+        self.initialized = False
+        self.mode = "uninitialized"
+        self.error_log = []
+        
+    def log_error(self, error_msg):
+        """Log errors for debugging"""
+        self.error_log.append(error_msg)
+        logger.error(error_msg)
+        
+    def initialize_pipeline(self):
+        """Initialize pipeline with detailed error logging"""
+        if self.initialized:
+            return True
+            
+        logger.info("🔧 Starting Pipeline Initialization...")
+        logger.info(f"📱 Device: {self.device}")
+        logger.info(f"🔢 Data type: {self.dtype}")
+        logger.info(f"💾 CUDA available: {torch.cuda.is_available()}")
         
-        print("Applying CPU optimizations to ControlNet pipeline...")
-        controlnet_pipe.enable_attention_slicing()
+        if torch.cuda.is_available():
+            logger.info(f"🎮 CUDA device: {torch.cuda.get_device_name()}")
+            logger.info(f"💾 CUDA memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f}GB")
         
-        try:
-            import accelerate
-            if torch.cuda.is_available():
-                controlnet_pipe.enable_sequential_cpu_offload()
-                print("✅ ControlNet: Sequential CPU offload enabled")
-            else:
-                try:
-                    controlnet_pipe.enable_model_cpu_offload()
-                    print("✅ ControlNet: Model CPU offload enabled")
-                except:
-                    print("✅ ControlNet: Running without CPU offload (CPU-only mode)")
-        except ImportError:
-            print("⚠️ Accelerate not available, running without CPU offload")
-        except Exception as e:
-            print(f"⚠️ CPU offload setup failed: {e}")
-        
-        print("Loading inpainting pipeline for furniture replacement...")
-        inpaint_pipe = StableDiffusionInpaintPipeline.from_pretrained(
-            "runwayml/stable-diffusion-v1-5",
-            torch_dtype=torch.float32,
-            safety_checker=None,
-            requires_safety_checker=False
-        )
-        
-        print("Applying CPU optimizations to inpainting pipeline...")
-        inpaint_pipe.enable_attention_slicing()
+        logger.info(f"🔑 HF Token available: {'Yes' if HF_TOKEN else 'No'}")
         
         try:
-            import accelerate
-            if torch.cuda.is_available():
-                inpaint_pipe.enable_sequential_cpu_offload()
-                print("✅ Inpainting: Sequential CPU offload enabled")
-            else:
-                try:
-                    inpaint_pipe.enable_model_cpu_offload()
-                    print("✅ Inpainting: Model CPU offload enabled")
-                except:
-                    print("✅ Inpainting: Running without CPU offload (CPU-only mode)")
-        except ImportError:
-            print("⚠️ Accelerate not available for inpainting, running without CPU offload")
-        except Exception as e:
-            print(f"⚠️ Inpainting CPU offload setup failed: {e}")
-        
-        print("🎉 All models loaded successfully!")
-        return True
-        
-    except Exception as e:
-        print(f"❌ Critical error loading models: {e}")
-        import traceback
-        print(f"Full traceback: {traceback.format_exc()}")
-        return False
-
-def detect_furniture_and_style(inspiration_image: Image.Image) -> Tuple[List[dict], str, str]:
-    """Analyze inspiration image for furniture and style"""
-    try:
-        # Detect furniture items
-        furniture_items = []
-        if detector_model is not None and detector_processor is not None:
-            if max(inspiration_image.size) > 800:
-                resized_img = inspiration_image.resize((800, int(800 * inspiration_image.size[1] / inspiration_image.size[0])))
-            else:
-                resized_img = inspiration_image
+            # Step 1: Check package availability
+            logger.info("📦 Checking package availability...")
+            try:
+                import diffusers
+                logger.info(f"✓ diffusers version: {diffusers.__version__}")
+            except ImportError as e:
+                self.log_error(f"❌ diffusers not available: {e}")
+                self.mode = "fallback"
+                self.initialized = True
+                return True
                 
-            inputs = detector_processor(images=resized_img, return_tensors="pt")
+            try:
+                import transformers
+                logger.info(f"✓ transformers version: {transformers.__version__}")
+            except ImportError as e:
+                self.log_error(f"❌ transformers not available: {e}")
+                self.mode = "fallback"
+                self.initialized = True
+                return True
+                
+            try:
+                import controlnet_aux
+                logger.info(f"✓ controlnet_aux available")
+            except ImportError as e:
+                self.log_error(f"❌ controlnet_aux not available: {e}")
+                self.mode = "fallback"
+                self.initialized = True
+                return True
             
-            with torch.no_grad():
-                outputs = detector_model(**inputs)
+            # Step 2: Import classes
+            logger.info("📚 Importing model classes...")
+            from diffusers import StableDiffusionXLControlNetPipeline, ControlNetModel
+            from controlnet_aux import CannyDetector
             
-            target_sizes = torch.tensor([resized_img.size[::-1]])
-            results = detector_processor.post_process_object_detection(
-                outputs, target_sizes=target_sizes, threshold=0.6
-            )
+            # Step 3: Try to load ControlNet (smaller model first)
+            logger.info("🔍 Loading ControlNet model...")
+            try:
+                # Try with minimal settings first
+                self.controlnet = ControlNetModel.from_pretrained(
+                    "diffusers/controlnet-canny-sdxl-1.0",
+                    torch_dtype=self.dtype,
+                    token=HF_TOKEN,
+                    cache_dir="./hf_cache",
+                    local_files_only=False,
+                    resume_download=True
+                )
+                logger.info("✅ ControlNet loaded successfully")
+            except Exception as e:
+                self.log_error(f"❌ ControlNet loading failed: {e}")
+                self.log_error(f"Full traceback: {traceback.format_exc()}")
+                self.mode = "fallback"
+                self.initialized = True
+                return True
             
-            furniture_keywords = ['chair', 'couch', 'bed', 'dining table', 'tv', 
-                                'sofa', 'table', 'desk', 'cabinet', 'refrigerator', 'oven']
+            # Step 4: Load main pipeline
+            logger.info("🎨 Loading SDXL pipeline...")
+            try:
+                self.pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+                    "stabilityai/stable-diffusion-xl-base-1.0",
+                    controlnet=self.controlnet,
+                    torch_dtype=self.dtype,
+                    token=HF_TOKEN,
+                    cache_dir="./hf_cache",
+                    local_files_only=False,
+                    resume_download=True,
+                    variant="fp16" if self.dtype == torch.float16 else None,
+                    use_safetensors=True
+                )
+                logger.info("✅ SDXL pipeline loaded successfully")
+            except Exception as e:
+                self.log_error(f"❌ SDXL pipeline loading failed: {e}")
+                self.log_error(f"Full traceback: {traceback.format_exc()}")
+                self.mode = "fallback"
+                self.initialized = True
+                return True
             
-            for score, label, box in zip(results[0]["scores"], results[0]["labels"], results[0]["boxes"]):
-                label_name = detector_model.config.id2label[label.item()]
-                if any(keyword in label_name.lower() for keyword in furniture_keywords):
-                    furniture_items.append({
-                        'label': label_name,
-                        'confidence': score.item(),
-                        'box': box.tolist()
-                    })
-        
-        # Analyze style using caption
-        if max(inspiration_image.size) > 512:
-            caption_img = inspiration_image.resize((512, int(512 * inspiration_image.size[1] / inspiration_image.size[0])))
-        else:
-            caption_img = inspiration_image
+            # Step 5: Move to device
+            logger.info(f"🚀 Moving pipeline to {self.device}...")
+            try:
+                self.pipe = self.pipe.to(self.device)
+                logger.info("✅ Pipeline moved to device successfully")
+            except Exception as e:
+                self.log_error(f"❌ Failed to move pipeline to device: {e}")
+                self.mode = "fallback"
+                self.initialized = True
+                return True
             
-        inputs = caption_processor(caption_img, return_tensors="pt")
-        with torch.no_grad():
-            out = caption_model.generate(**inputs, max_length=30, num_beams=2)
-        
-        caption = caption_processor.decode(out[0], skip_special_tokens=True)
-        
-        # Style detection
-        style_keywords = {
-            'modern': ['modern', 'contemporary', 'sleek', 'minimal', 'glass', 'steel', 'clean'],
-            'traditional': ['traditional', 'classic', 'wood', 'ornate', 'vintage', 'antique'],
-            'minimalist': ['minimal', 'simple', 'clean', 'white', 'empty', 'sparse'],
-            'industrial': ['industrial', 'metal', 'concrete', 'exposed', 'brick'],
-            'scandinavian': ['light', 'bright', 'wooden', 'cozy', 'natural'],
-            'rustic': ['rustic', 'rural', 'country', 'farmhouse']
-        }
-        
-        caption_lower = caption.lower()
-        style_scores = {}
-        
-        for style, keywords in style_keywords.items():
-            score = sum(2 if keyword in caption_lower else 0 for keyword in keywords)
-            if style in caption_lower:
-                score += 5
-            style_scores[style] = score
+            # Step 6: Apply optimizations
+            logger.info("⚡ Applying memory optimizations...")
+            try:
+                if self.device == "cuda":
+                    # Only apply optimizations that are likely to work
+                    self.pipe.enable_vae_slicing()
+                    logger.info("✓ VAE slicing enabled")
+                    
+                    self.pipe.enable_attention_slicing(1)
+                    logger.info("✓ Attention slicing enabled")
+                    
+                    # Try CPU offload (helps with memory)
+                    try:
+                        self.pipe.enable_model_cpu_offload()
+                        logger.info("✓ Model CPU offload enabled")
+                    except Exception as e:
+                        logger.warning(f"⚠️ CPU offload failed: {e}")
+                    
+                    # Try xformers (optional)
+                    try:
+                        self.pipe.enable_xformers_memory_efficient_attention()
+                        logger.info("✓ XFormers enabled")
+                    except Exception as e:
+                        logger.info(f"ℹ️ XFormers not available: {e}")
+                        
+            except Exception as e:
+                logger.warning(f"⚠️ Some optimizations failed: {e}")
             
-        detected_style = max(style_scores, key=style_scores.get) if max(style_scores.values()) > 0 else 'modern'
+            # Step 7: Initialize Canny detector
+            logger.info("🔍 Initializing Canny detector...")
+            try:
+                self.canny_detector = CannyDetector()
+                logger.info("✅ Canny detector initialized")
+            except Exception as e:
+                self.log_error(f"❌ Canny detector initialization failed: {e}")
+                # Continue without it - we have OpenCV fallback
+            
+            # Step 8: Test generation (small test)
+            logger.info("🧪 Testing pipeline with small generation...")
+            try:
+                # Create a small test image
+                test_image = Image.new('RGB', (512, 512), color='white')
+                test_control = self.create_canny_control(test_image)
+                
+                generator = torch.Generator(device=self.device).manual_seed(42)
+                
+                with torch.autocast(self.device, enabled=(self.device=="cuda")):
+                    test_result = self.pipe(
+                        prompt="test room",
+                        image=test_control,
+                        num_inference_steps=1,  # Just 1 step for testing
+                        height=512,
+                        width=512,
+                        generator=generator,
+                        controlnet_conditioning_scale=0.5,
+                        guidance_scale=7.5
+                    ).images[0]
+                
+                logger.info("✅ Pipeline test successful!")
+                
+                # Cleanup test
+                del test_result, test_image, test_control
+                if self.device == "cuda":
+                    torch.cuda.empty_cache()
+                    
+            except Exception as e:
+                self.log_error(f"❌ Pipeline test failed: {e}")
+                self.log_error(f"Full traceback: {traceback.format_exc()}")
+                self.mode = "fallback"
+                self.initialized = True
+                return True
+            
+            self.initialized = True
+            self.mode = "advanced"
+            logger.info("🎉 Advanced AI pipeline fully ready!")
+            return True
+            
+        except Exception as e:
+            self.log_error(f"❌ Unexpected error during initialization: {e}")
+            self.log_error(f"Full traceback: {traceback.format_exc()}")
+            self.mode = "fallback"
+            self.initialized = True
+            return True
+    
+    def prepare_image(self, image: Image.Image) -> Image.Image:
+        """Prepare image for processing"""
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
         
-        return furniture_items, detected_style, caption
+        w, h = image.size
         
-    except Exception as e:
-        print(f"Error analyzing inspiration image: {e}")
-        return [], 'modern', 'A furnished interior space'
-
-def create_canny_control(user_room_image: Image.Image) -> Image.Image:
-    """Create Canny edge detection for ControlNet to preserve room structure"""
-    try:
-        # Convert PIL to numpy
-        image_np = np.array(user_room_image)
+        # Calculate new size maintaining aspect ratio
+        if w > h:
+            new_w = MAX_RESOLUTION
+            new_h = int(h * MAX_RESOLUTION / w)
+        else:
+            new_h = MAX_RESOLUTION
+            new_w = int(w * MAX_RESOLUTION / h)
         
-        # Convert to grayscale
-        gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
+        # Make divisible by 8 for diffusion models
+        new_w = (new_w // 8) * 8
+        new_h = (new_h // 8) * 8
         
-        # Apply Gaussian blur to reduce noise
-        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+        # Ensure minimum size
+        new_w = max(new_w, MIN_RESOLUTION)
+        new_h = max(new_h, MIN_RESOLUTION)
         
-        # Apply Canny edge detection with adjusted parameters for room layouts
-        canny = cv2.Canny(blurred, 50, 150)
+        return image.resize((new_w, new_h), Image.LANCZOS)
+    
+    def create_canny_control(self, image: Image.Image) -> Image.Image:
+        """Create Canny edge control image"""
+        try:
+            if self.canny_detector and self.mode == "advanced":
+                return self.canny_detector(image, low_threshold=100, high_threshold=200)
+        except Exception as e:
+            logger.debug(f"Canny detector failed: {e}")
         
-        # Convert back to PIL
-        canny_image = Image.fromarray(canny)
+        # OpenCV fallback (always works)
+        img_array = np.array(image)
+        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+        edges = cv2.Canny(gray, 100, 200)
+        return Image.fromarray(edges)
+    
+    def generate_advanced(self, room_image: Image.Image, inspiration_image: Image.Image,
+                         prompt: str, control_strength: float, num_steps: int,
+                         guidance_scale: float, seed: int) -> Image.Image:
+        """Generate using SDXL + ControlNet"""
         
-        return canny_image
+        logger.info("🎨 Starting advanced generation...")
         
-    except Exception as e:
-        print(f"Error creating canny control: {e}")
-        return user_room_image.convert('L')
-
-def transform_room_with_inspiration(
-    inspiration_image: Image.Image,
-    user_room_image: Image.Image,
-    style_override: str = "Auto-detect",
-    transformation_strength: float = 0.8,
-    quality: str = "Balanced"
-) -> Tuple[Image.Image, str]:
-    """Main function to transform user's room with inspiration style while preserving structure"""
-    
-    if inspiration_image is None or user_room_image is None:
-        return None, "❌ Please upload both images:\n1. Inspiration image (interior design you like)\n2. Your room image (to be transformed)"
-    
-    try:
-        print("🎯 STEP 1: Analyzing inspiration image for style and furniture...")
+        control_image = self.create_canny_control(room_image)
         
-        # Step 1: Analyze inspiration image to extract style and furniture elements
-        furniture_items, detected_style, scene_description = detect_furniture_and_style(inspiration_image)
+        # Enhanced prompt
+        enhanced_prompt = f"{prompt}, professional interior design, high quality, detailed"
+        negative_prompt = "blurry, low quality, distorted, deformed, ugly, oversaturated, cluttered"
         
-        # Use style override if provided, otherwise use detected style
-        final_style = style_override if style_override != "Auto-detect" else detected_style
+        generator = torch.Generator(device=self.device).manual_seed(seed)
         
-        print(f"📊 Detected style: {detected_style}, Using: {final_style}")
-        print(f"🪑 Found {len(furniture_items)} furniture items")
+        # Clear cache before generation
+        if self.device == "cuda":
+            torch.cuda.empty_cache()
         
-        print("🎯 STEP 2: Analyzing user room structure for preservation...")
+        logger.info(f"Generation parameters: steps={num_steps}, guidance={guidance_scale}, control={control_strength}")
         
-        # Step 2: Create ControlNet control image to preserve room structure
-        canny_control = create_canny_control(user_room_image)
+        with torch.autocast(self.device, enabled=(self.device=="cuda")):
+            result = self.pipe(
+                prompt=enhanced_prompt,
+                negative_prompt=negative_prompt,
+                image=control_image,
+                controlnet_conditioning_scale=control_strength,
+                num_inference_steps=num_steps,
+                guidance_scale=guidance_scale,
+                generator=generator,
+                height=room_image.height,
+                width=room_image.width
+            ).images[0]
         
-        print("🎯 STEP 3: Building transformation prompt from inspiration...")
+        # Cleanup
+        if self.device == "cuda":
+            torch.cuda.empty_cache()
         
-        # Step 3: Build detailed prompt based on inspiration analysis
-        furniture_list = [item['label'] for item in furniture_items]
-        furniture_str = ", ".join(set(furniture_list)) if furniture_list else "modern furniture"
+        logger.info("✅ Advanced generation completed")
+        return result
+    
+    def style_transfer_fallback(self, room_image: Image.Image, inspiration_image: Image.Image) -> Image.Image:
+        """Computer vision-based style transfer"""
+        logger.info("🎨 Using computer vision style transfer...")
         
-        # Style-specific prompt generation
-        style_descriptions = {
-            'modern': "modern interior design, contemporary furniture, clean lines, sleek finishes, neutral colors, minimalist aesthetic",
-            'traditional': "traditional interior design, classic furniture, warm wood tones, elegant details, ornate elements",
-            'minimalist': "minimalist interior design, simple clean furniture, neutral palette, uncluttered space, zen aesthetic",
-            'industrial': "industrial interior design, metal fixtures, exposed elements, urban aesthetic, concrete and steel",
-            'scandinavian': "scandinavian interior design, light wood furniture, cozy textiles, natural light, hygge atmosphere",
-            'rustic': "rustic interior design, wooden furniture, country style, natural textures, farmhouse charm"
-        }
+        room_array = np.array(room_image).astype(np.float32) / 255.0
+        inspiration_array = np.array(inspiration_image).astype(np.float32) / 255.0
         
-        style_prompt = style_descriptions.get(final_style.lower(), style_descriptions['modern'])
+        # Convert to LAB color space for better color transfer
+        room_lab = cv2.cvtColor((room_array * 255).astype(np.uint8), cv2.COLOR_RGB2LAB).astype(np.float32)
+        inspiration_lab = cv2.cvtColor((inspiration_array * 255).astype(np.uint8), cv2.COLOR_RGB2LAB).astype(np.float32)
         
-        # Create comprehensive prompt that incorporates inspiration elements
-        if furniture_list:
-            main_prompt = f"{style_prompt}, featuring {furniture_str}, well-arranged interior space, professional photography, beautiful lighting, high quality interior design"
-        else:
-            main_prompt = f"{style_prompt}, beautifully furnished room, professional interior photography, elegant arrangement, high quality"
+        # Transfer color statistics
+        for channel in range(3):
+            room_mean, room_std = cv2.meanStdDev(room_lab[:,:,channel])
+            inspiration_mean, inspiration_std = cv2.meanStdDev(inspiration_lab[:,:,channel])
+            
+            if room_std > 0:
+                room_lab[:,:,channel] = ((room_lab[:,:,channel] - room_mean) * 
+                                       (inspiration_std / room_std) + inspiration_mean)
         
-        negative_prompt = "blurry, low quality, distorted, cluttered, dark, bad architecture, deformed furniture, amateur photography, poor lighting"
+        # Clamp values to valid ranges
+        room_lab[:,:,0] = np.clip(room_lab[:,:,0], 0, 100)    # L channel
+        room_lab[:,:,1] = np.clip(room_lab[:,:,1], -127, 127) # A channel  
+        room_lab[:,:,2] = np.clip(room_lab[:,:,2], -127, 127) # B channel
         
-        print("🎯 STEP 4: Generating transformed room while preserving structure...")
-        print("⏱️  This will take 3-5 minutes on CPU...")
+        # Convert back to RGB
+        result_array = cv2.cvtColor(room_lab.astype(np.uint8), cv2.COLOR_LAB2RGB)
+        result_image = Image.fromarray(result_array)
         
-        # Step 4: Generate transformation using ControlNet to preserve room structure
-        inference_steps = {"Fast": 12, "Balanced": 18, "High Quality": 25}
-        steps = inference_steps.get(quality, 18)
+        # Enhance the result
+        enhancer = ImageEnhance.Contrast(result_image)
+        result_image = enhancer.enhance(1.15)
         
-        # Resize images for consistent processing while maintaining aspect ratios
-        target_size = (512, 512)
-        user_room_resized = user_room_image.resize(target_size)
-        canny_control_resized = canny_control.resize(target_size)
+        enhancer = ImageEnhance.Color(result_image)
+        result_image = enhancer.enhance(1.25)
         
-        # Generate the transformed image using ControlNet
-        with torch.no_grad():
-            generated_image = controlnet_pipe(
-                prompt=main_prompt,
-                negative_prompt=negative_prompt,
-                image=canny_control_resized,  # This preserves the room structure
-                num_inference_steps=steps,
-                guidance_scale=7.5,
-                controlnet_conditioning_scale=transformation_strength,  # How much to preserve vs transform
-                height=target_size[1],
-                width=target_size[0],
-                generator=torch.manual_seed(42)  # For reproducible results
-            ).images[0]
+        logger.info("✅ Style transfer completed")
+        return result_image
+    
+    def transform_room(self, room_image: Image.Image, inspiration_image: Image.Image,
+                      custom_prompt: str = "", control_strength: float = 0.8,
+                      style_strength: float = 0.7, num_steps: int = 20,
+                      guidance_scale: float = 7.5, seed: int = 42) -> Tuple[Image.Image, Dict]:
+        """Main transformation function"""
         
-        # Resize result back to match original user room dimensions
-        final_size = user_room_image.size
-        generated_image = generated_image.resize(final_size, Image.LANCZOS)
+        # Initialize if needed
+        if not self.initialized:
+            self.initialize_pipeline()
         
-        print("🎯 STEP 5: Creating transformation analysis report...")
+        # Prepare images
+        room_prepared = self.prepare_image(room_image)
+        inspiration_prepared = self.prepare_image(inspiration_image)
         
-        # Step 5: Create detailed analysis report
-        furniture_report = ""
-        if furniture_items:
-            furniture_report = "\n".join([f"• {item['label']} (confidence: {item['confidence']:.2f})" for item in furniture_items[:8]])
-        else:
-            furniture_report = "• General interior styling elements detected"
+        # Create control image for display
+        control_image = self.create_canny_control(room_prepared)
         
-        analysis_report = f"""**🎨 ROOM TRANSFORMATION COMPLETE**
-
-**📸 INSPIRATION ANALYSIS:**
-• **Original Style Detected:** {detected_style.title()}
-• **Applied Style:** {final_style.title()}
-• **Scene Description:** {scene_description}
+        try:
+            if self.mode == "advanced" and self.pipe is not None:
+                if not custom_prompt.strip():
+                    custom_prompt = "elegant modern interior design, stylish furniture, beautiful lighting"
+                
+                result = self.generate_advanced(
+                    room_prepared, inspiration_prepared, custom_prompt,
+                    control_strength, num_steps, guidance_scale, seed
+                )
+                mode_used = "🤖 SDXL + ControlNet AI"
+                
+            else:
+                result = self.style_transfer_fallback(room_prepared, inspiration_prepared)
+                mode_used = "🎨 Computer Vision Style Transfer"
+            
+            info = {
+                'control_image': control_image,
+                'mode': mode_used,
+                'prompt': custom_prompt,
+                'device': self.device,
+                'resolution': f"{room_prepared.width}x{room_prepared.height}",
+                'pipeline_mode': self.mode,
+                'error_log': self.error_log.copy() if self.error_log else None
+            }
+            
+            return result, info
+            
+        except Exception as e:
+            self.log_error(f"Generation failed: {e}")
+            self.log_error(f"Full traceback: {traceback.format_exc()}")
+            
+            # Emergency fallback
+            result = self.style_transfer_fallback(room_prepared, inspiration_prepared)
+            info = {
+                'control_image': control_image,
+                'mode': "🛠️ Emergency Fallback",
+                'error': str(e),
+                'device': self.device,
+                'resolution': f"{room_prepared.width}x{room_prepared.height}",
+                'error_log': self.error_log.copy()
+            }
+            return result, info
 
-**🪑 FURNITURE & ELEMENTS FROM INSPIRATION:**
-{furniture_report}
+# Global pipeline instance
+pipeline = None
 
-**🏠 TRANSFORMATION DETAILS:**
-• **Structure Preservation:** ✅ Room dimensions and layout preserved using ControlNet
-• **Style Transfer:** ✅ {final_style.title()} aesthetic applied from inspiration
-• **Transformation Strength:** {transformation_strength:.1%} (higher = more dramatic change)
-• **Quality Setting:** {quality} ({steps} generation steps)
-• **Processing Method:** Canny edge detection + Stable Diffusion ControlNet
+def get_pipeline():
+    """Get or create pipeline"""
+    global pipeline
+    if pipeline is None:
+        pipeline = InteriorDesignPipeline()
+    return pipeline
 
-**🎯 WHAT WAS PRESERVED:**
-• Room walls and architectural structure
-• Window/door positions and proportions
-• Overall room dimensions and layout
-• Spatial relationships and perspective
+def transform_images(room_image, inspiration_image, custom_prompt, 
+                    control_strength, style_strength, num_steps,
+                    guidance_scale, seed):
+    """Main processing function for Gradio interface"""
+    
+    if room_image is None:
+        return None, None, "❌ Please upload a room image"
+    
+    if inspiration_image is None:
+        return None, None, "❌ Please upload an inspiration image"
+    
+    try:
+        pipe = get_pipeline()
+        
+        result, info = pipe.transform_room(
+            room_image, inspiration_image, custom_prompt,
+            control_strength, style_strength, num_steps,
+            guidance_scale, seed
+        )
+        
+        # Create detailed status message with debug info
+        status = f"""✅ Transformation Complete!
 
-**✨ WHAT WAS TRANSFORMED:**
-• Interior design style and aesthetic
-• Furniture arrangement and selection
-• Color scheme and lighting mood
-• Decorative elements and textures
+🔧 Mode: {info['mode']}
+💻 Device: {info['device']} 
+📐 Resolution: {info['resolution']}
+🧠 Pipeline Status: {info.get('pipeline_mode', 'unknown')}
+📝 Prompt: {info['prompt'][:100]}{'...' if len(info['prompt']) > 100 else ''}
 
-**💡 Tips for Better Results:**
-• Try different transformation strengths (0.3-1.0)
-• Use clear, well-lit photos of both images
-• Similar room types work best (bedroom to bedroom, etc.)
-• Experiment with style overrides for different aesthetics
-        """
+{get_mode_description(info.get('pipeline_mode', 'unknown'))}
+"""
+        
+        # Add error information if available
+        if info.get('error_log'):
+            status += f"\n\n🔍 DEBUG INFO:\n"
+            for i, error in enumerate(info['error_log'][-3:]):  # Show last 3 errors
+                status += f"{i+1}. {error[:100]}{'...' if len(error) > 100 else ''}\n"
+        
+        if 'error' in info:
+            status += f"\n⚠️ Last Error: {info['error'][:150]}{'...' if len(info['error']) > 150 else ''}"
         
-        print("✅ TRANSFORMATION COMPLETED SUCCESSFULLY!")
-        return generated_image, analysis_report
+        return result, info['control_image'], status
         
     except Exception as e:
-        error_msg = f"""❌ TRANSFORMATION FAILED
+        error_msg = f"""❌ Critical Processing Error
 
-**Error:** {str(e)}
+Error: {str(e)[:300]}{'...' if len(str(e)) > 300 else ''}
 
-**Troubleshooting:**
-• Ensure both images are clear and well-lit
-• Try reducing transformation strength
-• Check that images show interior spaces
-• Try different quality settings
+Full traceback:
+{traceback.format_exc()[:500]}{'...' if len(traceback.format_exc()) > 500 else ''}
 
-Please try again with different images or settings."""
+This information can help debug the issue."""
+        
+        return None, None, error_msg
+
+def get_mode_description(mode):
+    """Get description for current mode"""
+    descriptions = {
+        "advanced": "🚀 Using state-of-the-art AI models (SDXL + ControlNet) - Full AI processing active!",
+        "fallback": "🎨 Using computer vision algorithms for style transfer - AI models failed to load", 
+        "uninitialized": "⏳ Pipeline initializing...",
+        "unknown": "🔄 Processing with available methods"
+    }
+    return descriptions.get(mode, "🔄 Processing...")
+
+def get_debug_info():
+    """Get system debug information"""
+    info = f"""🔍 System Debug Information:
+
+💻 Device: {DEVICE}
+🔢 Data Type: {DTYPE}
+🎮 CUDA Available: {torch.cuda.is_available()}
+"""
+    
+    if torch.cuda.is_available():
+        info += f"""🎮 CUDA Device: {torch.cuda.get_device_name()}
+💾 CUDA Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f}GB
+"""
+    
+    info += f"""🔑 HF Token: {'Available' if HF_TOKEN else 'Not set'}
+📦 PyTorch Version: {torch.__version__}
+"""
+    
+    try:
+        import diffusers
+        info += f"📦 Diffusers Version: {diffusers.__version__}\n"
+    except:
+        info += "📦 Diffusers: Not available\n"
+    
+    try:
+        import transformers
+        info += f"📦 Transformers Version: {transformers.__version__}\n"
+    except:
+        info += "📦 Transformers: Not available\n"
         
-        print(f"Error in room transformation: {e}")
-        return None, error_msg
+    return info
 
-def create_room_transformer_interface():
-    """Create the main room transformation interface"""
+def create_gradio_interface():
+    """Create the Gradio interface with debug info"""
     
     with gr.Blocks(
-        title="AI Room Transformer - Style Transfer with Structure Preservation",
+        title="Interior Design AI - Debug Mode",
+        theme=gr.themes.Soft(),
         css="""
-        .main-container { max-width: 1200px; margin: 0 auto; }
-        .header { text-align: center; padding: 2rem 0; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; margin-bottom: 2rem; border-radius: 10px; }
-        .instruction-box { background: #f8f9fa; padding: 1.5rem; border-radius: 8px; margin: 1rem 0; border-left: 4px solid #007bff; }
-        .settings-panel { background: #e3f2fd; padding: 1rem; border-radius: 8px; margin: 1rem 0; }
-        .result-panel { background: #f1f8e9; padding: 1rem; border-radius: 8px; margin: 1rem 0; }
+        .gradio-container {
+            max-width: 1400px !important;
+        }
+        .status-box {
+            font-family: monospace;
+            font-size: 11px;
+        }
         """
     ) as demo:
         
-        with gr.Column(elem_classes="main-container"):
-            # Header
-            gr.HTML("""
-            <div class="header">
-                <h1>🏠 AI Room Transformer</h1>
-                <h3>Transform Your Room with Inspiration While Preserving Structure</h3>
-                <p>Upload an inspiration image and your room image to see the magic happen!</p>
-            </div>
-            """)
-            
-            # Instructions
-            gr.HTML("""
-            <div class="instruction-box">
-                <h3>📋 How It Works:</h3>
-                <ol>
-                    <li><strong>Inspiration Image:</strong> Upload an interior design photo you love (this provides the style, colors, and furniture ideas)</li>
-                    <li><strong>Your Room Image:</strong> Upload a photo of your room (empty or furnished - the structure will be preserved)</li>
-                    <li><strong>AI Magic:</strong> Our AI analyzes the inspiration style and applies it to your room while keeping walls, doors, windows in place</li>
-                    <li><strong>Result:</strong> Get a transformed room that keeps your space's dimensions but adopts the inspiration's aesthetic</li>
-                </ol>
-            </div>
-            """)
-            
-            # Main interface
-            with gr.Row():
-                # Input Section
-                with gr.Column(scale=1):
-                    gr.Markdown("### 🎨 INPUT IMAGES")
-                    
-                    inspiration_input = gr.Image(
-                        label="📸 Inspiration Image (Interior Design You Like)",
-                        type="pil",
-                        height=300
-                    )
-                    gr.Markdown("*Upload a beautiful interior design photo for style reference*")
-                    
-                    user_room_input = gr.Image(
-                        label="🏠 Your Room Image (To Be Transformed)", 
-                        type="pil",
-                        height=300
-                    )
-                    gr.Markdown("*Upload your room photo - structure will be preserved*")
-                    
-                    # Settings Panel
-                    with gr.Column(elem_classes="settings-panel"):
-                        gr.Markdown("### ⚙️ TRANSFORMATION SETTINGS")
+        gr.Markdown("""
+        # 🏠 Interior Design AI Transformer (Debug Mode)
+        
+        This debug version provides detailed information about what's happening during model loading and processing.
+        """)
+        
+        with gr.Tabs():
+            with gr.TabItem("🚀 Transform"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📤 Input")
                         
-                        style_override = gr.Dropdown(
-                            choices=["Auto-detect", "Modern", "Traditional", "Minimalist", 
-                                    "Industrial", "Scandinavian", "Rustic"],
-                            label="🎭 Style Override",
-                            value="Auto-detect",
-                            info="Override auto-detected style if desired"
-                        )
+                        room_input = gr.Image(type="pil", label="🏠 Your Room Photo", height=300)
+                        inspiration_input = gr.Image(type="pil", label="🎨 Style Inspiration", height=300)
                         
-                        transformation_strength = gr.Slider(
-                            minimum=0.3,
-                            maximum=1.0,
-                            value=0.8,
-                            step=0.1,
-                            label="💪 Transformation Strength",
-                            info="Higher = more dramatic change, Lower = more preservation"
+                        prompt_input = gr.Textbox(
+                            label="📝 Custom Style Description (Optional)",
+                            placeholder="modern minimalist, Scandinavian design, warm lighting...",
+                            lines=3
                         )
                         
-                        quality_setting = gr.Dropdown(
-                            choices=["Fast", "Balanced", "High Quality"],
-                            label="⚡ Quality Setting",
-                            value="Balanced",
-                            info="Higher quality takes longer but produces better results"
-                        )
-                    
-                    transform_btn = gr.Button(
-                        "🎨 TRANSFORM MY ROOM", 
-                        variant="primary",
-                        size="lg"
-                    )
-                
-                # Output Section
-                with gr.Column(scale=1):
-                    gr.Markdown("### ✨ TRANSFORMATION RESULT")
+                        with gr.Row():
+                            control_strength = gr.Slider(0.5, 1.0, 0.8, label="🏗️ Structure Preservation")
+                            style_strength = gr.Slider(0.3, 1.0, 0.7, label="🎨 Style Intensity")
+                        
+                        with gr.Accordion("⚙️ Advanced Settings", open=False):
+                            num_steps = gr.Slider(10, 30, 20, step=5, label="🔄 Steps")
+                            guidance_scale = gr.Slider(3.0, 12.0, 7.5, label="🎯 Guidance")
+                            seed = gr.Number(42, label="🎲 Seed", precision=0)
+                        
+                        generate_btn = gr.Button("🚀 Transform Room", variant="primary", size="lg")
                     
-                    with gr.Column(elem_classes="result-panel"):
-                        output_image = gr.Image(
-                            label="🏠 Your Transformed Room",
-                            type="pil",
-                            height=400
-                        )
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 Results")
+                        result_output = gr.Image(type="pil", label="✨ Result", height=400)
+                        control_output = gr.Image(type="pil", label="🔍 Edge Control", height=200)
                         
-                        analysis_output = gr.Markdown(
-                            value="**Upload both images and click 'TRANSFORM MY ROOM' to see the magic!**\n\n⏱️ Processing typically takes 3-5 minutes on CPU.",
-                            label="📊 Transformation Analysis"
+                        status_output = gr.Textbox(
+                            label="📊 Detailed Status & Debug Info", 
+                            lines=15, 
+                            interactive=False,
+                            value="🔧 Ready! Upload images and click Transform to see detailed processing info.",
+                            elem_classes=["status-box"]
                         )
             
-            # Process button click
-            transform_btn.click(
-                fn=transform_room_with_inspiration,
-                inputs=[
-                    inspiration_input, 
-                    user_room_input, 
-                    style_override, 
-                    transformation_strength, 
-                    quality_setting
-                ],
-                outputs=[output_image, analysis_output]
-            )
-            
-            # Footer
-            gr.HTML("""
-            <div style="text-align: center; margin-top: 2rem; padding: 1rem; background: #f8f9fa; border-radius: 8px;">
-                <p><strong>🚀 AI Room Transformer</strong> | Powered by Stable Diffusion + ControlNet</p>
-                <p>Preserves your room structure while applying inspiration aesthetics</p>
-            </div>
-            """)
+            with gr.TabItem("🔍 Debug Info"):
+                gr.Markdown("### 🔍 System Information")
+                debug_info = gr.Textbox(
+                    value=get_debug_info(),
+                    lines=15,
+                    interactive=False,
+                    elem_classes=["status-box"]
+                )
+                
+                refresh_debug = gr.Button("🔄 Refresh Debug Info")
+                refresh_debug.click(fn=get_debug_info, outputs=debug_info)
+        
+        # Event handling
+        generate_btn.click(
+            fn=transform_images,
+            inputs=[
+                room_input, inspiration_input, prompt_input,
+                control_strength, style_strength, num_steps,
+                guidance_scale, seed
+            ],
+            outputs=[result_output, control_output, status_output],
+            show_progress=True
+        )
+        
+        gr.Markdown("""
+        ### 🔍 Debug Information
+        This version shows detailed logs to help identify why the AI models might not be loading.
+        Check the "Debug Info" tab and the status messages for clues.
+        """)
     
     return demo
 
-# Main execution
 if __name__ == "__main__":
-    print("🏠 Starting AI Room Transformer with Structure Preservation...")
-    print(f"📋 Device: {device}")
-    print(f"🔧 PyTorch: {torch.__version__}")
+    logger.info("🏠 Starting Interior Design AI (Debug Mode)")
     
-    try:
-        if load_models():
-            print("✅ All models loaded successfully!")
-            print("🚀 Creating room transformation interface...")
-            
-            demo = create_room_transformer_interface()
-            
-            print("🌐 Launching application...")
-            print("🎯 Ready to transform rooms while preserving structure!")
-            
-            # Launch with proper settings for different environments
-            demo.launch(
-                share=True,  # Create public link
-                show_error=True,
-                debug=False,
-                server_name="0.0.0.0",
-                server_port=7860 if os.environ.get('SPACE_ID') else None  # Use 7860 for HF Spaces
-            )
-            
-        else:
-            print("❌ Model loading failed!")
-            # Create simple error interface
-            with gr.Blocks() as error_demo:
-                gr.Markdown("# ❌ AI Room Transformer - Model Loading Error")
-                gr.Markdown("""
-                The AI models failed to load properly.
-                
-                **Common causes:**
-                - Insufficient memory
-                - Network issues downloading models  
-                - Missing dependencies
-                
-                **Please try:**
-                1. Refreshing the page
-                2. Waiting a few minutes for models to download
-                3. Checking system resources
-                """)
-            
-            error_demo.launch(share=True, server_name="0.0.0.0")
-            
-    except Exception as e:
-        print(f"❌ Critical startup error: {e}")
-        import traceback
-        traceback.print_exc()
+    # Show initial debug info
+    print("\n" + "="*50)
+    print(get_debug_info())
+    print("="*50 + "\n")
+    
+    # Create and launch interface
+    demo = create_gradio_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        share=False
+    )