Update app.py

app.py

@@ -1,723 +1,165 @@
-# app.py - 完整的单文件时尚AI应用
-# 无需复杂的模块导入，直接在 Hugging Face Spaces 运行
-
+# app.py (Gradio界面)
 import gradio as gr
-import torch
-import numpy as np
-from PIL import Image, ImageDraw, ImageFont
-import logging
-import time
-import random
-import os
-from datetime import datetime
-from typing import Dict, List, Optional
-
-# 设置日志
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+from main import app
+import requests
+from PIL import Image
+import json
 
-# 尝试导入AI模型库
-try:
-    from transformers import (
-        BlipProcessor, BlipForConditionalGeneration,
-        CLIPProcessor, CLIPModel,
-        pipeline
-    )
-    from diffusers import (
-        StableDiffusionPipeline, 
-        ControlNetModel, 
-        StableDiffusionControlNetPipeline
-    )
-    from sklearn.cluster import KMeans
-    import cv2
-    MODELS_AVAILABLE = True
-    logger.info("✅ 所有AI库导入成功")
-except ImportError as e:
-    logger.warning(f"⚠️ 部分AI库未安装: {e}")
-    MODELS_AVAILABLE = False
+# 导入模型管理器
+from models.model_manager import ModelManager
 
-# 尝试导入 Hugging Face Spaces GPU 支持
-try:
-    import spaces
-    SPACES_GPU_AVAILABLE = True
-    logger.info("✅ Hugging Face Spaces GPU 支持可用")
-except ImportError:
-    SPACES_GPU_AVAILABLE = False
-    logger.info("ℹ️ 运行在非Spaces环境或无GPU支持")
+# 初始化模型管理器
+model_manager = ModelManager()
 
-class FashionAnalyzer:
-    """时尚分析引擎"""
-    
-    def __init__(self):
-        self.style_keywords = {
-            "商务正装": ["suit", "formal", "business", "office", "professional", "blazer", "西装", "正装"],
-            "休闲风格": ["casual", "relaxed", "comfortable", "jeans", "t-shirt", "休闲", "日常"],
-            "运动风格": ["sport", "athletic", "gym", "fitness", "training", "运动", "健身"],
-            "时尚潮流": ["fashion", "trendy", "stylish", "modern", "chic", "时尚", "潮流"],
-            "复古风格": ["vintage", "retro", "classic", "traditional", "复古", "经典"],
-            "街头风格": ["street", "urban", "hip-hop", "edgy", "街头", "嘻哈"],
-            "优雅风格": ["elegant", "sophisticated", "graceful", "classy", "优雅", "高贵"],
-            "极简风格": ["minimalist", "clean", "simple", "basic", "极简", "简约"]
+def upload_and_analyze(image_path):
+    """分析上传的图片"""
+    try:
+        if image_path is None:
+            return {}, {}, []
+        
+        # 打开图片
+        image = Image.open(image_path)
+        
+        # 生成图像描述
+        caption = model_manager.generate_caption(image)
+        
+        # 模拟风格分析结果
+        analysis_result = {
+            "图像描述": caption,
+            "检测到的颜色": ["蓝色", "白色", "黑色"],
+            "风格类型": "休闲风",
+            "服装类别": "上衣",
+            "适合场景": ["日常", "休闲", "约会"]
         }
         
-        self.color_names = {
-            "红色系": ["红色", "玫瑰红", "深红", "暗红", "鲜红"],
-            "蓝色系": ["蓝色", "天蓝", "海军蓝", "宝石蓝", "钴蓝"],
-            "绿色系": ["绿色", "翠绿", "森林绿", "橄榄绿", "苹果绿"],
-            "黑白灰": ["黑色", "白色", "灰色", "象牙白", "珍珠白", "炭黑"],
-            "暖色调": ["橙色", "黄色", "粉色", "金黄", "柠檬黄"],
-            "冷色调": ["紫色", "青色", "薄荷绿", "紫罗兰", "青绿"]
+        # 生成设计建议
+        suggestions = {
+            "建议1": "现代简约风格搭配",
+            "建议2": "复古经典款式",
+            "建议3": "运动休闲风格",
+            "建议4": "商务正装风格"
         }
-    
-    def extract_colors(self, image: Image.Image, n_colors: int = 5) -> List[Dict]:
-        """提取图像主要颜色"""
-        try:
-            # 调整图像大小以提高处理速度
-            image_small = image.resize((100, 100))
-            img_array = np.array(image_small)
-            pixels = img_array.reshape(-1, 3)
-            
-            # 过滤极端值
-            mask = np.all(pixels > 20, axis=1) & np.all(pixels < 235, axis=1)
-            filtered_pixels = pixels[mask]
-            
-            if len(filtered_pixels) < 50:
-                filtered_pixels = pixels
-            
-            # 使用 K-means 聚类
-            if MODELS_AVAILABLE:
-                kmeans = KMeans(n_clusters=min(n_colors, len(filtered_pixels)), 
-                              random_state=42, n_init=10)
-                kmeans.fit(filtered_pixels)
-                colors = kmeans.cluster_centers_
-                labels = kmeans.labels_
-            else:
-                # 简化版本：直接采样
-                colors = []
-                step = max(1, len(filtered_pixels) // n_colors)
-                for i in range(0, len(filtered_pixels), step):
-                    if len(colors) < n_colors:
-                        colors.append(filtered_pixels[i])
-                colors = np.array(colors)
-                labels = np.zeros(len(colors))
-            
-            color_info = []
-            for i, color in enumerate(colors):
-                rgb = color.astype(int)
-                color_name = self.rgb_to_color_name(rgb)
-                hex_color = '#{:02x}{:02x}{:02x}'.format(*rgb)
-                
-                if MODELS_AVAILABLE:
-                    percentage = np.sum(labels == i) / len(labels) * 100
-                else:
-                    percentage = 100.0 / len(colors)
-                
-                color_info.append({
-                    "name": color_name,
-                    "rgb": rgb.tolist(),
-                    "hex": hex_color,
-                    "percentage": round(percentage, 1)
-                })
-            
-            return sorted(color_info, key=lambda x: x["percentage"], reverse=True)
-            
-        except Exception as e:
-            logger.error(f"颜色提取失败: {e}")
-            return [{"name": "未知颜色", "rgb": [128, 128, 128], "hex": "#808080", "percentage": 100.0}]
-    
-    def rgb_to_color_name(self, rgb: np.ndarray) -> str:
-        """RGB转颜色名称"""
-        r, g, b = rgb
-        
-        if r > 200 and g > 200 and b > 200:
-            return "象牙白" if min(r, g, b) > 240 else "珍珠白"
-        elif r < 50 and g < 50 and b < 50:
-            return "墨黑" if max(r, g, b) < 30 else "炭黑"
-        elif r > max(g, b) + 30:
-            return "玫瑰红" if r > 180 else "深红"
-        elif g > max(r, b) + 30:
-            return "翠绿" if g > 180 else "森林绿"
-        elif b > max(r, g) + 30:
-            return "天蓝" if b > 180 else "海军蓝"
-        elif r > 150 and g > 150 and b < 100:
-            return "金黄" if r > 200 else "暖黄"
-        elif r > 120 and g < 100 and b > 120:
-            return "紫罗兰" if r > 150 else "深紫"
-        else:
-            return "混合色"
-    
-    def analyze_style(self, description: str) -> Dict[str, float]:
-        """分析时尚风格"""
-        description_lower = description.lower()
-        style_scores = {}
-        
-        for style, keywords in self.style_keywords.items():
-            score = sum(1 for keyword in keywords if keyword in description_lower)
-            if score > 0:
-                confidence = min(score / len(keywords) * 100, 100)
-                style_scores[style] = round(confidence, 1)
-        
-        # 如果没有匹配到任何风格，给一个默认分析
-        if not style_scores:
-            style_scores = {"休闲风格": 60.0, "时尚潮流": 40.0}
-        
-        return dict(sorted(style_scores.items(), key=lambda x: x[1], reverse=True))
-
-class ModelManager:
-    """AI模型管理器"""
-    
-    def __init__(self):
-        self.models_loaded = False
-        self.blip_processor = None
-        self.blip_model = None
-        self.clip_processor = None
-        self.clip_model = None
-        self.sd_pipeline = None
-        self.controlnet_pipeline = None
-        
-        if MODELS_AVAILABLE:
-            self.load_models()
-    
-    def load_models(self):
-        """加载AI模型"""
-        try:
-            logger.info("🔄 开始加载AI模型...")
-            
-            # 1. 尝试加载 BLIP 图像理解模型
-            try:
-                logger.info("加载 BLIP 图像理解模型...")
-                self.blip_processor = BlipProcessor.from_pretrained(
-                    "Salesforce/blip-image-captioning-base"
-                )
-                self.blip_model = BlipForConditionalGeneration.from_pretrained(
-                    "Salesforce/blip-image-captioning-base",
-                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
-                )
-                
-                if torch.cuda.is_available():
-                    self.blip_model = self.blip_model.to("cuda")
-                
-                logger.info("✅ BLIP模型加载成功")
-            except Exception as e:
-                logger.warning(f"BLIP模型加载失败: {e}")
-                # 尝试轻量级替代
-                try:
-                    self.blip_model = pipeline("image-to-text", 
-                                             model="nlpconnect/vit-gpt2-image-captioning")
-                    logger.info("✅ 轻量级图像理解模型加载成功")
-                except Exception as e2:
-                    logger.error(f"所有图像理解模型加载失败: {e2}")
-            
-            # 2. 尝试加载 Stable Diffusion
-            try:
-                logger.info("加载 Stable Diffusion 设计生成模型...")
-                self.sd_pipeline = StableDiffusionPipeline.from_pretrained(
-                    "runwayml/stable-diffusion-v1-5",
-                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                    safety_checker=None,
-                    requires_safety_checker=False
-                )
-                
-                if torch.cuda.is_available():
-                    self.sd_pipeline = self.sd_pipeline.to("cuda")
-                
-                self.sd_pipeline.enable_attention_slicing()
-                logger.info("✅ Stable Diffusion模型加载成功")
-            except Exception as e:
-                logger.warning(f"Stable Diffusion加载失败: {e}")
-            
-            self.models_loaded = True
-            logger.info("🎉 模型加载完成")
-            
-        except Exception as e:
-            logger.error(f"模型加载过程出错: {e}")
-            self.models_loaded = False
-    
-    def generate_description(self, image: Image.Image) -> str:
-        """生成图像描述"""
-        if not self.models_loaded:
-            return "AI模型未就绪，使用基础分析"
         
-        try:
-            # 使用 BLIP 模型
-            if self.blip_processor and self.blip_model and hasattr(self.blip_model, 'generate'):
-                inputs = self.blip_processor(image, return_tensors="pt")
-                if torch.cuda.is_available() and next(self.blip_model.parameters()).is_cuda:
-                    inputs = {k: v.to("cuda") for k, v in inputs.items()}
-                
-                with torch.no_grad():
-                    generated_ids = self.blip_model.generate(
-                        **inputs, 
-                        max_length=50, 
-                        num_beams=3,
-                        do_sample=True,
-                        temperature=0.7
-                    )
-                
-                description = self.blip_processor.decode(generated_ids[0], skip_special_tokens=True)
-                return description
-            
-            # 使用 pipeline 模型
-            elif hasattr(self.blip_model, '__call__'):
-                result = self.blip_model(image)
-                if isinstance(result, list) and len(result) > 0:
-                    return result[0].get('generated_text', '时尚服装图像')
-            
-            return "时尚服装分析 - 基础模式"
-            
-        except Exception as e:
-            logger.error(f"描述生成失败: {e}")
-            return f"图像分析完成 - {str(e)[:50]}"
-    
-    def generate_fashion_design(self, prompt: str) -> Optional[Image.Image]:
-        """生成时尚设计"""
-        if not self.sd_pipeline:
-            return self.create_placeholder_image("设计生成功能不可用")
+        # 创建选择选项
+        choices = list(suggestions.keys())
         
-        try:
-            enhanced_prompt = f"high quality fashion design, {prompt}, professional photography, detailed, 4k"
-            negative_prompt = "blurry, low quality, distorted, text, watermark, deformed, ugly"
-            
-            with torch.autocast("cuda" if torch.cuda.is_available() else "cpu"):
-                result = self.sd_pipeline(
-                    prompt=enhanced_prompt,
-                    negative_prompt=negative_prompt,
-                    num_inference_steps=20,
-                    guidance_scale=7.5,
-                    width=512,
-                    height=512
-                )
-            
-            return result.images[0]
-            
-        except Exception as e:
-            logger.error(f"设计生成失败: {e}")
-            return self.create_placeholder_image(f"生成失败: {str(e)[:30]}")
-    
-    def create_placeholder_image(self, text: str) -> Image.Image:
-        """创建占位图"""
-        img = Image.new('RGB', (512, 512), color=(245, 245, 250))
-        draw = ImageDraw.Draw(img)
+        return analysis_result, suggestions, gr.Radio(choices=choices, value=choices[0] if choices else None)
         
-        # 计算文本位置
-        text_lines = text.split('\n')
-        y_start = (512 - len(text_lines) * 30) // 2
-        
-        for i, line in enumerate(text_lines):
-            text_width = len(line) * 8
-            x = (512 - text_width) // 2
-            y = y_start + i * 35
-            draw.text((x, y), line, fill=(100, 100, 100))
-        
-        return img
-    
-    def cleanup_memory(self):
-        """清理内存"""
-        try:
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-            
-            import gc
-            gc.collect()
-            
-            return "✅ 内存清理完成"
-        except Exception as e:
-            return f"❌ 内存清理失败: {e}"
-
-# 全局实例
-fashion_analyzer = FashionAnalyzer()
-model_manager = ModelManager()
+    except Exception as e:
+        error_result = {"错误": f"分析失败: {str(e)}"}
+        return error_result, {}, []
 
-# 主要功能函数
-def analyze_fashion_image(image: Image.Image) -> Dict:
-    """分析时尚图像"""
-    if image is None:
-        return {"error": "请上传图像"}
-    
+def generate_designs(selected_suggestion):
+    """根据选择的建议生成设计"""
     try:
-        logger.info("开始时尚图像分析...")
-        start_time = time.time()
-        
-        # 1. 生成图像描述
-        description = model_manager.generate_description(image)
-        
-        # 2. 色彩分析
-        colors = fashion_analyzer.extract_colors(image, n_colors=5)
-        
-        # 3. 风格分析
-        styles = fashion_analyzer.analyze_style(description)
-        primary_style = list(styles.keys())[0] if styles else "现代时尚"
-        
-        # 4. 综合分析
-        analysis_time = round(time.time() - start_time, 2)
-        
-        result = {
-            "image_description": description,
-            "color_analysis": colors,
-            "style_analysis": styles,
-            "primary_style": primary_style,
-            "main_colors": [c["name"] for c in colors[:3]],
-            "analysis_time": f"{analysis_time}秒",
-            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "ai_model_status": "✅ 已连接" if model_manager.models_loaded else "⚠️ 基础模式"
+        if not selected_suggestion:
+            return [], gr.Radio(choices=[])
+        
+        # 生成设计图像的提示词
+        design_prompts = {
+            "建议1": "modern minimalist clothing design, clean lines, neutral colors",
+            "建议2": "vintage classic fashion design, retro style, elegant",
+            "建议3": "sporty casual wear design, comfortable, athletic",
+            "建议4": "business formal attire, professional, sophisticated"
         }
         
-        logger.info(f"分析完成，耗时 {analysis_time}秒")
-        return result
-        
-    except Exception as e:
-        logger.error(f"分析失败: {e}")
-        return {"error": f"分析过程出错: {str(e)}"}
-
-def generate_design_suggestions(analysis_result: Dict) -> Dict[str, str]:
-    """生成设计建议"""
-    if "error" in analysis_result:
-        return {"基础建议": "请先完成图像分析"}
-    
-    primary_style = analysis_result.get("primary_style", "现代时尚")
-    main_colors = analysis_result.get("main_colors", ["经典色"])
-    
-    suggestions = {
-        f"优化{primary_style}": f"保持{primary_style}特色，突出{main_colors[0]}主色调",
-        f"色彩增强版": f"基于{primary_style}风格，强化{main_colors[0]}和{main_colors[1] if len(main_colors) > 1 else '经典色'}搭配",
-        f"现代融合": f"将{primary_style}与当代设计元素结合",
-        f"个性定制": f"专属{primary_style}风格的个性化设计",
-        f"场景适配": f"适合多种场合的{primary_style}变化"
-    }
-    
-    return suggestions
-
-def generate_designs(suggestion: str, analysis_result: Dict, progress=gr.Progress()) -> List[Image.Image]:
-    """生成设计方案"""
-    if not suggestion or "error" in analysis_result:
-        return [model_manager.create_placeholder_image("请先选择设计建议")]
-    
-    try:
-        primary_style = analysis_result.get("primary_style", "现代时尚")
-        main_colors = analysis_result.get("main_colors", ["经典色"])
+        prompt = design_prompts.get(selected_suggestion, "fashion design, stylish clothing")
         
-        designs = []
-        design_prompts = [
-            f"{primary_style} style fashion, {main_colors[0]} color, elegant design",
-            f"modern {primary_style} clothing, {main_colors[0]} and {main_colors[1] if len(main_colors) > 1 else 'neutral'} colors",
-            f"professional {primary_style} outfit, premium materials, {main_colors[0]} accent",
-            f"contemporary {primary_style} fashion, artistic design, {main_colors[0]} theme"
-        ]
+        # 生成设计图像
+        design_images = []
+        design_choices = []
         
-        for i, prompt in enumerate(design_prompts):
-            if progress:
-                progress(i / len(design_prompts), f"生成设计方案 {i+1}/{len(design_prompts)}")
-            
-            design_image = model_manager.generate_fashion_design(prompt)
-            designs.append(design_image)
+        for i in range(3):  # 生成3个设计
+            try:
+                image = model_manager.generate_image(
+                    prompt=f"{prompt}, design {i+1}",
+                    negative_prompt="blurry, low quality, distorted",
+                    num_inference_steps=20
+                )
+                if image:
+                    design_images.append(image)
+                    design_choices.append(f"设计方案 {i+1}")
+            except Exception as e:
+                print(f"生成设计 {i+1} 失败: {e}")
         
-        if progress:
-            progress(1.0, "设计生成完成")
+        # 如果没有成功生成图像，返回空结果
+        if not design_images:
+            return [], gr.Radio(choices=[])
         
-        return designs
+        return design_images, gr.Radio(choices=design_choices, value=design_choices[0] if design_choices else None)
         
     except Exception as e:
-        logger.error(f"设计生成失败: {e}")
-        return [model_manager.create_placeholder_image(f"生成失败: {str(e)[:30]}")]
+        print(f"设计生成错误: {e}")
+        return [], gr.Radio(choices=[])
 
-def create_3d_fitting(selected_design: str) -> Image.Image:
-    """创建3D试穿效果"""
-    if not selected_design:
-        return model_manager.create_placeholder_image("请先选择设计方案")
-    
+def generate_3d_fitting(selected_design):
+    """生成3D试穿效果"""
     try:
-        # 创建3D试穿提示
-        fitting_prompt = f"3D virtual fashion model wearing {selected_design}, full body view, professional studio lighting, photorealistic"
+        if not selected_design:
+            return None
         
-        # 生成3D试穿图像
-        fitting_image = model_manager.generate_fashion_design(fitting_prompt)
+        # 生成3D试穿效果的提示词
+        fitting_prompt = f"3D fashion fitting, virtual try-on, {selected_design}, realistic human model"
         
-        return fitting_image if fitting_image else model_manager.create_placeholder_image("3D试穿生成完成")
+        # 使用模型生成3D试穿图像
+        fitting_image = model_manager.generate_image(
+            prompt=fitting_prompt,
+            negative_prompt="blurry, distorted, low quality, unrealistic",
+            num_inference_steps=25
+        )
+        
+        return fitting_image
         
     except Exception as e:
-        logger.error(f"3D试穿生成失败: {e}")
-        return model_manager.create_placeholder_image("3D试穿生成失败")
+        print(f"3D试穿生成错误: {e}")
+        return None
 
-# Gradio 界面
-def create_fashion_interface():
-    """创建时尚AI界面"""
-    
-    custom_css = """
-    .gradio-container {
-        max-width: 1200px;
-        margin: 0 auto;
-        font-family: 'Inter', sans-serif;
-    }
-    .header {
-        text-align: center;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        padding: 20px;
-        border-radius: 15px;
-        margin-bottom: 20px;
-    }
-    .status-info {
-        background: #f8f9fa;
-        padding: 10px;
-        border-radius: 8px;
-        border-left: 4px solid #28a745;
-        margin: 10px 0;
-    }
-    """
+def create_gradio_interface():
+    """创建Gradio用户界面"""
     
-    with gr.Blocks(title="AI时尚设计师", theme=gr.themes.Soft(), css=custom_css) as demo:
-        
-        # 头部
-        gr.HTML(f"""
-            <div class="header">
-                <h1>🎨 AI时尚设计师</h1>
-                <p>智能图像分析 • 个性化设计建议 • AI生成时尚方案</p>
-                <div class="status-info">
-                    <strong>系统状态:</strong> 
-                    {'🟢 GPU可用' if torch.cuda.is_available() else '🟡 CPU模式'} | 
-                    {'✅ AI模型就绪' if model_manager.models_loaded else '⚠️ 基础模式'} |
-                    {'🚀 Spaces GPU' if SPACES_GPU_AVAILABLE else '💻 标准环境'}
-                </div>
-            </div>
-        """)
-        
-        # 主界面
-        with gr.Row():
-            # 左侧：图像上传和分析
-            with gr.Column(scale=1):
-                gr.Markdown("## 📸 图像分析")
-                
-                image_input = gr.Image(
-                    type="pil", 
-                    label="上传时尚图片",
-                    height=300
-                )
-                
-                analyze_btn = gr.Button(
-                    "🔍 AI智能分析",
-                    variant="primary",
-                    size="lg"
-                )
-                
-                # 分析状态
-                analysis_status = gr.Textbox(
-                    label="分析状态",
-                    value="等待图片上传...",
-                    interactive=False
-                )
-            
-            # 右侧：分析结果
-            with gr.Column(scale=2):
-                gr.Markdown("## 📊 分析结果")
-                
-                with gr.Tabs():
-                    with gr.Tab("🔍 详细分析"):
-                        analysis_output = gr.JSON(label="AI分析报告")
-                    
-                    with gr.Tab("🎨 色彩分析"):
-                        color_gallery = gr.DataFrame(
-                            headers=["颜色名称", "RGB值", "十六进制", "占比%"],
-                            label="色彩详细信息"
-                        )
-        
-        # 设计建议部分
-        gr.Markdown("## 💡 个性化设计建议")
+    with gr.Blocks(title="AI时尚设计师") as demo:
+        gr.Markdown("# 🎨 AI时尚设计师")
+        gr.Markdown("上传图片，获得专业的服装设计建议和3D试穿效果")
         
-        with gr.Row():
-            suggestions_radio = gr.Radio(
-                label="选择设计方向",
-                interactive=True
-            )
-            generate_btn = gr.Button(
-                "🚀 生成设计���案",
-                variant="primary"
-            )
-        
-        # 设计结果
-        with gr.Tabs():
-            with gr.Tab("🎯 设计方案"):
-                designs_gallery = gr.Gallery(
-                    label="AI生成的设计方案",
-                    columns=2,
-                    rows=2,
-                    height=400
-                )
-                
-                design_choice = gr.Radio(
-                    label="选择方案进行3D试穿",
-                    interactive=True
-                )
-                
-                fitting_btn = gr.Button(
-                    "👤 生成3D试穿",
-                    variant="primary"
-                )
-            
-            with gr.Tab("👥 3D试穿"):
-                fitting_output = gr.Image(
-                    label="3D虚拟试穿效果",
-                    height=500
-                )
+        with gr.Tab("1. 图片上传与分析"):
+            image_input = gr.Image(type="filepath", label="上传参考图片")
+            analyze_btn = gr.Button("分析风格")
+            analysis_output = gr.JSON(label="风格分析结果")
         
-        # 系统控制
-        with gr.Accordion("⚙️ 系统控制", open=False):
-            with gr.Row():
-                cleanup_btn = gr.Button("🧹 清理内存")
-                memory_status = gr.Textbox(label="内存状态", interactive=False)
+        with gr.Tab("2. 设计建议"):
+            suggestions_output = gr.JSON(label="设计建议")
+            suggestion_choice = gr.Radio(label="选择设计建议")
+            generate_designs_btn = gr.Button("生成样衣设计")
         
-        # 状态存储
-        analysis_state = gr.State({})
+        with gr.Tab("3. 样衣设计"):
+            designs_gallery = gr.Gallery(label="样衣设计图")
+            design_choice = gr.Radio(label="选择设计")
+            generate_3d_btn = gr.Button("生成3D试穿")
         
-        # 事件处理
-        def process_analysis(image):
-            if image is None:
-                return {}, gr.Radio(choices=[]), [], "❌ 请先上传图片", {}
-            
-            # 执行分析
-            result = analyze_fashion_image(image)
-            
-            if "error" in result:
-                return result, gr.Radio(choices=[]), [], f"❌ {result['error']}", result
-            
-            # 生成建议
-            suggestions = generate_design_suggestions(result)
-            choices = list(suggestions.keys())
-            
-            # 准备色彩数据
-            color_data = []
-            for color in result.get("color_analysis", []):
-                color_data.append([
-                    color["name"],
-                    str(color["rgb"]),
-                    color["hex"],
-                    f"{color['percentage']}%"
-                ])
-            
-            status = f"✅ 分析完成 - 耗时 {result.get('analysis_time', '未知')}"
-            
-            return (
-                result,
-                gr.Radio(choices=choices, value=choices[0] if choices else None),
-                color_data,
-                status,
-                result
-            )
+        with gr.Tab("4. 3D试穿"):
+            fitting_result = gr.Image(label="3D试穿效果")
         
+        # 事件绑定
         analyze_btn.click(
-            fn=process_analysis,
+            fn=upload_and_analyze,
             inputs=[image_input],
-            outputs=[
-                analysis_output,
-                suggestions_radio,
-                color_gallery,
-                analysis_status,
-                analysis_state
-            ]
+            outputs=[analysis_output, suggestions_output, suggestion_choice]
         )
         
-        # 设计生成
-        def handle_design_generation(suggestion, analysis_result):
-            if not suggestion or "error" in analysis_result:
-                return [], gr.Radio(choices=[])
-            
-            designs = generate_designs(suggestion, analysis_result)
-            choices = [f"{suggestion} - 方案{i+1}" for i in range(len(designs))]
-            
-            return designs, gr.Radio(choices=choices, value=choices[0] if choices else None)
-        
-        generate_btn.click(
-            fn=handle_design_generation,
-            inputs=[suggestions_radio, analysis_state],
+        generate_designs_btn.click(
+            fn=generate_designs,
+            inputs=[suggestion_choice],
             outputs=[designs_gallery, design_choice]
         )
         
-        # 3D试穿
-        fitting_btn.click(
-            fn=create_3d_fitting,
+        generate_3d_btn.click(
+            fn=generate_3d_fitting,
             inputs=[design_choice],
-            outputs=[fitting_output]
-        )
-        
-        # 内存清理
-        cleanup_btn.click(
-            fn=model_manager.cleanup_memory,
-            inputs=[],
-            outputs=[memory_status]
+            outputs=[fitting_result]
         )
-        
-        # 底部信息
-        gr.Markdown("""
-        ---
-        ### 🔧 技术说明
-        
-        **AI技术栈:**
-        - 🔤 BLIP: 专业图像理解与描述生成
-        - 🎨 Stable Diffusion: 高质量时尚设计生成
-        - 🧮 K-means聚类: 智能色彩分析
-        - 📊 风格识别: 多维度时尚风格评估
-        
-        **系统特点:**
-        - ✅ 单文件部署，无模块导入错误
-        - 🚀 自动GPU/CPU适配
-        - 🛡️ 完善的错误处理机制
-        - 📱 响应式用户界面
-        
-        > 💡 **使用提示**: 首次运行会下载AI模型，请耐心等待。生成过程可能需要1-3分钟。
-        """)
     
     return demo
 
-# 主函数
-def main():
-    """应用主入口"""
-    try:
-        logger.info("🚀 启动AI时尚设计师应用...")
-        logger.info(f"PyTorch版本: {torch.__version__}")
-        logger.info(f"CUDA可用: {torch.cuda.is_available()}")
-        logger.info(f"AI模型库可用: {MODELS_AVAILABLE}")
-        
-        # 创建界面
-        demo = create_fashion_interface()
-        
-        # 配置启动参数
-        demo.queue(
-            concurrency_count=2 if torch.cuda.is_available() else 1,
-            max_size=10
-        )
-        
-        # 启动应用
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=int(os.environ.get("PORT", 7860)),
-            share=False,
-            show_error=True,
-            debug=False
-        )
-        
-    except Exception as e:
-        logger.error(f"应用启动失败: {e}")
-        print(f"启动错误: {e}")
-        
-        # 创建最小化的错误页面
-        with gr.Blocks() as error_demo:
-            gr.HTML(f"""
-                <div style="text-align: center; padding: 50px;">
-                    <h1>❌ 应用启动失败</h1>
-                    <p><strong>错误信息:</strong> {str(e)}</p>
-                    <p><strong>PyTorch可用:</strong> {torch.__version__ if 'torch' in globals() else '未安装'}</p>
-                    <p><strong>CUDA可用:</strong> {torch.cuda.is_available() if 'torch' in globals() else '未知'}</p>
-                    <hr>
-                    <h2>🛠️ 故障排除建议:</h2>
-                    <ol style="text-align: left; max-width: 600px; margin: 0 auto;">
-                        <li>检查 requirements.txt 中的依赖是否正确安装</li>
-                        <li>确认 Hugging Face Spaces 环境配置</li>
-                        <li>检查 GPU 资源是否可用</li>
-                        <li>查看完整的错误日志</li>
-                    </ol>
-                </div>
-            """)
-        
-        error_demo.launch()
-
 if __name__ == "__main__":
-    main()
+    demo = create_gradio_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)