Update app.py

app.py

@@ -6,8 +6,9 @@ import random
 import warnings
 import json
 import numpy as np
-from PIL import Image
-import gradio as gr  # 确保在函数定义前导入
+from PIL import Image, ImageDraw, ImageFont
+import gradio as gr
+import colorsys
 
 # 设置环境变量解决 OpenMP 问题
 os.environ['OMP_NUM_THREADS'] = '1'
@@ -38,29 +39,23 @@ class SimpleModelManager:
         logger.info("使用简化模型管理器")
     
     def generate_caption(self, image):
-        # 真实模拟BLIP模型输出
         return "一件时尚的{}服装，采用{}设计".format(
             random.choice(["夏季", "冬季", "春秋季"]),
             random.choice(["简约", "复古", "现代", "街头"])
         )
     
     def analyze_style(self, image):
-        # 真实模拟CLIP模型输出
         styles = ["商务正装", "休闲风", "运动风", "时尚潮流", "复古风", "街头风", "优雅风"]
         scores = {style: random.uniform(0.3, 0.9) for style in random.sample(styles, 3)}
         return scores
     
     def generate_image(self, prompt, **kwargs):
-        """真实模拟SD模型生成过程"""
         width = kwargs.get('width', 512)
         height = kwargs.get('height', 512)
-        
-        # 创建基于提示词的图像
         img = Image.new('RGB', (width, height), color=(200, 200, 200))
         return img
     
     def generate_controlnet_image(self, image, prompt, **kwargs):
-        """真实模拟ControlNet生成过程"""
         return self.generate_image(prompt, width=512, height=768)
     
     def cleanup(self):
@@ -75,16 +70,35 @@ class SimpleModelManager:
     def force_reload_all_models(self):
         pass
 
-# 全局状态管理
-class AppState:
+# 改进的全局状态管理
+class DesignState:
     def __init__(self):
-        self.current_image = None
-        self.current_caption = ""
-        self.current_analysis = {}
-        self.current_suggestions = {}
-        self.design_images = []
-        self.selected_suggestion = ""
+        self.reset()
+    
+    def reset(self):
+        self.original_image = None
+        self.image_caption = ""
+        self.style_analysis = {}
+        self.color_analysis = {}
+        self.fabric_analysis = {}
+        self.design_direction = ""
+        self.design_concepts = []
+        self.generated_designs = []
         self.selected_design_index = -1
+        self.fitting_result = None
+        
+    def get_design_context(self):
+        """获取完整的设计上下文，用于生成连贯的设计"""
+        return {
+            "caption": self.image_caption,
+            "main_style": max(self.style_analysis.keys(), key=self.style_analysis.get) if self.style_analysis else "时尚",
+            "style_scores": self.style_analysis,
+            "dominant_colors": self.color_analysis.get("dominant_colors", []),
+            "color_palette": self.color_analysis.get("color_palette", {}),
+            "fabric_type": self.fabric_analysis.get("predicted_fabric", "棉质"),
+            "texture": self.fabric_analysis.get("texture", "光滑"),
+            "design_direction": self.design_direction
+        }
 
 # 初始化模型管理器
 if MODELS_AVAILABLE:
@@ -97,556 +111,856 @@ if MODELS_AVAILABLE:
 else:
     model_manager = SimpleModelManager()
 
-app_state = AppState()
+design_state = DesignState()
 
-def upload_and_analyze(image_path, progress=gr.Progress()):
-    """完整的图片上传和分析流程 - 使用真实模型分析"""
+def advanced_color_analysis(image):
+    """高级颜色分析 - 提取颜色调色板和情感色彩"""
     try:
-        # 重置应用状态
-        global app_state
-        app_state = AppState()
+        from sklearn.cluster import KMeans
         
-        if image_path is None:
-            return {}, {}, gr.Radio(choices=[]), gr.Gallery(value=[])
+        # 调整图像大小
+        image = image.resize((150, 150))
+        img_array = np.array(image)
+        pixels = img_array.reshape(-1, 3)
         
-        progress(0.1, desc="加载图片...")
-        image = Image.open(image_path).convert('RGB')
-        app_state.current_image = image
+        # 使用KMeans提取主要颜色
+        kmeans = KMeans(n_clusters=5, random_state=42, n_init=10)
+        kmeans.fit(pixels)
         
-        # 步骤1: 使用BLIP模型生成图像描述
-        progress(0.2, desc="生成图像描述...")
-        try:
-            caption = model_manager.generate_caption(image)
-            app_state.current_caption = caption
-            logger.info(f"BLIP生成的图像描述: {caption}")
-        except Exception as e:
-            logger.error(f"生成描述失败: {e}")
-            caption = "时尚服装设计"
-            app_state.current_caption = caption
+        colors = kmeans.cluster_centers_.astype(int)
+        labels = kmeans.labels_
         
-        # 步骤2: 使用CLIP模型分析风格
-        progress(0.4, desc="分析服装风格...")
-        try:
-            style_scores = model_manager.analyze_style(image)
-            logger.info(f"CLIP风格分析结果: {style_scores}")
-        except Exception as e:
-            logger.error(f"风格分析失败: {e}")
-            # 使用描述回退分析
-            style_scores = analyze_style_from_caption(caption)
-        
-        # 步骤3: 提取颜色信息
-        progress(0.6, desc="提取颜色信息...")
-        colors = extract_dominant_colors(image)
-        logger.info(f"提取的主要颜色: {colors}")
-        
-        # 步骤4: 整合分析结果
-        progress(0.8, desc="生成完整分析...")
-        app_state.current_analysis = {
-            "图像描述": caption,
-            "主要风格": max(style_scores, key=style_scores.get),
-            "风格评分": style_scores,
-            "主要颜色": colors,
-            "图像尺寸": f"{image.width} x {image.height}",
-            "分析时间": time.strftime("%Y-%m-%d %H:%M:%S")
-        }
+        # 计算每种颜色的比例
+        color_percentages = []
+        for i in range(5):
+            percentage = np.sum(labels == i) / len(labels)
+            color_percentages.append(percentage)
         
-        # 步骤5: 基于所有分析结果生成个性化建议
-        app_state.current_suggestions = generate_personalized_suggestions_v2(
-            caption, style_scores, colors
-        )
-        logger.info(f"生成的设计建议: {app_state.current_suggestions}")
+        # 按比例排序
+        color_data = list(zip(colors, color_percentages))
+        color_data.sort(key=lambda x: x[1], reverse=True)
         
-        # 创建建议选项
-        choices = list(app_state.current_suggestions.keys())
+        # 生成颜色信息
+        dominant_colors = []
+        color_palette = {}
         
-        progress(1.0, desc="分析完成")
+        for i, (color, percentage) in enumerate(color_data):
+            color_name = rgb_to_detailed_color_name(color)
+            color_emotion = get_color_emotion(color)
+            dominant_colors.append(color_name)
+            
+            color_palette[f"颜色{i+1}"] = {
+                "name": color_name,
+                "rgb": color.tolist(),
+                "hex": rgb_to_hex(color),
+                "percentage": f"{percentage:.1%}",
+                "emotion": color_emotion,
+                "fashion_application": get_fashion_application(color_name)
+            }
         
-        return (
-            app_state.current_analysis, 
-            app_state.current_suggestions, 
-            gr.Radio(choices=choices, value=choices[0] if choices else None),
-            gr.Gallery(value=[])  # 清空之前的设计
-        )
+        return {
+            "dominant_colors": dominant_colors[:3],  # 前3种主要颜色
+            "color_palette": color_palette,
+            "color_harmony": analyze_color_harmony(colors[:3]),
+            "season_analysis": analyze_seasonal_colors(colors[:3])
+        }
         
     except Exception as e:
-        logger.error(f"上传分析失败: {e}", exc_info=True)
-        return {"错误": f"分析失败: {str(e)}"}, {}, gr.Radio(choices=[]), gr.Gallery(value=[])
+        logger.error(f"高级颜色分析失败: {e}")
+        return {
+            "dominant_colors": ["经典色调"],
+            "color_palette": {"颜色1": {"name": "经典色调", "emotion": "中性"}},
+            "color_harmony": "单色调",
+            "season_analysis": "四季通用"
+        }
 
-def analyze_style_from_caption(caption):
-    """基于描述分析风格（回退方案）"""
-    caption_lower = caption.lower()
+def rgb_to_detailed_color_name(rgb):
+    """更详细的RGB到颜色名称转换"""
+    r, g, b = rgb
     
-    style_keywords = {
-        "商务正装": ["suit", "formal", "business", "office", "professional", "tie", "blazer", "西装", "正装", "商务"],
-        "休闲风": ["casual", "relaxed", "comfortable", "everyday", "jeans", "t-shirt", "休闲", "日常"],
-        "运动风": ["sport", "athletic", "gym", "fitness", "running", "training", "运动", "健身"],
-        "时尚潮流": ["fashion", "trendy", "stylish", "modern", "chic", "designer", "时尚", "潮流"],
-        "复古风": ["vintage", "retro", "classic", "traditional", "old-fashioned", "复古", "经典"],
-        "街头风": ["street", "urban", "hip-hop", "cool", "edgy", "街头", "嘻哈"],
-        "优雅风": ["elegant", "sophisticated", "graceful", "refined", "classy", "优雅", "高贵"]
+    # 转换到HSV空间进行更精确的颜色分类
+    h, s, v = colorsys.rgb_to_hsv(r/255.0, g/255.0, b/255.0)
+    h = h * 360
+    s = s * 100
+    v = v * 100
+    
+    # 基于HSV值进行精确分类
+    if v < 20:
+        return "深黑色"
+    elif v > 90 and s < 10:
+        return "纯白色"
+    elif s < 15:
+        if v < 30:
+            return "深灰色"
+        elif v < 70:
+            return "中灰色"
+        else:
+            return "浅灰色"
+    
+    # 彩色分类
+    color_ranges = [
+        (0, 15, "深红色"), (15, 45, "橙红色"), (45, 75, "金黄色"),
+        (75, 105, "草绿色"), (105, 135, "翠绿色"), (135, 165, "青绿色"),
+        (165, 195, "天蓝色"), (195, 225, "宝蓝色"), (225, 255, "紫蓝色"),
+        (255, 285, "紫色"), (285, 315, "紫红色"), (315, 345, "玫红色"),
+        (345, 360, "深红色")
+    ]
+    
+    for start, end, color_name in color_ranges:
+        if start <= h < end:
+            if v < 40:
+                return f"深{color_name}"
+            elif v > 80:
+                return f"亮{color_name}"
+            else:
+                return color_name
+    
+    return "混合色调"
+
+def rgb_to_hex(rgb):
+    """RGB转十六进制"""
+    return "#{:02x}{:02x}{:02x}".format(int(rgb[0]), int(rgb[1]), int(rgb[2]))
+
+def get_color_emotion(rgb):
+    """获取颜色的情感属性"""
+    r, g, b = rgb
+    
+    # 基于颜色心理学的情感映射
+    if r > 180 and g < 100 and b < 100:
+        return "热情、力量、激情"
+    elif r < 100 and g > 150 and b < 100:
+        return "自然、平静、成长"
+    elif r < 100 and g < 100 and b > 150:
+        return "专业、信任、稳定"
+    elif r > 150 and g > 150 and b < 100:
+        return "温暖、活力、创意"
+    elif r > 100 and g < 100 and b > 150:
+        return "神秘、高贵、优雅"
+    elif r < 50 and g < 50 and b < 50:
+        return "经典、正式、权威"
+    elif r > 200 and g > 200 and b > 200:
+        return "纯洁、简约、现代"
+    else:
+        return "平衡、和谐、中性"
+
+def get_fashion_application(color_name):
+    """获取颜色在时尚中的应用建议"""
+    applications = {
+        "深红色": "晚装、正装细节、配饰",
+        "橙红色": "夏季休闲、运动装、配饰",
+        "金黄色": "夏季单品、配饰、装饰细节",
+        "草绿色": "春夏装、休闲装、自然风格",
+        "翠绿色": "春装、度假装、民族风格",
+        "天蓝色": "衬衫、夏装、商务休闲",
+        "宝蓝色": "正装、晚装、经典款式",
+        "紫色": "晚装、艺术风格、个性单品",
+        "深黑色": "基础款、正装、经典设计",
+        "纯白色": "基础款、夏装、简约风格",
+        "深灰色": "商务装、基础款、现代风格"
     }
     
-    style_scores = {}
-    for style, keywords in style_keywords.items():
-        score = sum(0.2 for keyword in keywords if keyword in caption_lower)
-        if score > 0:
-            style_scores[style] = min(score, 1.0)
+    return applications.get(color_name, "通用时尚单品")
+
+def analyze_color_harmony(colors):
+    """分析颜色和谐度"""
+    if len(colors) < 2:
+        return "单色调"
+    
+    # 转换为HSV进行分析
+    hsv_colors = []
+    for color in colors:
+        h, s, v = colorsys.rgb_to_hsv(color[0]/255.0, color[1]/255.0, color[2]/255.0)
+        hsv_colors.append((h*360, s*100, v*100))
+    
+    h_values = [hsv[0] for hsv in hsv_colors]
+    
+    # 判断配色方案
+    h_diff = max(h_values) - min(h_values)
+    
+    if h_diff < 30:
+        return "同色系配色"
+    elif h_diff < 60:
+        return "相邻色配色"
+    elif 150 < h_diff < 210:
+        return "对比色配色"
+    else:
+        return "多色调配色"
+
+def analyze_seasonal_colors(colors):
+    """分析季节色彩倾向"""
+    # 计算平均饱和度和明度
+    total_s, total_v = 0, 0
+    
+    for color in colors:
+        h, s, v = colorsys.rgb_to_hsv(color[0]/255.0, color[1]/255.0, color[2]/255.0)
+        total_s += s
+        total_v += v
     
-    # 如果没有匹配，给默认评分
-    if not style_scores:
-        style_scores = {"休闲风": 0.7, "时尚潮流": 0.5}
+    avg_s = total_s / len(colors)
+    avg_v = total_v / len(colors)
     
-    return style_scores
+    if avg_s > 0.6 and avg_v > 0.6:
+        return "春季色彩（明亮、清新）"
+    elif avg_s > 0.6 and avg_v < 0.6:
+        return "秋季色彩（浓郁、温暖）"
+    elif avg_s < 0.6 and avg_v > 0.6:
+        return "夏季色彩（柔和、清淡）"
+    else:
+        return "冬季色彩（深沉、对比）"
 
-def extract_dominant_colors(image):
-    """提取图像主要颜色 - 真实算法"""
+def analyze_fabric_texture(image):
+    """分析面料和质地（基于图像特征）"""
     try:
-        from sklearn.cluster import KMeans
-        
-        # 调整图像大小以提高处理速度
-        image = image.resize((150, 150))
-        
-        # 转换为numpy数组
-        img_array = np.array(image)
-        pixels = img_array.reshape(-1, 3)
-        
-        # 使用KMeans聚类找到主要颜色
-        kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
-        kmeans.fit(pixels)
+        # 转换为灰度图进行纹理分析
+        gray_image = image.convert('L')
+        img_array = np.array(gray_image)
+        
+        # 计算纹理特征
+        # 1. 计算标准差（纹理粗糙度）
+        texture_variance = np.std(img_array)
+        
+        # 2. 计算边缘密度
+        from scipy import ndimage
+        edges = ndimage.sobel(img_array)
+        edge_density = np.mean(np.abs(edges))
+        
+        # 基于特征推断面料类型
+        if texture_variance < 20:
+            if edge_density < 10:
+                fabric_type = "丝绸"
+                texture = "光滑丝滑"
+            else:
+                fabric_type = "棉质"
+                texture = "柔软光滑"
+        elif texture_variance < 40:
+            fabric_type = "混纺"
+            texture = "适中质感"
+        else:
+            if edge_density > 30:
+                fabric_type = "牛仔"
+                texture = "粗糙硬挺"
+            else:
+                fabric_type = "毛呢"
+                texture = "厚实温暖"
         
-        # 获取主要颜色
-        colors = []
-        for color in kmeans.cluster_centers_:
-            color_name = rgb_to_color_name(color)
-            colors.append(color_name)
+        return {
+            "predicted_fabric": fabric_type,
+            "texture": texture,
+            "texture_score": texture_variance,
+            "edge_score": edge_density,
+            "fabric_properties": get_fabric_properties(fabric_type)
+        }
         
-        return colors
     except Exception as e:
-        logger.error(f"颜色提取失败: {e}")
-        return ["主色调", "辅助色", "点缀色"]
+        logger.error(f"面料分析失败: {e}")
+        return {
+            "predicted_fabric": "棉质",
+            "texture": "舒适",
+            "fabric_properties": "透气、舒适、日常"
+        }
 
-def rgb_to_color_name(rgb):
-    """将RGB值转换为颜色名称 - 真实算法"""
-    try:
-        r, g, b = rgb.astype(int)
-        
-        if r > 200 and g > 200 and b > 200:
-            return "白色系"
-        elif r < 50 and g < 50 and b < 50:
-            return "黑色系"
-        elif r > g and r > b:
-            return "红色系" if r > 150 else "深红色系"
-        elif g > r and g > b:
-            return "绿色系" if g > 150 else "深绿色系"
-        elif b > r and b > g:
-            return "蓝色系" if b > 150 else "深蓝色系"
-        elif r > 150 and g > 150:
-            return "黄色系"
-        elif r > 100 and b > 100:
-            return "紫色系"
-        elif g > 100 and b > 100:
-            return "青色系"
-        else:
-            return "灰色系"
-    except:
-        return "混合色调"
+def get_fabric_properties(fabric_type):
+    """获取面料特性"""
+    properties = {
+        "丝绸": "光泽感强、垂坠性好、高级感、适合正装",
+        "棉质": "透气舒适、日常休闲、易打理、四季适用",
+        "混纺": "结合优点、性价比高、适应性强、现代感",
+        "牛仔": "硬挺耐用、休闲风格、经典时尚、年轻活力",
+        "毛呢": "保暖性好、正式高级、秋冬首选、商务感强"
+    }
+    return properties.get(fabric_type, "舒适实用")
 
-def generate_personalized_suggestions_v2(caption, style_scores, colors):
-    """基于模型分析结果生成个性化建议"""
+def comprehensive_image_analysis(image_path, progress=gr.Progress()):
+    """综合图像分析 - 整合所有分析维度"""
     try:
-        # 获取主要风格
-        main_style = max(style_scores.keys(), key=style_scores.get) if style_scores else "时尚潮流"
-        main_color = colors[0] if colors else "经典色"
-        
-        # 基于主要风格和颜色生成建议
-        suggestions = {}
-        
-        if "商务" in main_style:
-            suggestions = {
-                f"经典{main_style}": f"保持{main_style}特色，强调{main_color}的专业感",
-                f"现代{main_style}": f"在{main_style}基础上融入现代设计元素",
-                f"时尚{main_style}": f"{main_style}结合当下流行趋势",
-                f"个性{main_style}": f"基于{main_color}打造独特的{main_style}风格"
-            }
-        elif "休闲" in main_style:
-            suggestions = {
-                "舒适休闲": f"强化舒适感，突出{main_color}的自然魅力",
-                "时尚休闲": f"休闲风格融入时尚元素",
-                "运动休闲": f"结合运动风格的休闲设计",
-                "优雅休闲": f"提升休闲装的优雅度"
-            }
-        elif "运动" in main_style:
-            suggestions = {
-                "专业运动": f"强化功能性，突出{main_color}的活力",
-                "时尚运动": f"运动风格加入潮流设计",
-                "休闲运动": f"适合日常的运动休闲风",
-                "户外运动": f"适应户外环境的运动设计"
-            }
-        else:
-            # 其他风格的通用建议
-            suggestions = {
-                f"经典{main_style}": f"保持{main_style}的经典特色",
-                f"现代{main_style}": f"{main_style}融入现代设计理念",
-                f"创新{main_style}": f"在{main_style}基础上的创新尝试",
-                f"个性{main_style}": f"基于{main_color}的个性化{main_style}"
-            }
+        design_state.reset()
         
-        # 添加基于颜色的额外建议
-        color_suggestions = {
-            f"单色系设计": f"围绕{main_color}打造单色系搭配",
-            f"撞色搭配": f"以{main_color}为主的撞色设计"
+        if image_path is None:
+            return {}, {}, gr.Radio(choices=[]), gr.Gallery(value=[])
+        
+        progress(0.05, desc="加载图片...")
+        image = Image.open(image_path).convert('RGB')
+        design_state.original_image = image
+        
+        # 1. BLIP图像描述
+        progress(0.15, desc="AI图像理解中...")
+        try:
+            caption = model_manager.generate_caption(image)
+            design_state.image_caption = caption
+            logger.info(f"BLIP描述: {caption}")
+        except Exception as e:
+            logger.error(f"图像描述生成失败: {e}")
+            caption = "时尚服装设计作品"
+            design_state.image_caption = caption
+        
+        # 2. CLIP风格分析
+        progress(0.3, desc="AI风格识别中...")
+        try:
+            style_scores = model_manager.analyze_style(image)
+            design_state.style_analysis = style_scores
+            logger.info(f"风格分析: {style_scores}")
+        except Exception as e:
+            logger.error(f"风格分析失败: {e}")
+            style_scores = {"时尚潮流": 0.8, "现代风格": 0.6}
+            design_state.style_analysis = style_scores
+        
+        # 3. 高级颜色分析
+        progress(0.5, desc="深度颜色分析中...")
+        color_analysis = advanced_color_analysis(image)
+        design_state.color_analysis = color_analysis
+        
+        # 4. 面料质地分析
+        progress(0.7, desc="面料质地分析中...")
+        fabric_analysis = analyze_fabric_texture(image)
+        design_state.fabric_analysis = fabric_analysis
+        
+        # 5. 生成综合分析报告
+        progress(0.85, desc="生成分析报告...")
+        comprehensive_analysis = {
+            "基础信息": {
+                "图像描述": caption,
+                "图像尺寸": f"{image.width} x {image.height}",
+                "分析时间": time.strftime("%Y-%m-%d %H:%M:%S")
+            },
+            "风格分析": {
+                "主要风格": max(style_scores.keys(), key=style_scores.get),
+                "风格置信度": f"{max(style_scores.values()):.1%}",
+                "所有风格评分": {k: f"{v:.1%}" for k, v in sorted(style_scores.items(), key=lambda x: x[1], reverse=True)}
+            },
+            "颜色分析": {
+                "主色调": color_analysis["dominant_colors"][0] if color_analysis["dominant_colors"] else "经典色调",
+                "配色方案": color_analysis["color_harmony"],
+                "季节倾向": color_analysis["season_analysis"],
+                "颜色情感": color_analysis["color_palette"].get("颜色1", {}).get("emotion", "中性")
+            },
+            "材质分析": {
+                "预测面料": fabric_analysis["predicted_fabric"],
+                "质地特征": fabric_analysis["texture"],
+                "面料特性": fabric_analysis["fabric_properties"]
+            }
         }
         
-        # 合并建议（限制数量避免选项过多）
-        final_suggestions = dict(list(suggestions.items())[:4] + list(color_suggestions.items())[:2])
+        # 6. 基于综合分析生成设计建议
+        design_suggestions = generate_intelligent_suggestions()
         
-        return final_suggestions
+        progress(1.0, desc="分析完成")
+        
+        choices = list(design_suggestions.keys())
+        return (
+            comprehensive_analysis,
+            design_suggestions,
+            gr.Radio(choices=choices, value=choices[0] if choices else None),
+            gr.Gallery(value=[])
+        )
         
     except Exception as e:
-        logger.error(f"生成建议失败: {e}")
-        return {
-            "经典设计": "传统经典的设计风格",
-            "现代风格": "融入现代设计元素",
-            "时尚潮流": "跟随当下时尚趋势",
-            "个性化": "独特的个性化设计"
-        }
+        logger.error(f"综合分析失败: {e}", exc_info=True)
+        return {"错误": f"分析失败: {str(e)}"}, {}, gr.Radio(choices=[]), gr.Gallery(value=[])
 
-def generate_designs(selected_suggestion, progress=gr.Progress()):
-    """根据选择的建议使用SD模型生成设计"""
+def generate_intelligent_suggestions():
+    """基于所有分析维度生成智能设计建议"""
+    context = design_state.get_design_context()
+    
+    # 获取关键信息
+    main_style = context["main_style"]
+    dominant_color = context["dominant_colors"][0] if context["dominant_colors"] else "经典色调"
+    fabric_type = context["fabric_type"]
+    color_emotion = design_state.color_analysis.get("color_palette", {}).get("颜色1", {}).get("emotion", "中性")
+    
+    # 基于综合分析生成建议
+    suggestions = {}
+    
+    # 1. 风格延续建议
+    suggestions[f"经典{main_style}"] = f"保持{main_style}核心特色，运用{dominant_color}主色调，体现{color_emotion}的情感表达"
+    
+    # 2. 材质创新建议
+    suggestions[f"{fabric_type}质感创新"] = f"基于{fabric_type}面料特性，结合{dominant_color}配色，打造现代{main_style}风格"
+    
+    # 3. 配色方案建议
+    color_harmony = design_state.color_analysis.get("color_harmony", "和谐配色")
+    suggestions[f"{color_harmony}设计"] = f"采用{color_harmony}策略，以{dominant_color}为主调，营造{color_emotion}氛围"
+    
+    # 4. 季节适应建议
+    season_analysis = design_state.color_analysis.get("season_analysis", "四季通用")
+    suggestions[f"{season_analysis}款式"] = f"针对{season_analysis}特点，融合{main_style}元素，突出{fabric_type}质感"
+    
+    # 5. 情感导向建议
+    suggestions[f"{color_emotion}表达"] = f"强化{color_emotion}的情感传达，通过{main_style}剪裁体现{fabric_type}的独特魅力"
+    
+    # 6. 创新融合建议
+    suggestions["跨界融合创新"] = f"打破传统{main_style}界限，创新运用{dominant_color}，结合现代设计理念"
+    
+    return suggestions
+
+def generate_professional_designs(selected_suggestion, progress=gr.Progress()):
+    """生成专业服装设计图 - 三视图风格"""
     try:
-        if not selected_suggestion or not app_state.current_analysis:
+        if not selected_suggestion or not design_state.original_image:
             return gr.Gallery(value=[]), gr.Radio(choices=[])
         
+        design_state.design_direction = selected_suggestion
+        
         progress(0.1, desc="准备设计生成...")
-        app_state.selected_suggestion = selected_suggestion
         
-        # 基于当前分析结果和选择的建议生成详细的提示词
-        base_prompt = create_design_prompt(
-            selected_suggestion, 
-            app_state.current_analysis
-        )
+        # 获取完整设计上下文
+        context = design_state.get_design_context()
         
-        # 生成设计图像
-        design_images = []
+        # 生成三种专业设计视图
+        design_views = ["正面设计图", "背面设计图", "侧面设计图"]
+        generated_designs = []
         design_choices = []
         
-        for i in range(3):  # 生成3个设计方案
+        for i, view in enumerate(design_views):
             try:
-                progress(0.2 + i*0.25, desc=f"生成设计方案 {i+1}/3...")
+                progress(0.2 + i*0.25, desc=f"生成{view}...")
                 
-                # 为每个设计添加变化，同时包含原始描述和风格信息
-                variant_prompt = (
-                    f"{base_prompt}, design variation {i+1}, "
-                    f"inspired by: '{app_state.current_caption}', "
-                    f"style: {app_state.current_analysis['主要风格']}, "
-                    f"colors: {', '.join(app_state.current_analysis['主要颜色'][:2])}"
-                )
+                # 创建专业的设计提示词
+                design_prompt = create_professional_design_prompt(view, context, selected_suggestion)
                 
-                # 使用模型生成图像
-                image = model_manager.generate_image(
-                    prompt=variant_prompt,
-                    negative_prompt="blurry, low quality, distorted, text, watermark, ugly, deformed",
-                    num_inference_steps=25,
+                # 使用SD模型生成设计
+                design_image = model_manager.generate_image(
+                    prompt=design_prompt,
+                    negative_prompt="person, face, model, background, blurry, low quality, text, watermark, realistic photo, 3d render",
+                    num_inference_steps=30,
                     width=512,
-                    height=512,
-                    guidance_scale=7.5
+                    height=640,
+                    guidance_scale=8.0
                 )
                 
-                design_images.append(image)
-                design_choices.append(f"{selected_suggestion} - 方案 {i+1}")
-                logger.info(f"成功生成设计方案 {i+1}")
-                    
+                generated_designs.append(design_image)
+                design_choices.append(f"{selected_suggestion} - {view}")
+                logger.info(f"成功生成{view}")
+                
             except Exception as e:
-                logger.error(f"生成设计 {i+1} 失败: {e}")
+                logger.error(f"生成{view}失败: {e}")
                 # 创建占位图像
-                img = create_placeholder_image(512, 512)
-                design_images.append(img)
-                design_choices.append(f"{selected_suggestion} - 方案 {i+1} (占位)")
+                placeholder = create_design_placeholder(view, 512, 640)
+                generated_designs.append(placeholder)
+                design_choices.append(f"{selected_suggestion} - {view} (占位)")
         
-        # 保存生成的设计
-        app_state.design_images = design_images
+        design_state.generated_designs = generated_designs
         
-        progress(0.95, desc="完成设计生成")
+        progress(1.0, desc="设计生成完成")
         
         return (
-            gr.Gallery(value=design_images), 
+            gr.Gallery(value=generated_designs, columns=3),
             gr.Radio(choices=design_choices, value=design_choices[0] if design_choices else None)
         )
         
     except Exception as e:
-        logger.error(f"设计生成错误: {e}")
+        logger.error(f"专业设计生成失败: {e}")
         return gr.Gallery(value=[]), gr.Radio(choices=[])
 
-def generate_3d_fitting(selected_design_index, progress=gr.Progress()):
-    """生成3D试穿效果 - 使用更精细的模型"""
+def create_professional_design_prompt(view, context, suggestion):
+    """创建专业的服装设计提示词 - 避免token截断"""
+    
+    # 关键词映射，避免中文token问题
+    style_keywords = {
+        "商务正装": "business formal suit professional",
+        "休闲风": "casual comfortable relaxed",
+        "运动风": "sportswear athletic active",
+        "时尚潮流": "fashion trendy modern stylish", 
+        "复古风": "vintage retro classic",
+        "街头风": "streetwear urban hip",
+        "优雅风": "elegant sophisticated graceful"
+    }
+    
+    color_keywords = {
+        "深红色": "deep red burgundy",
+        "橙红色": "orange red coral",
+        "金黄色": "golden yellow amber",
+        "草绿色": "grass green olive",
+        "翠绿色": "emerald green jade",
+        "天蓝色": "sky blue azure",
+        "宝蓝色": "royal blue navy",
+        "紫色": "purple violet",
+        "深黑色": "deep black charcoal",
+        "纯白色": "pure white ivory",
+        "深灰色": "dark gray slate"
+    }
+    
+    fabric_keywords = {
+        "丝绸": "silk smooth luxurious",
+        "棉质": "cotton comfortable breathable",
+        "混纺": "blend modern synthetic",
+        "牛仔": "denim sturdy casual",
+        "毛呢": "wool warm textured"
+    }
+    
+    view_keywords = {
+        "正面设计图": "front view technical drawing fashion flat",
+        "背面设计图": "back view technical drawing fashion flat", 
+        "侧面设计图": "side view technical drawing fashion flat"
+    }
+    
+    # 构建英文提示词
+    style_eng = style_keywords.get(context["main_style"], "modern fashion")
+    color_eng = color_keywords.get(context["dominant_colors"][0] if context["dominant_colors"] else "", "neutral colors")
+    fabric_eng = fabric_keywords.get(context["fabric_type"], "quality fabric")
+    view_eng = view_keywords.get(view, "technical fashion drawing")
+    
+    # 专业服装设计提示词
+    prompt = (
+        f"{view_eng}, {style_eng} garment design, "
+        f"{color_eng} color scheme, {fabric_eng} material, "
+        f"clean fashion illustration, professional technical drawing, "
+        f"flat lay design, no model, clothing only, "
+        f"detailed stitching, precise proportions, "
+        f"fashion design sketch, minimalist background, "
+        f"high quality illustration, vector style"
+    )
+    
+    logger.info(f"{view}设计提示词: {prompt}")
+    return prompt
+
+def create_design_placeholder(view, width, height):
+    """创建设计占位图"""
+    img = Image.new('RGB', (width, height), color=(240, 240, 240))
+    draw = ImageDraw.Draw(img)
+    
+    # 绘制基本轮廓
+    if "正面" in view:
+        # 画一个基本的衣服正面轮廓
+        draw.rectangle([width//4, height//6, 3*width//4, 5*height//6], outline=(100, 100, 100), width=3)
+    elif "背面" in view:
+        # 画一个基本的衣服背面轮廓
+        draw.rectangle([width//4, height//6, 3*width//4, 5*height//6], outline=(120, 120, 120), width=3)
+    else:
+        # 侧面轮廓
+        draw.ellipse([width//3, height//6, 2*width//3, 5*height//6], outline=(140, 140, 140), width=3)
+    
+    # 添加文字
+    try:
+        font = ImageFont.load_default()
+        text = view
+        draw.text((width//2-50, height//2), text, fill=(80, 80, 80), font=font)
+    except:
+        pass
+    
+    return img
+
+def generate_3d_fitting_effect(selected_design_index, progress=gr.Progress()):
+    """生成专业3D试穿效果 - 标准模特展示"""
     try:
-        if not app_state.design_images or not app_state.current_image or selected_design_index is None:
+        if not design_state.generated_designs or selected_design_index is None:
             return None
         
-        progress(0.1, desc="准备3D试穿...")
+        design_state.selected_design_index = selected_design_index
         
-        # 获取选中的设计
-        selected_image = app_state.design_images[selected_design_index]
-        app_state.selected_design_index = selected_design_index
+        progress(0.1, desc="准备3D建模...")
         
-        # 基于原���图像和选择的设计创建3D试穿提示词
-        fitting_prompt = create_3d_fitting_prompt(
-            selected_design_index, 
-            app_state.current_analysis
-        )
+        # 获取设计上下文和选中的设计
+        context = design_state.get_design_context()
+        selected_design = design_state.generated_designs[selected_design_index]
+        
+        progress(0.3, desc="构建3D试穿场景...")
+        
+        # 创建专业3D试穿提示词
+        fitting_prompt = create_3d_fitting_prompt(context, selected_design_index)
         
-        progress(0.3, desc="生成3D模型...")
+        progress(0.5, desc="AI 3D渲染中...")
         
-        # 使用更精细的3D模型
         try:
-            # 使用专门的3D试穿模型
-            image = model_manager.generate_controlnet_image(
-                image=app_state.current_image,  # 使用原始图像作为控制
+            # 使用ControlNet生成高质量3D试穿效果
+            fitting_image = model_manager.generate_controlnet_image(
+                image=design_state.original_image,
                 prompt=fitting_prompt,
-                reference_image=selected_image,  # 设计风格参考
-                negative_prompt="blurry, distorted, low quality, unrealistic, extra limbs, deformed",
-                num_inference_steps=40,  # 更多步骤以获得更高质量
+                reference_image=selected_design,
+                negative_prompt="blurry, distorted, low quality, unrealistic, extra limbs, deformed, bad anatomy, text, watermark, multiple people",
+                num_inference_steps=40,
                 guidance_scale=8.5
             )
+            
             progress(0.9, desc="完成3D渲染")
+            design_state.fitting_result = fitting_image
             logger.info("使用ControlNet生成3D试穿效果")
-            return image
+            return fitting_image
+            
         except Exception as e:
-            logger.warning(f"3D模型生成失败: {e}")
-        
-        # 回退到普通模型
-        progress(0.5, desc="使用标准模型生成...")
-        try:
-            image = model_manager.generate_image(
+            logger.warning(f"ControlNet 3D试穿失败: {e}")
+            # 回退到标准模型
+            progress(0.6, desc="使用标准模型生成...")
+            fitting_image = model_manager.generate_image(
                 prompt=fitting_prompt,
-                negative_prompt="blurry, distorted, low quality, unrealistic, extra limbs, deformed, bad anatomy",
+                negative_prompt="blurry, distorted, low quality, unrealistic, extra limbs, deformed, bad anatomy, multiple people",
                 num_inference_steps=35,
                 width=512,
                 height=768,
-                guidance_scale=7.5
+                guidance_scale=8.0
             )
-        except Exception as e:
-            logger.error(f"3D试穿生成失败: {e}")
-            image = create_placeholder_image(512, 768)
-        
-        progress(0.9, desc="完成3D渲染")
-        return image
+            
+            progress(0.9, desc="完成渲染")
+            design_state.fitting_result = fitting_image
+            return fitting_image
         
     except Exception as e:
-        logger.error(f"3D试穿生成错误: {e}")
-        return create_placeholder_image(512, 768)
+        logger.error(f"3D试穿生成失败: {e}")
+        return create_fitting_placeholder()
 
-def create_design_prompt(suggestion, analysis):
-    """创建详细的设计提示词 - 整合所有分析结果"""
+def create_3d_fitting_prompt(context, design_index):
+    """创建3D试穿提示词 - 英文避免token截断"""
+    
+    # 风格关键词映射
+    style_keywords = {
+        "商务正装": "professional business attire formal suit",
+        "休闲风": "casual comfortable everyday wear",
+        "运动风": "athletic sportswear activewear",
+        "时尚潮流": "fashion forward trendy modern",
+        "复古风": "vintage retro classic style",
+        "街头风": "streetwear urban contemporary",
+        "优雅风": "elegant sophisticated refined"
+    }
+    
+    color_keywords = {
+        "深红色": "deep red burgundy rich",
+        "橙红色": "coral orange warm",
+        "金黄色": "golden amber bright",
+        "草绿色": "olive green natural",
+        "翠绿色": "emerald jade vibrant",
+        "天蓝色": "sky blue light",
+        "宝蓝色": "royal navy deep",
+        "紫色": "purple violet",
+        "深黑色": "black charcoal dark",
+        "纯白色": "white clean pure",
+        "深灰色": "charcoal slate gray"
+    }
+    
+    fabric_keywords = {
+        "丝绸": "silk luxurious smooth draping",
+        "棉质": "cotton comfortable natural texture",
+        "混纺": "modern blend synthetic comfort",
+        "牛仔": "denim sturdy casual texture",
+        "毛呢": "wool textured warm sophisticated"
+    }
+    
+    # 获取英文关键词
+    style_eng = style_keywords.get(context["main_style"], "modern fashion")
+    color_eng = color_keywords.get(context["dominant_colors"][0] if context["dominant_colors"] else "", "neutral tones")
+    fabric_eng = fabric_keywords.get(context["fabric_type"], "quality fabric")
+    
+    # 构建3D试穿提示词
+    prompt = (
+        f"professional 3D fashion model wearing {style_eng}, "
+        f"{color_eng} color scheme, {fabric_eng} material, "
+        f"full body pose, studio lighting, clean background, "
+        f"high quality 3D render, realistic fabric texture, "
+        f"perfect fit tailoring, fashion photography style, "
+        f"detailed clothing construction, professional modeling"
+    )
+    
+    logger.info(f"3D试穿提示词: {prompt}")
+    return prompt
+
+def create_fitting_placeholder():
+    """创建3D试穿占位图"""
+    img = Image.new('RGB', (512, 768), color=(245, 245, 245))
+    draw = ImageDraw.Draw(img)
+    
+    # 画一个基本的人体轮廓
+    # 头部
+    draw.ellipse([206, 50, 306, 150], outline=(150, 150, 150), width=2)
+    # 身体
+    draw.rectangle([226, 150, 286, 400], outline=(150, 150, 150), width=2)
+    # 手臂
+    draw.rectangle([186, 170, 226, 350], outline=(150, 150, 150), width=2)
+    draw.rectangle([286, 170, 326, 350], outline=(150, 150, 150), width=2)
+    # 腿部
+    draw.rectangle([236, 400, 266, 650], outline=(150, 150, 150), width=2)
+    draw.rectangle([266, 400, 296, 650], outline=(150, 150, 150), width=2)
+    
+    # 添加文字
     try:
-        # 从分析中提取关键信息
-        style_info = analysis.get("主要风格", "时尚")
-        colors = analysis.get("主要颜色", ["现代色"])
-        caption = analysis.get("图像描述", "")
-        
-        # 获取风格描述
-        style_prompts = {
-            "商务正装": "专业商务装，正式西装，简洁线条，精致剪裁",
-            "休闲风": "休闲服装，舒适风格，日常穿着，宽松合身",
-            "运动风": "运动服装，功能性设计，运动休闲",
-            "时尚潮流": "时尚潮流，现代设计，高级时装",
-            "复古风": "复古风格，怀旧元素，经典设计",
-            "街头风": "街头服饰，都市风格，现代青年文化",
-            "优雅风": "优雅服装，精致风格，高贵设计"
-        }
-        
-        style_prompt = style_prompts.get(style_info, "时尚服装，现代设计")
-        
-        # 颜色描述
-        color_prompt = f"主色调: {colors[0] if colors else '现代色调'}"
-        if len(colors) > 1:
-            color_prompt += f", 辅色: {colors[1]}"
-        
-        # 根据建议调整提示词
-        suggestion_modifiers = {
-            "经典": "经典设计，永恒风格，传统元素",
-            "现代": "现代美学，创新设计，前沿时尚",
-            "时尚": "时尚前沿，T台风格，潮流趋势",
-            "个性": "独特设计，个性化元素，定制风格"
-        }
-        
-        modifier = "高品质，精心设计，时尚风格"
-        for key, value in suggestion_modifiers.items():
-            if key in suggestion:
-                modifier = value
-                break
-        
-        # 组合完整的提示词 - 整合所有分析元素
-        full_prompt = (
-            f"{style_prompt}，{color_prompt}，{modifier}。"
-            f"设计灵感来源：'{caption}'。"
-            f"高清细节，专业时尚摄影，工作室灯光"
-        )
-        
-        logger.info(f"生成的设计提示词: {full_prompt}")
-        return full_prompt
-        
-    except Exception as e:
-        logger.error(f"创建提示词失败: {e}")
-        return "时尚服装设计，高品质，专业时尚"
+        font = ImageFont.load_default()
+        draw.text((200, 380), "3D Fitting", fill=(100, 100, 100), font=font)
+    except:
+        pass
+    
+    return img
 
-def create_3d_fitting_prompt(design_index, analysis):
-    """创建3D试穿的提示词 - 整合所有分析结果"""
+def export_design_report():
+    """导出完整的设计报告"""
+    if not design_state.original_image:
+        return "没有设计数据可导出"
+    
     try:
-        style_info = analysis.get("主要风格", "时尚")
-        colors = analysis.get("主要颜色", ["现代色"])
-        caption = analysis.get("图像描述", "")
-        
-        # 获取设计描述
-        design_desc = f"设计方案 {design_index+1}"
-        
-        # 3D试穿基础提示词
-        base_prompt = "高精度3D虚拟试穿，真实人体模特穿着"
-        
-        # 添加风格和颜色信息
-        style_desc = f"{style_info}风格服装"
-        color_desc = f"主色调: {colors[0] if colors else '时尚色调'}"
-        
-        # 完整的3D试穿提示词
-        full_prompt = (
-            f"{base_prompt} {style_desc}，{color_desc}。"
-            f"全身展示，专业工作室灯光，高质量3D渲染，"
-            f"真实面料质感，合身剪裁，高清细节。"
-            f"设��灵感：'{caption}'。"
-            f"具体设计：{design_desc}"
-        )
+        context = design_state.get_design_context()
+        
+        report = {
+            "设计项目报告": {
+                "生成时间": time.strftime("%Y-%m-%d %H:%M:%S"),
+                "项目概述": {
+                    "设计描述": context["caption"],
+                    "设计方向": context["design_direction"],
+                    "主要风格": context["main_style"]
+                },
+                "色彩分析": {
+                    "主色调": context["dominant_colors"],
+                    "配色方案": design_state.color_analysis.get("color_harmony", ""),
+                    "季节特征": design_state.color_analysis.get("season_analysis", ""),
+                    "情感表达": design_state.color_analysis.get("color_palette", {}).get("颜色1", {}).get("emotion", "")
+                },
+                "材质分析": {
+                    "面料类型": context["fabric_type"],
+                    "质地特征": design_state.fabric_analysis.get("texture", ""),
+                    "材质特性": design_state.fabric_analysis.get("fabric_properties", "")
+                },
+                "设计建议": {
+                    "选择方向": design_state.design_direction,
+                    "设计理念": f"基于{context['main_style']}风格，运用{context['dominant_colors'][0] if context['dominant_colors'] else '经典'}色调"
+                }
+            }
+        }
         
-        logger.info(f"3D试穿提示词: {full_prompt}")
-        return full_prompt
+        return json.dumps(report, ensure_ascii=False, indent=2)
         
     except Exception as e:
-        logger.error(f"创建3D提示词失败: {e}")
-        return "高精度3D虚拟时尚试穿，真实人体模特，全身展示，工作室灯光"
-
-def create_placeholder_image(width, height):
-    """创建占位图像 - 修复语法错误"""
-    color = (random.randint(120, 200), random.randint(120, 200), random.randint(120, 200))
-    return Image.new('RGB', (width, height), color=color)
+        return f"报告生成失败: {str(e)}"
 
 def create_gradio_interface():
-    """创建Gradio用户界面"""
+    """创建改进的Gradio界面"""
     
-    with gr.Blocks(title="AI时尚设计师", theme="soft") as demo:
-        gr.Markdown("# 🎨 AI时尚设计师")
-        gr.Markdown("上传服装图片，AI将分析风格并生成个性化设计方案和3D试穿效果")
+    with gr.Blocks(title="AI时尚设计师 Pro", theme="soft") as demo:
+        gr.Markdown("# 🎨 AI时尚设计师 Pro")
+        gr.Markdown("**专业AI驱动的服装设计平台** - 深度分析、智能设计、3D试穿")
         
         with gr.Row():
             with gr.Column(scale=1):
-                image_input = gr.Image(type="filepath", label="上传参考图片", height=400)
-                analyze_btn = gr.Button("🔍 AI智能分析", variant="primary", size="lg")
+                image_input = gr.Image(type="filepath", label="📸 上传服装参考图", height=400)
+                analyze_btn = gr.Button("🔍 AI深度分析", variant="primary", size="lg")
+                
+                # 分析结果展示
+                with gr.Accordion("📊 详细分析报告", open=False):
+                    analysis_output = gr.JSON(label="综合分析结果")
             
             with gr.Column(scale=2):
-                analysis_output = gr.JSON(label="🎯 AI分析结果")
-        
-        with gr.Tab("💡 设计建议"):
-            suggestions_output = gr.JSON(label="个性化设计建议")
-            suggestion_choice = gr.Radio(label="选择设计方向", interactive=True)
-            generate_designs_btn = gr.Button("🎨 生成设计方案", variant="primary")
-        
-        with gr.Tab("👔 样衣设计"):
-            designs_gallery = gr.Gallery(label="AI生成的设计方案", columns=3, height=400)
-            design_choice = gr.Radio(label="选择设计方案", type="index", interactive=True)
-            generate_3d_btn = gr.Button("🎭 生成3D试穿效果", variant="primary")
-        
-        with gr.Tab("👤 3D试穿效果"):
-            fitting_result = gr.Image(label="3D试穿效果", height=600)
-            
-        # 系统状态和控制
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### 🔧 系统控制")
-                cleanup_btn = gr.Button("🧹 清理显存缓存", variant="secondary")
-                cpu_btn = gr.Button("💾 模型移至CPU", variant="secondary") 
-                gpu_btn = gr.Button("🚀 模型移至GPU", variant="secondary")
-                reload_btn = gr.Button("🔄 重新加载模型", variant="primary")
-                gr.Markdown("""
-                > **使用说明**: 
-                > - **清理显存缓存**: 只清理缓存，不影响模型
-                > - **模型移至CPU**: 释放GPU显存，但推理会变慢
-                > - **模型移至GPU**: 将模型移回GPU，恢复正常速度
-                > - **重新加载模型**: 如果模型出现问题，强制重新加载
-                """)
+                # 设计建议标签页
+                with gr.Tab("💡 智能设计建议"):
+                    suggestions_output = gr.JSON(label="🎯 基于AI分析的个性化建议")
+                    suggestion_choice = gr.Radio(label="🎨 选择设计方向", interactive=True)
+                    generate_designs_btn = gr.Button("✨ 生成专业设计图", variant="primary", size="lg")
+                
+                # 设计图标签页
+                with gr.Tab("👔 专业设计图"):
+                    gr.Markdown("**服装设计三视图** - 正面/背面/侧面专业技术图")
+                    designs_gallery = gr.Gallery(label="AI生成的专业设计图", columns=3, height=500)
+                    design_choice = gr.Radio(label="🎯 选择设计方案", type="index", interactive=True)
+                    generate_3d_btn = gr.Button("🎭 生成3D试穿效果", variant="primary", size="lg")
+                
+                # 3D试穿标签页
+                with gr.Tab("🎭 3D虚拟试穿"):
+                    gr.Markdown("**专业3D试穿展示** - 标准模特效果图")
+                    fitting_result = gr.Image(label="3D虚拟试穿效果", height=600)
+                    
+                    with gr.Row():
+                        export_btn = gr.Button("📄 导出设计报告", variant="secondary")
+                        reset_btn = gr.Button("🔄 重置项目", variant="secondary")
+                
+                # 导出结果
+                with gr.Tab("📋 设计报告"):
+                    report_output = gr.Textbox(label="完整设计报告", lines=20, max_lines=30)
+        
+        # 系统控制面板
+        with gr.Accordion("🔧 系统控制面板", open=False):
+            with gr.Row():
+                cleanup_btn = gr.Button("🧹 清理显存", variant="secondary")
+                cpu_btn = gr.Button("💾 模型→CPU", variant="secondary")
+                gpu_btn = gr.Button("🚀 模型→GPU", variant="secondary")
+                reload_btn = gr.Button("🔄 重载模型", variant="primary")
             
-        # 事件绑定 - 完整的流水线连接
+            gr.Markdown("""
+            **系统优化说明**：
+            - 🧹 清理显存：清理GPU缓存，不影响模型
+            - 💾 模型→CPU：释放GPU显存，推理速度会降低
+            - 🚀 模型→GPU：恢复GPU加速，提升生成速度
+            - 🔄 重载模型：强制重新加载所有AI模型
+            """)
+        
+        # 事件绑定 - 完整工作流程
         analyze_btn.click(
-            fn=upload_and_analyze,
+            fn=comprehensive_image_analysis,
             inputs=[image_input],
             outputs=[analysis_output, suggestions_output, suggestion_choice, designs_gallery]
         )
         
         generate_designs_btn.click(
-            fn=generate_designs,
+            fn=generate_professional_designs,
             inputs=[suggestion_choice],
             outputs=[designs_gallery, design_choice]
         )
         
         generate_3d_btn.click(
-            fn=generate_3d_fitting,
+            fn=generate_3d_fitting_effect,
             inputs=[design_choice],
             outputs=[fitting_result]
         )
         
-        cleanup_btn.click(
-            fn=model_manager.cleanup,
+        export_btn.click(
+            fn=export_design_report,
             inputs=[],
-            outputs=[]
+            outputs=[report_output]
         )
         
-        cpu_btn.click(
-            fn=model_manager.move_models_to_cpu,
+        reset_btn.click(
+            fn=lambda: (design_state.reset(), {}, {}, gr.Radio(choices=[]), gr.Gallery(value=[]), None, ""),
             inputs=[],
-            outputs=[]
+            outputs=[analysis_output, suggestions_output, suggestion_choice, designs_gallery, fitting_result, report_output]
         )
         
-        gpu_btn.click(
-            fn=model_manager.move_models_to_gpu,
-            inputs=[],
-            outputs=[]
-        )
-        
-        reload_btn.click(
-            fn=model_manager.force_reload_all_models,
-            inputs=[],
-            outputs=[]
-        )
+        # 系统控制
+        cleanup_btn.click(fn=model_manager.cleanup, inputs=[], outputs=[])
+        cpu_btn.click(fn=model_manager.move_models_to_cpu, inputs=[], outputs=[])
+        gpu_btn.click(fn=model_manager.move_models_to_gpu, inputs=[], outputs=[])
+        reload_btn.click(fn=model_manager.force_reload_all_models, inputs=[], outputs=[])
         
-        # 添加使用说明
-        with gr.Row():
+        # 使用指南
+        with gr.Accordion("📖 专业使用指南", open=False):
             gr.Markdown("""
-            ### 📋 使用流程:
-            1. **上传图片** → 点击"AI智能分析"进行风格识别
-            2. **查看建议** → 在"设计建议"标签中选择��仪的设计方向
-            3. **生成设计** → 点击"生成设计方案"查看AI设计的服装
-            4. **3D试穿** → 选择喜欢的设计，点击"生成3D试穿效果"
+            ## 🚀 完整工作流程
             
-            💡 **提示**: 
-            - 每一步都会调用相应的AI模型，请耐心等待生成完成
-            - 使用ControlNet模型生成高质量的3D试穿效果
-            - 所有设计都基于原始图片的分析结果
-            - 如果遇到模型问题，可以使用下方的系统控制按钮
+            ### 第一步：AI深度分析
+            1. 上传高清服装参考图片
+            2. 点击"AI深度分析"进行多维度智能分析
+            3. 查看详细的风格、颜色、材质分析报告
+            
+            ### 第二步：选择设计方向  
+            1. 在"智能设计建议"中查看个性化建议
+            2. 基于AI分析结果选择最符合需求的设计方向
+            3. 建议会整合风格、色彩、材质等所有分析维度
+            
+            ### 第三步：生成专业设计
+            1. 点击"生成专业设计图"获取三视图
+            2. 包含正面、背面、侧面的专业技术图
+            3. 所有设计都基于前期分析结果，确保一致性
+            
+            ### 第四步：3D虚拟试穿
+            1. 选择心仪的设计方案
+            2. 生成标准模特的3D试穿效果
+            3. 展示真实的着装效果和服装细节
+            
+            ### 第五步：导出设计报告
+            1. 获取完整的项目设计报告
+            2. 包含所有分析数据和设计决策依据
+            3. 支持进一步的设计开发和制作
+            
+            ## 💡 专业建议
+            - **图片质量**：使用高分辨率、光线良好的服装图片
+            - **分析准确性**：让AI完整分析后再进行设计选择
+            - **设计连贯性**：所有生成内容都基于初始分析，确保风格统一
+            - **3D效果**：基于ControlNet技术，提供专业级试穿展示
             """)
     
     return demo
 
 if __name__ == "__main__":
-    # 检查环境
     logger.info(f"Python版本: {sys.version}")
     logger.info(f"当前工作目录: {os.getcwd()}")
     logger.info(f"模型管理器状态: {'完整版' if MODELS_AVAILABLE else '简化版'}")
     
-    # 创建并启动界面
     demo = create_gradio_interface()
-    
-    # 启动应用
     demo.launch(
-        server_name="0.0.0.0", 
+        server_name="0.0.0.0",
         server_port=7860,
         share=False,
         show_error=True,
-        max_threads=2
+        max_threads=4  # 增加线程数支持并发
     )