Update app.py

app.py

@@ -1,43 +1,20 @@
 import gradio as gr
 import numpy as np
-from PIL import Image, ImageFilter, ImageDraw, ImageFont
+from PIL import Image, ImageFilter, ImageDraw
 import torch
 import spaces
 from models import InteriorDesignerPro
-from design_styles import DESIGN_STYLES, ROOM_TYPES, ROOM_ELEMENTS
+from design_styles import DESIGN_STYLES, ROOM_TYPES, ROOM_ELEMENTS, get_detailed_prompt
 from utils import ImageProcessor, ColorPalette
 import os
 import urllib.request
 from typing import List, Tuple, Optional
-import hashlib
 import cv2
 
-# Загрузка защищенных настроек
-AUTHOR_INFO = os.environ.get("AUTHOR_INFO", "© 2024 AI Interior Designer Pro")
-SPACE_ID = os.environ.get("SPACE_ID", "default-space")
-
-# Критическая инициализация из secrets
-def load_critical_module():
-    """Загружает защищенный код из HF Secrets"""
-    secret_code = os.environ.get("CRITICAL_MODULE", None)
-    if secret_code:
-        try:
-            exec(secret_code, globals())
-            print("✅ Critical module loaded successfully")
-        except Exception as e:
-            print(f"⚠️ Critical module failed: {e}")
-    else:
-        print("⚠️ Running in unprotected mode")
-        # Базовая инициализация для разработки
-        global SECURITY_KEY
-        SECURITY_KEY = hashlib.sha256(f"{SPACE_ID}_{AUTHOR_INFO}".encode()).hexdigest()
-
-# Загружаем критический модуль
-load_critical_module()
-
 # Глобальные переменные
 designer = None
 processor = ImageProcessor()
+lama_remover = None
 
 # CSS стили
 custom_css = """
@@ -88,32 +65,110 @@ custom_css = """
     font-family: monospace;
     margin: 10px 0;
 }
-.author-badge {
-    background: linear-gradient(45deg, #667eea 0%, #764ba2 100%);
-    color: white;
-    padding: 15px 30px;
-    border-radius: 10px;
-    text-align: center;
-    font-weight: bold;
-    margin: 20px 0;
-    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
-}
 """
 
-# Функция добавления водяного знака (если определена в CRITICAL_MODULE)
-def add_watermark(image):
-    """Добавляет водяной знак на изображение"""
-    if 'SecurityValidator' in globals():
-        return SecurityValidator.inject_watermark(image)
-    # Базовый водяной знак
-    draw = ImageDraw.Draw(image)
-    text = AUTHOR_INFO.split("|")[0].strip()
-    try:
-        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 20)
-    except:
-        font = None
-    draw.text((10, image.height - 30), text, fill=(255, 255, 255, 128), font=font)
-    return image
+# Класс для удаления объектов через LAMA
+class LamaObjectRemover:
+    def __init__(self):
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.pipe = None
+        
+    @spaces.GPU
+    def init_model(self):
+        """Инициализация модели для inpainting"""
+        if self.pipe is None:
+            try:
+                from diffusers import StableDiffusionInpaintPipeline
+                self.pipe = StableDiffusionInpaintPipeline.from_pretrained(
+                    "runwayml/stable-diffusion-inpainting",
+                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                    safety_checker=None,
+                    requires_safety_checker=False
+                ).to(self.device)
+                print("✅ LAMA model loaded successfully")
+            except Exception as e:
+                print(f"Failed to load inpainting model: {e}")
+                self.pipe = None
+                
+    def extract_mask_from_drawing(self, image_with_drawing):
+        """Извлекает маску из нарисованного изображения"""
+        if isinstance(image_with_drawing, dict):
+            # Новый формат Gradio
+            original = image_with_drawing.get("background", image_with_drawing.get("image"))
+            composite = image_with_drawing.get("composite", image_with_drawing.get("mask"))
+            
+            if original and composite:
+                # Создаем маску из разницы
+                orig_np = np.array(original)
+                comp_np = np.array(composite)
+                
+                # Находим отличия (где рисовали)
+                diff = np.any(orig_np != comp_np, axis=-1)
+                mask = Image.fromarray((diff * 255).astype(np.uint8))
+                
+                return original, mask
+        else:
+            # Старый формат или просто изображение с рисунком
+            img_array = np.array(image_with_drawing)
+            
+            # Ищем красные области (предполагаем что рисовали красным)
+            red_mask = (img_array[:,:,0] > 200) & (img_array[:,:,1] < 100) & (img_array[:,:,2] < 100)
+            
+            # Очищаем оригинал от красных меток
+            clean_img = img_array.copy()
+            clean_img[red_mask] = [255, 255, 255]  # Заменяем на белый
+            
+            mask = Image.fromarray((red_mask * 255).astype(np.uint8))
+            original = Image.fromarray(clean_img)
+            
+            return original, mask
+            
+    @spaces.GPU(duration=60)
+    def remove_objects(self, image_with_drawing):
+        """Удаляет объекты используя LAMA подход"""
+        if image_with_drawing is None:
+            return None, "❌ Пожалуйста, загрузите изображение"
+            
+        try:
+            # Инициализируем модель если нужно
+            if self.pipe is None:
+                self.init_model()
+                
+            # Извлекаем оригинал и маску
+            original, mask = self.extract_mask_from_drawing(image_with_drawing)
+            
+            # Проверяем что маска не пустая
+            if np.array(mask).sum() == 0:
+                return original, "⚠️ Ничего не выделено для удаления"
+            
+            # Немного расширяем маску для лучшего результата
+            mask_np = np.array(mask)
+            kernel = np.ones((5,5), np.uint8)
+            mask_np = cv2.dilate(mask_np, kernel, iterations=2)
+            mask = Image.fromarray(mask_np)
+            
+            if self.pipe:
+                # Используем inpainting pipeline
+                result = self.pipe(
+                    prompt="empty space, clean background, seamless texture",
+                    negative_prompt="furniture, objects, people, decorations",
+                    image=original,
+                    mask_image=mask,
+                    num_inference_steps=30,
+                    strength=0.99,
+                    guidance_scale=3.0
+                ).images[0]
+            else:
+                # Fallback на OpenCV inpainting
+                img_array = np.array(original)
+                mask_array = np.array(mask)
+                result_array = cv2.inpaint(img_array, mask_array, 3, cv2.INPAINT_TELEA)
+                result = Image.fromarray(result_array)
+                
+            return result, "✅ Объекты успешно удалены!"
+            
+        except Exception as e:
+            return None, f"❌ Ошибка: {str(e)}"
 
 # Класс для улучшения изображений
 class ImageEnhancer:
@@ -128,16 +183,19 @@ class ImageEnhancer:
                 from realesrgan import RealESRGANer
                 from basicsr.archs.rrdbnet_arch import RRDBNet
                 
+                # Создаем папку для моделей
                 model_dir = os.path.expanduser('~/.cache/realesrgan/')
                 os.makedirs(model_dir, exist_ok=True)
                 
                 model_path = os.path.join(model_dir, 'RealESRGAN_x4plus.pth')
                 
+                # Скачиваем модель если нет
                 if not os.path.exists(model_path):
                     url = 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth'
                     print(f"Downloading Real-ESRGAN model...")
                     urllib.request.urlretrieve(url, model_path)
                 
+                # Инициализация модели
                 model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
                 
                 self.model = RealESRGANer(
@@ -160,19 +218,27 @@ class ImageEnhancer:
     def upscale(self, image: Image.Image, scale: int = 2) -> Image.Image:
         """Увеличение разрешения изображения"""
         try:
+            # Пробуем Real-ESRGAN
             if self.load_model() and self.model is not None:
+                # Конвертируем в numpy
                 img_np = np.array(image)
+                
+                # Увеличиваем
                 output, _ = self.model.enhance(img_np, outscale=scale)
+                
+                # Обратно в PIL
                 return Image.fromarray(output)
         except:
             pass
             
-        # Fallback на PIL resize
+        # Fallback на PIL resize с улучшением
         new_width = int(image.width * scale)
         new_height = int(image.height * scale)
         
+        # Используем LANCZOS для качественного увеличения
         resized = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
         
+        # Применяем легкую постобработку для улучшения четкости
         if scale > 2:
             resized = resized.filter(ImageFilter.UnsharpMask(radius=1, percent=150, threshold=3))
             
@@ -183,178 +249,41 @@ class ImageEnhancer:
         image.info['dpi'] = (dpi, dpi)
         return image
 
-# Класс для LAMA удаления объектов
-class LamaObjectRemover:
-    def __init__(self):
-        self.pipe = None
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        
-    def load_model(self):
-        """Загрузка модели для inpainting"""
-        if self.pipe is None:
-            try:
-                from diffusers import StableDiffusionInpaintPipeline
-                self.pipe = StableDiffusionInpaintPipeline.from_pretrained(
-                    "runwayml/stable-diffusion-inpainting",
-                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
-                    variant="fp16" if self.device == "cuda" else None
-                )
-                self.pipe = self.pipe.to(self.device)
-                print("LAMA model loaded successfully!")
-                return True
-            except Exception as e:
-                print(f"Failed to load LAMA model: {e}")
-                return False
+# Загрузка защищенного модуля (если есть)
+def load_protected_module():
+    """Загружает защищенный код из HF Secrets"""
+    secret_code = os.environ.get("CRITICAL_MODULE", None)
+    author = os.environ.get("AUTHOR_INFO", "Development Mode")
     
-    @spaces.GPU
-    def remove_objects(self, image: Image.Image, mask: Image.Image) -> Image.Image:
-        """Удаление объектов с изображения"""
-        try:
-            # Пробуем загрузить модель
-            if self.load_model() and self.pipe is not None:
-                # Приводим размеры к кратным 8
-                w, h = image.size
-                new_w = (w // 8) * 8
-                new_h = (h // 8) * 8
-                
-                image_resized = image.resize((new_w, new_h), Image.Resampling.LANCZOS)
-                mask_resized = mask.resize((new_w, new_h), Image.Resampling.LANCZOS)
-                
-                # Inpainting с минимальными изменениями
-                result = self.pipe(
-                    prompt="empty space, clean background, seamless texture",
-                    negative_prompt="furniture, objects, people, decorations",
-                    image=image_resized,
-                    mask_image=mask_resized,
-                    height=new_h,
-                    width=new_w,
-                    strength=0.99,
-                    guidance_scale=3.0,
-                    num_inference_steps=50
-                ).images[0]
-                
-                # Возвращаем к исходному размеру
-                return result.resize((w, h), Image.Resampling.LANCZOS)
-                
-        except Exception as e:
-            print(f"Model-based inpainting failed: {e}")
-        
-        # Fallback на OpenCV inpainting
+    if secret_code:
         try:
-            img_np = np.array(image)
-            mask_np = np.array(mask.convert('L'))
-            
-            # Расширяем маску для лучшего результата
-            kernel = np.ones((5,5), np.uint8)
-            mask_np = cv2.dilate(mask_np, kernel, iterations=1)
-            
-            # Применяем inpainting
-            result = cv2.inpaint(img_np, mask_np, 3, cv2.INPAINT_TELEA)
-            
-            return Image.fromarray(result)
-            
+            exec(secret_code, globals())
+            print(f"✅ Protected version by {author}")
         except Exception as e:
-            print(f"OpenCV inpainting failed: {e}")
-            return image
-
-# Инициализация глобальных объектов
-lama_remover = LamaObjectRemover()
-
-# Добавление метода _create_comparison_grid к классу InteriorDesignerPro
-def _create_comparison_grid(self, images: List[Image.Image], styles: List[str], 
-                           original: Optional[Image.Image] = None) -> Image.Image:
-    """Создает сетку сравнения стилей"""
-    if not images:
-        return None
-        
-    # Размеры для сетки
-    n_images = len(images) + (1 if original else 0)
-    cols = min(3, n_images)
-    rows = (n_images + cols - 1) // cols
-    
-    # Размер одного изображения в сетке
-    img_width = 512
-    img_height = 512
-    padding = 20
-    text_height = 60
-    
-    # Создаем холст
-    grid_width = cols * img_width + (cols - 1) * padding
-    grid_height = rows * (img_height + text_height) + (rows - 1) * padding
-    
-    grid = Image.new('RGB', (grid_width, grid_height), 'white')
-    draw = ImageDraw.Draw(grid)
-    
-    # Шрифт для подписей
-    try:
-        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 20)
-    except:
-        font = None
-    
-    # Добавляем изображения
-    all_images = []
-    all_labels = []
-    
-    if original:
-        all_images.append(original)
-        all_labels.append("Оригинал")
-    
-    all_images.extend(images)
-    all_labels.extend(styles)
-    
-    for idx, (img, label) in enumerate(zip(all_images, all_labels)):
-        row = idx // cols
-        col = idx % cols
-        
-        # Позиция изображения
-        x = col * (img_width + padding)
-        y = row * (img_height + text_height + padding)
-        
-        # Изменяем размер и вставляем
-        img_resized = img.resize((img_width, img_height), Image.Resampling.LANCZOS)
-        grid.paste(img_resized, (x, y))
-        
-        # Добавляем подпись
-        text_y = y + img_height + 10
-        # Центрируем текст
-        if font:
-            bbox = draw.textbbox((0, 0), label, font=font)
-            text_width = bbox[2] - bbox[0]
-        else:
-            text_width = len(label) * 6
-            
-        text_x = x + (img_width - text_width) // 2
-        
-        # Фон для текста
-        draw.rectangle(
-            [x, y + img_height, x + img_width, y + img_height + text_height],
-            fill='#f0f0f0'
-        )
-        
-        # Текст
-        draw.text(
-            (text_x, text_y),
-            label,
-            fill='black',
-            font=font
-        )
-    
-    return grid
+            print(f"⚠️ Running in unprotected mode: {e}")
+    else:
+        print("⚠️ Running in development mode (no protection)")
 
-# Динамически добавляем метод к классу
-InteriorDesignerPro._create_comparison_grid = _create_comparison_grid
+# Загружаем защиту
+load_protected_module()
 
 @spaces.GPU
 def init_designer():
     """Инициализация дизайнера"""
     global designer
     if designer is None:
-        # Проверка безопасности если определена
-        if 'critical_init' in globals():
-            critical_init()
         designer = InteriorDesignerPro()
     return designer
 
+@spaces.GPU
+def init_lama():
+    """Инициализация LAMA"""
+    global lama_remover
+    if lama_remover is None:
+        lama_remover = LamaObjectRemover()
+        lama_remover.init_model()
+    return lama_remover
+
 @spaces.GPU(duration=90)
 def process_image(image, style, room_type, strength, quality_mode,
                   enhance_lighting, add_details, custom_prompt, use_variations, negative_prompt=""):
@@ -377,6 +306,7 @@ def process_image(image, style, room_type, strength, quality_mode,
         
         # Применяем стиль с выбранным качеством
         if custom_prompt:
+            # Используем кастомный промпт
             quality_boost = "masterpiece, best quality, ultra-detailed, 8k uhd, " if quality_mode == "ultra" else ""
             styled_image = designer.pipe(
                 prompt=f"{quality_boost}{room_type_en}, {custom_prompt}, interior design, high quality",
@@ -387,21 +317,25 @@ def process_image(image, style, room_type, strength, quality_mode,
                 guidance_scale={"fast": 7.5, "balanced": 8.5, "ultra": 10}[quality_mode]
             ).images[0]
         else:
-            styled_image = designer.apply_style_pro(
-                image, style, room_type_en, strength, quality=quality_mode
-            )
+            # Используем предустановленный стиль с детальным промптом
+            detailed_prompt = get_detailed_prompt(style, room_type_en)
+            styled_image = designer.pipe(
+                prompt=detailed_prompt,
+                negative_prompt=DESIGN_STYLES[style].get("negative", ""),
+                image=image,
+                strength=strength,
+                num_inference_steps={"fast": 20, "balanced": 35, "ultra": 50}[quality_mode],
+                guidance_scale={"fast": 7.5, "balanced": 8.5, "ultra": 10}[quality_mode]
+            ).images[0]
         
         # HDR освещение
         if enhance_lighting and quality_mode != "fast":
             styled_image = designer.create_hdr_lighting(styled_image, intensity=0.3)
         
-        # Улучшение деталей
+        # Улучшение деталей (только для мощных GPU)
         if add_details and designer.is_powerful_gpu and quality_mode == "ultra":
             styled_image = designer.enhance_details(styled_image)
         
-        # Добавляем водяной знак
-        styled_image = add_watermark(styled_image)
-        
         # Создаем сравнение до/после
         comparison = processor.create_before_after(image, styled_image)
         
@@ -410,8 +344,6 @@ def process_image(image, style, room_type, strength, quality_mode,
         if use_variations:
             num_var = 8 if designer.is_powerful_gpu else 4
             var_images = designer.create_variations(image, num_variations=num_var)
-            # Добавляем водяные знаки на вариации
-            var_images = [add_watermark(img) for img in var_images]
             variations = processor.create_grid(
                 var_images, 
                 titles=[f"Вариант {i+1}" for i in range(len(var_images))]
@@ -429,14 +361,13 @@ def process_image(image, style, room_type, strength, quality_mode,
 ⚡ Режим качества: {quality_mode.upper()}
 🖼️ Разрешение: {styled_image.width}×{styled_image.height}
 🤖 Модель: {designer.model_name}
-🔒 Protected by: {AUTHOR_INFO.split('|')[0]}
 
 🎨 Основные цвета дизайна:
 """
         for i, color in enumerate(colors[:5]):
             hex_color = '#{:02x}{:02x}{:02x}'.format(*color)
-            info += f"\n  • {hex_color}"
-        
+            info += f"\n • {hex_color}"
+            
         return comparison, variations, palette, info
         
     except Exception as e:
@@ -449,73 +380,23 @@ def change_room_element(image, element, value, strength):
     """Изменение отдельного элемента"""
     if image is None:
         return None, "Загрузите изображение"
-    
+        
     global designer
     if designer is None:
         designer = InteriorDesignerPro()
-    
+        
     try:
         result = designer.change_element(image, element, value, strength)
-        result = add_watermark(result)
         return result, f"✅ {element} изменен на {value}"
     except Exception as e:
         return None, f"❌ Ошибка: {str(e)}"
 
-@spaces.GPU
-def remove_objects_lama(image, mask, inpaint_prompt=""):
-    """Удаление объектов с использованием LAMA"""
-    if image is None:
-        return None, "❌ Загрузите изображение"
-    
-    try:
-        # Если маска не загружена, возвращаем оригинал
-        if mask is None:
-            return image, "⚠️ Загрузите маску для удаления объектов"
-        
-        # Применяем LAMA
-        result = lama_remover.remove_objects(image, mask)
-        result = add_watermark(result)
-        
-        return result, "✅ Объекты успешно удалены"
-        
-    except Exception as e:
-        return None, f"❌ Ошибка: {str(e)}"
-
-@spaces.GPU
-def create_auto_mask(image, objects_text):
-    """Создание маски по текстовому описанию"""
-    if image is None:
-        return None, "❌ Загрузите изображение"
-    
-    try:
-        # Простая демо-маска (в реальности нужен GroundingDINO или SAM)
-        mask = Image.new('L', image.size, 0)
-        draw = ImageDraw.Draw(mask)
-        
-        # Создаем примерную маску в центре
-        width, height = image.size
-        margin = min(width, height) // 4
-        
-        if "центр" in objects_text.lower() or "middle" in objects_text.lower():
-            draw.ellipse([margin, margin, width-margin, height-margin], fill=255)
-        elif "лев" in objects_text.lower() or "left" in objects_text.lower():
-            draw.rectangle([0, 0, width//2, height], fill=255)
-        elif "прав" in objects_text.lower() or "right" in objects_text.lower():
-            draw.rectangle([width//2, 0, width, height], fill=255)
-        else:
-            # По умолчанию - центральная область
-            draw.ellipse([margin, margin, width-margin, height-margin], fill=255)
-        
-        return mask, "✅ Маска создана. Для точного выделения используйте ручное рисование."
-        
-    except Exception as e:
-        return None, f"❌ Ошибка: {str(e)}"
-
 def suggest_styles(image):
     """Предложение подходящих стилей"""
     if image is None:
         return "Загрузите изображение для получения рекомендаций"
-    
+        
+    # Анализируем текущий стиль
     room_type = processor.detect_room_type(image)
     
     suggestions = f"""
@@ -549,68 +430,21 @@ def suggest_styles(image):
 - Интенсивность 70-90% - кардинальное преображение
 - Режим Ultra - для финальной визуализации
 - HDR освещение - добавит реализма
-
-🔒 {AUTHOR_INFO}
 """
+    
     return suggestions
 
 @spaces.GPU(duration=60)
-def create_style_comparison(image, selected_styles, quality="balanced"):
-    """Создание сравнения стилей"""
-    if image is None:
-        return None, "❌ Загрузите изображение"
-    
-    if not selected_styles or len(selected_styles) < 2:
-        return None, "❌ Выберите минимум 2 стиля для сравнения"
-    
-    global designer
-    if designer is None:
-        designer = InteriorDesignerPro()
-    
-    try:
-        room_type = processor.detect_room_type(image)
-        room_type_en = ROOM_TYPES.get(room_type, "living room")
-        
-        # Генерируем изображения для каждого стиля
-        styled_images = []
-        for style in selected_styles[:6]:  # Максимум 6 стилей
-            styled = designer.apply_style_pro(
-                image, style, room_type_en, 
-                strength=0.75, 
-                quality="fast" if quality == "balanced" else quality
-            )
-            styled = add_watermark(styled)
-            styled_images.append(styled)
-        
-        # Создаем сетку сравнения
-        comparison_grid = designer._create_comparison_grid(
-            styled_images, 
-            selected_styles[:6], 
-            original=image
-        )
-        
-        info = f"""
-✅ Сравнение стилей готово!
-📐 Тип комнаты: {room_type}
-🎨 Стили: {', '.join(selected_styles[:6])}
-🖼️ Количество вариантов: {len(styled_images)}
-🔒 {AUTHOR_INFO}
-"""
-        
-        return comparison_grid, info
-        
-    except Exception as e:
-        return None, f"❌ Ошибка: {str(e)}"
-
-@spaces.GPU
 def enhance_image(image, scale, dpi):
     """Увеличение разрешения изображения"""
     if image is None:
         return None, None, "❌ Пожалуйста, загрузите изображение"
     
     try:
+        # Инициализируем enhancer
         enhancer = ImageEnhancer()
         
+        # Добавим отладку
         original_size = f"{image.width}×{image.height}"
         
         # Улучшаем изображение
@@ -618,6 +452,7 @@ def enhance_image(image, scale, dpi):
         
         # Проверяем, изменился ли размер
         if enhanced.size == image.size:
+            # Если размер не изменился, делаем upscale вручную через PIL
             new_width = image.width * scale
             new_height = image.height * scale
             enhanced = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
@@ -628,9 +463,6 @@ def enhance_image(image, scale, dpi):
         # Настраиваем DPI
         enhanced = enhancer.set_dpi(enhanced, dpi)
         
-        # Добавляем водяной знак
-        enhanced = add_watermark(enhanced)
-        
         # Создаем сравнение
         comparison = processor.create_before_after(image, enhanced)
         
@@ -643,17 +475,16 @@ def enhance_image(image, scale, dpi):
 🔍 Масштаб: {scale}x
 📊 DPI: {dpi}
 🔧 Метод: {method}
-🔒 {AUTHOR_INFO}
-"""
+        """
         
         return enhanced, comparison, info
         
     except Exception as e:
+        # Fallback на простой resize
         try:
             new_width = int(image.width * scale)
             new_height = int(image.height * scale)
             enhanced = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
-            enhanced = add_watermark(enhanced)
             
             info = f"""
 ⚠️ Real-ESRGAN недоступен, использован PIL resize
@@ -661,26 +492,132 @@ def enhance_image(image, scale, dpi):
 📐 Новый размер: {enhanced.width}×{enhanced.height}
 🔍 Масштаб: {scale}x
 Ошибка: {str(e)}
-"""
+            """
             return enhanced, None, info
         except Exception as e2:
             return None, None, f"❌ Ошибка увеличения: {str(e2)}"
 
+# Добавляем метод _create_comparison_grid к InteriorDesignerPro если его нет
+if hasattr(InteriorDesignerPro, 'create_style_comparison') and not hasattr(InteriorDesignerPro, '_create_comparison_grid'):
+    def _create_comparison_grid(self, images: List[Image.Image], styles: List[str], 
+                                cols: int = 3) -> Image.Image:
+        """Создание сетки для сравнения стилей"""
+        if not images:
+            return None
+            
+        # Размеры
+        img_width = 512
+        img_height = 512
+        padding = 20
+        text_height = 40
+        
+        # Изменяем размер всех изображений
+        resized_images = []
+        for img in images:
+            resized = img.resize((img_width, img_height), Image.Resampling.LANCZOS)
+            resized_images.append(resized)
+        
+        # Вычисляем размер итогового изображения
+        rows = (len(images) + cols - 1) // cols
+        total_width = cols * img_width + (cols + 1) * padding
+        total_height = rows * (img_height + text_height) + (rows + 1) * padding
+        
+        # Создаем пустое изображение
+        grid = Image.new('RGB', (total_width, total_height), color='white')
+        draw = ImageDraw.Draw(grid)
+        
+        # Размещаем изображения
+        for idx, (img, style) in enumerate(zip(resized_images, styles)):
+            row = idx // cols
+            col = idx % cols
+            
+            x = col * (img_width + padding) + padding
+            y = row * (img_height + text_height + padding) + padding
+            
+            # Вставляем изображение
+            grid.paste(img, (x, y))
+            
+            # Добавляем подпись
+            text_y = y + img_height + 5
+            draw.text((x + img_width//2, text_y), style, 
+                     fill='black', anchor='mt')
+        
+        return grid
+    
+    InteriorDesignerPro._create_comparison_grid = _create_comparison_grid
+
+@spaces.GPU(duration=120)
+def create_style_comparison(image, selected_styles, room_type, strength, fast_mode):
+    """Создание сравнения нескольких стилей"""
+    if image is None:
+        return None, "❌ Пожалуйста, загрузите изображение"
+        
+    if not selected_styles:
+        return None, "❌ Выберите хотя бы 2 стиля для сравнения"
+        
+    global designer
+    if designer is None:
+        designer = InteriorDesignerPro()
+        
+    try:
+        # Определяем тип комнаты
+        if room_type == "Автоопределение":
+            room_type = processor.detect_room_type(image)
+            room_type_en = ROOM_TYPES.get(room_type, "living room")
+        else:
+            room_type_en = ROOM_TYPES.get(room_type, "living room")
+        
+        # Настройки качества для режима сравнения
+        steps = 20 if fast_mode else 30
+        
+        # Генерируем изображения для каждого стиля
+        styled_images = []
+        for style in selected_styles:
+            detailed_prompt = get_detailed_prompt(style, room_type_en)
+            
+            styled = designer.pipe(
+                prompt=detailed_prompt,
+                negative_prompt=DESIGN_STYLES[style].get("negative", ""),
+                image=image,
+                strength=strength,
+                num_inference_steps=steps,
+                guidance_scale=7.5
+            ).images[0]
+            
+            styled_images.append(styled)
+        
+        # Создаем сетку сравнения
+        comparison = designer._create_comparison_grid(
+            styled_images,
+            selected_styles,
+            cols=3 if len(selected_styles) > 4 else 2
+        )
+        
+        info = f"""
+✅ Сравнение стилей завершено!
+📊 Сравнено стилей: {len(selected_styles)}
+🏠 Тип комнаты: {room_type}
+⚡ Режим: {'Быстрый' if fast_mode else 'Качественный'}
+        """
+        
+        return comparison, info
+        
+    except Exception as e:
+        return None, f"❌ Ошибка: {str(e)}"
+
 # Создаем интерфейс
 with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.themes.Soft(), css=custom_css) as app:
-    # Добавляем информацию об авторе вверху
-    gr.HTML(f"""
-    <div class="author-badge">
-        <h3>{AUTHOR_INFO}</h3>
-        <p>Protected AI Interior Designer Pro | Space ID: {SPACE_ID}</p>
-    </div>
-    """)
-    
     gr.Markdown("""
     # 🎨 AI Дизайнер интерьера Pro
     ### Преобразите свое пространство с помощью искусственного интеллекта
     """)
     
+    # Инициализация моделей при запуске
+    with gr.Row(visible=False):
+        init_btn = gr.Button("Init")
+        init_btn.click(fn=init_designer, inputs=[], outputs=[])
+        init_btn.click(fn=init_lama, inputs=[], outputs=[])
+    
     with gr.Tabs():
         # Основная вкладка
         with gr.TabItem("🎨 Дизайнер", id=0):
@@ -747,7 +684,6 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
                             lines=3,
                             info="Опишите желаемый результат своими словами"
                         )
-                        
                         negative_prompt = gr.Textbox(
                             label="Чего избегать",
                             placeholder="dark, cluttered, old furniture",
@@ -783,7 +719,6 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
                             label="Варианты дизайна",
                             visible=False
                         )
-                        
                         output_palette = gr.Image(
                             label="Цветовая палитра",
                             height=100
@@ -793,51 +728,83 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
                         label="Информация о процессе"
                     )
         
-        # Вкладка удаления объектов с LAMA
-        with gr.TabItem("🗑️ Удаление объектов (LAMA)", id=1):
+        # Вкладка сравнения стилей
+        with gr.TabItem("🎭 Сравнение стилей", id=1):
             with gr.Row():
                 with gr.Column():
-                    lama_image = gr.Image(
-                        label="Загрузите фото",
+                    compare_image = gr.Image(
+                        label="Загрузите фото для сравнения",
                         type="pil",
                         height=400
                     )
                     
-                    gr.Markdown("""
-                    ### 📝 Как удалить объекты:
+                    compare_styles = gr.CheckboxGroup(
+                        label="Выберите 2-6 стилей для сравнения",
+                        choices=list(DESIGN_STYLES.keys()),
+                        value=["Современный минимализм", "Скандинавский"]
+                    )
                     
-                    **Вариант 1: Создайте маску вручную**
-                    1. Сохраните изображение выше
-                    2. Откройте в любом редакторе (Paint, Photoshop, GIMP)
-                    3. Закрасьте объекты БЕЛЫМ цветом
-                    4. Загрузите маску ниже
+                    compare_room_type = gr.Dropdown(
+                        label="Тип комнаты",
+                        choices=["Автоопределение"] + list(ROOM_TYPES.keys()),
+                        value="Автоопределение"
+                    )
                     
-                    **Вариант 2: Автоматическая маска**
-                    - Опишите объекты текстом ниже
-                    """)
+                    compare_strength = gr.Slider(
+                        label="Интенсивность",
+                        minimum=0.3,
+                        maximum=0.95,
+                        value=0.7,
+                        step=0.05
+                    )
                     
-                    lama_mask = gr.Image(
-                        label="Загрузите маску (белый = удалить, черный = оставить)",
+                    compare_fast = gr.Checkbox(
+                        label="⚡ Быстрый режим",
+                        value=True,
+                        info="Быстрее, но немного ниже качество"
+                    )
+                    
+                    compare_btn = gr.Button(
+                        "🎭 Сравнить стили",
+                        variant="primary"
+                    )
+                
+                with gr.Column():
+                    compare_output = gr.Image(
+                        label="Сравнение стилей",
+                        height=600
+                    )
+                    compare_info = gr.Markdown()
+        
+        # Вкладка удаления объектов с РИСОВАНИЕМ
+        with gr.TabItem("🗑️ Удаление объектов (LAMA)", id=2):
+            with gr.Row():
+                with gr.Column():
+                    # Используем gr.ImageEditor для рисования маски
+                    lama_input = gr.Image(
+                        label="Закрасьте объекты для удаления красным цветом",
+                        source="upload",
+                        tool="color-sketch",  # Позволяет рисовать
                         type="pil",
-                        height=400
+                        height=500,
+                        brush_color="#FF0000",  # Красная кисть
+                        elem_id="lama_canvas"
                     )
                     
-                    with gr.Row():
-                        auto_mask_text = gr.Textbox(
-                            label="Или опишите объекты для удаления",
-                            placeholder="мебель в центре, диван, стол",
-                            lines=2
-                        )
-                        
-                        create_mask_btn = gr.Button("Создать маску автоматически")
+                    gr.Markdown("""
+                    ### 🖌️ Инструкция:
+                    1. Загрузите фото
+                    2. Выберите инструмент рисования (кисть)
+                    3. Закрасьте объекты КРАСНЫМ цветом
+                    4. Нажмите "Удалить объекты"
                     
-                    lama_inpaint_prompt = gr.Textbox(
-                        label="Чем заполнить пустоты (опционально)",
-                        placeholder="empty floor, clean wall",
-                        lines=2
-                    )
+                    💡 Советы:
+                    - Закрашивайте объекты полностью
+                    - Используйте увеличение для точности
+                    - Можно стереть лишнее ластиком
+                    """)
                     
-                    remove_btn = gr.Button(
+                    lama_btn = gr.Button(
                         "🗑️ Удалить объекты",
                         variant="primary",
                         size="lg"
@@ -846,25 +813,15 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
                 with gr.Column():
                     lama_output = gr.Image(
                         label="Результат",
-                        height=400
+                        height=500
                     )
-                    
                     lama_info = gr.Textbox(
                         label="Статус",
-                        lines=3
+                        lines=2
                     )
-                    
-                    # Примеры масок
-                    gr.Markdown("""
-                    ### 💡 Советы:
-                    - Чем точнее маска, тем лучше результат
-                    - Для мебели делайте маску чуть больше объекта
-                    - LAMA сохраняет стиль комнаты, только убирает объекты
-                    """)
         
-        # Остальные вкладки...
         # Вкладка детальных изменений
-        with gr.TabItem("🔧 Детальные изменения", id=2):
+        with gr.TabItem("🔧 Детальные изменения", id=3):
             with gr.Row():
                 with gr.Column():
                     detail_image = gr.Image(
@@ -899,51 +856,12 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
                     detail_output = gr.Image(label="Результат", height=300)
                     detail_info = gr.Textbox(label="Статус", lines=2)
         
-        # Вкладка сравнения стилей
-        with gr.TabItem("🎭 Сравнение стилей", id=3):
-            with gr.Row():
-                with gr.Column():
-                    compare_image = gr.Image(
-                        label="Загрузите фото для сравнения стилей",
-                        type="pil",
-                        height=400
-                    )
-                    
-                    compare_styles = gr.CheckboxGroup(
-                        label="Выберите стили для сравнения (от 2 до 6)",
-                        choices=list(DESIGN_STYLES.keys()),
-                        value=[]
-                    )
-                    
-                    compare_quality = gr.Radio(
-                        label="Качество сравнения",
-                        choices=[
-                            ("Быстрое", "fast"),
-                            ("Сбалансированное", "balanced")
-                        ],
-                        value="fast"
-                    )
-                    
-                    compare_btn = gr.Button(
-                        "🎭 Сравнить стили",
-                        variant="primary",
-                        size="lg"
-                    )
-                
-                with gr.Column():
-                    compare_output = gr.Image(
-                        label="Сравнение стилей",
-                        height=600
-                    )
-                    
-                    compare_info = gr.Markdown()
-        
         # Вкладка увеличения разрешения
         with gr.TabItem("🔍 Увеличение разрешения", id=4):
             with gr.Row():
                 with gr.Column():
                     upscale_image = gr.Image(
-                        label="Загрузите изображение для увеличения",
+                        label="Изображение для увеличения",
                         type="pil",
                         height=400
                     )
@@ -957,17 +875,16 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
                     upscale_dpi = gr.Radio(
                         label="DPI для печати",
                         choices=[
-                            ("Экран (96 DPI)", 96),
-                            ("Документ (150 DPI)", 150),
-                            ("Печать (300 DPI)", 300)
+                            ("96 DPI (экран)", 96),
+                            ("150 DPI (обычная печать)", 150),
+                            ("300 DPI (высокое качество)", 300)
                         ],
                         value=150
                     )
                     
                     upscale_btn = gr.Button(
                         "🔍 Увеличить разрешение",
-                        variant="primary",
-                        size="lg"
+                        variant="primary"
                     )
                 
                 with gr.Column():
@@ -975,12 +892,10 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
                         label="Увеличенное изображение",
                         height=400
                     )
-                    
                     upscale_comparison = gr.Image(
                         label="Сравнение",
                         height=200
                     )
-                    
                     upscale_info = gr.Markdown()
         
         # Вкладка рекомендаций
@@ -992,7 +907,6 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
                         type="pil",
                         height=400
                     )
-                    
                     suggest_btn = gr.Button("Получить рекомендации", variant="primary")
                 
                 with gr.Column():
@@ -1000,13 +914,9 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
                     
                     # Цветовые палитры для стилей
                     gr.Markdown("### 🎨 Цветовые палитры популярных стилей")
-                    
                     for style_name in list(DESIGN_STYLES.keys())[:4]:
-                        colors = ColorPalette.suggest_palette(style_name)
-                        color_blocks = " ".join([
-                            f'<span style="background-color:{c}; padding:10px 20px; margin:2px; display:inline-block; border-radius:5px;"></span>' 
-                            for c in colors
-                        ])
+                        colors = DESIGN_STYLES[style_name].get("colors", ["#FFFFFF"] * 6)
+                        color_blocks = " ".join([f'<span style="background-color:{c}; padding:10px 20px; margin:2px; display:inline-block; border-radius:5px;"></span>' for c in colors])
                         gr.HTML(f"<div class='info-box'><strong>{style_name}:</strong><br>{color_blocks}</div>")
     
     # Обработчики событий
@@ -1023,16 +933,16 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
         outputs=[output_variations]
     )
     
-    # LAMA handlers
-    create_mask_btn.click(
-        create_auto_mask,
-        inputs=[lama_image, auto_mask_text],
-        outputs=[lama_mask, lama_info]
+    compare_btn.click(
+        create_style_comparison,
+        inputs=[compare_image, compare_styles, compare_room_type, compare_strength, compare_fast],
+        outputs=[compare_output, compare_info]
     )
     
-    remove_btn.click(
-        remove_objects_lama,
-        inputs=[lama_image, lama_mask, lama_inpaint_prompt],
+    # Обработчик для LAMA
+    lama_btn.click(
+        lambda img: lama_remover.remove_objects(img) if lama_remover else (None, "❌ LAMA не инициализирован"),
+        inputs=[lama_input],
         outputs=[lama_output, lama_info]
     )
     
@@ -1042,12 +952,6 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
         outputs=[detail_output, detail_info]
     )
     
-    compare_btn.click(
-        create_style_comparison,
-        inputs=[compare_image, compare_styles, compare_quality],
-        outputs=[compare_output, compare_info]
-    )
-    
     upscale_btn.click(
         enhance_image,
         inputs=[upscale_image, upscale_factor, upscale_dpi],
@@ -1060,31 +964,41 @@ with gr.Blocks(title="AI Дизайнер интерьера Pro", theme=gr.them
         outputs=[suggestions]
     )
     
+    # Информация о защите
+    author_info = os.environ.get("AUTHOR_INFO", "Development Mode")
+    if "Development" not in author_info:
+        with gr.Row():
+            gr.Markdown(f"""
+            ---
+            <center>
+            <div style='background: linear-gradient(45deg, #667eea 0%, #764ba2 100%); 
+                        padding: 20px; border-radius: 10px; color: white;'>
+            <h3>🔒 {author_info}</h3>
+            <p>Protected AI Interior Designer Pro</p>
+            </div>
+            </center>
+            """)
+    
     # Информация внизу
-    gr.Markdown(f"""
+    gr.Markdown("""
     ---
     ### 📝 Инструкция по использованию:
-    1. Загрузите фото вашей комнаты
-    2. Выберите стиль из 8 доступных вариантов
-    3. Настройте параметры по вкусу
-    4. Нажмите "Преобразить интерьер"
+    
+    1. **Основной дизайнер** - загрузите фото и выберите стиль
+    2. **Сравнение стилей** - посмотрите как выглядят разные стили на одном фото
+    3. **Удаление объектов** - закрасьте ненужные предметы красным цветом
+    4. **Детальные изменения** - измените отдельные элементы интерьера
+    5. **Увеличение разрешения** - улучшите качество для печати
     
     ### 🚀 Возможности:
-    - 8 стилей дизайна - от минимализма до ар-деко
-    - Автоопределение типа комнаты
-    - Создание вариаций - до 8 вариантов за раз
-    - Удаление объектов с LAMA
-    - Детальные изменения - меняйте отдельные элементы
-    - HDR освещение - профессиональная обработка света
-    - Анализ цветовой палитры
+    - 20+ стилей дизайна с детальными настройками
+    - Удаление объектов с помощью LAMA
+    - Создание вариаций дизайна
+    - HDR освещение и улучшение деталей
+    - Увеличение разрешения до 4x
     
     ---
-    <center>
-        <div class="author-badge">
-            <p>{AUTHOR_INFO}</p>
-            <p>Made with ❤️ for interior design enthusiasts</p>
-        </div>
-    </center>
+    <center>Made with ❤️ for interior design enthusiasts</center>
     """)
 
 # ВАЖНО! Запуск приложения