Add chat editing + 3D preview + updated models

app.py

@@ -1,31 +1,12 @@
 """
-Garment Image → 2D Sewing Pattern Demo
-
-Uses modern VLMs (via HF Inference Providers) to analyze garment images and extract
-structured parameters, then generates flat 2D sewing pattern pieces.
-
-Models (verified working April 2026):
-- Qwen/Qwen3.5-9B via Together AI (primary)
-- google/gemma-4-31B-it via Together AI (Gemma 4)
-- moonshotai/Kimi-K2.5 via Together AI (fallback)
-
-Approach inspired by:
-- ChatGarment (arxiv:2412.17811): VLM → JSON → GarmentCode → 2D patterns
-- NGL-Prompter (arxiv:2602.20700): Training-free VLM → semantic params → patterns
+Garment Image -> 2D Sewing Pattern + Chat Editing + 3D Preview
 """
-
-import json
-import os
-import re
-import traceback
-from typing import Dict, Optional, Tuple
-
+import json, os, re, traceback, copy
+from typing import Dict, Optional, Tuple, List
 import gradio as gr
 from PIL import Image
-
-from pattern_generator import generate_pattern_from_analysis, get_pattern_pieces, render_pattern_pieces
-
-# ── VLM Analysis ──
+from pattern_generator import generate_pattern_from_analysis
+from garment_3d import create_3d_figure
 
 GARMENT_ANALYSIS_PROMPT = """You are a professional fashion pattern maker. Analyze this garment image and extract precise sewing pattern parameters.
 
@@ -35,440 +16,311 @@ Return ONLY a JSON object (no markdown, no explanation) with this exact structur
   "garment_type": "<one of: shirt, blouse, top, t-shirt, dress, skirt, pants, trousers, jeans, jacket, coat, blazer, hoodie, vest>",
   "description": "<brief description of the garment style, fit, and key features>",
   "measurements": {
-    "bust": <number 75-130, estimated bust circumference in cm>,
-    "waist": <number 55-110, estimated waist circumference in cm>,
-    "hip": <number 80-130, estimated hip circumference in cm>,
-    "shoulder_width": <number 35-55, shoulder width in cm>,
-    "bodice_length": <number 35-75, from shoulder to waist/hem for tops>,
-    "sleeve_length": <number 15-75, sleeve length in cm, 15=cap sleeve, 25=short, 45=3/4, 60-70=long>,
-    "skirt_length": <number 30-120, for skirts/dresses: 30=mini, 55=knee, 80=midi, 110=maxi>,
-    "pant_length": <number 30-110, for pants: 30=shorts, 70=cropped, 100=full>,
-    "neckline_depth": <number 3-25, how deep the neckline is>,
-    "neckline_width": <number 5-15, how wide the neckline opening is>,
-    "bicep": <number 25-45, bicep circumference>,
-    "wrist": <number 15-25, wrist circumference>,
-    "cap_height": <number 8-18, sleeve cap height>,
-    "collar_height": <number 3-10, if collar present>,
-    "flare": <number 0-15, extra hem width for A-line/flared styles>
+    "bust": <number 75-130>, "waist": <number 55-110>, "hip": <number 80-130>,
+    "shoulder_width": <number 35-55>, "bodice_length": <number 35-75>,
+    "sleeve_length": <number 15-75>, "skirt_length": <number 30-120>,
+    "pant_length": <number 30-110>, "neckline_depth": <number 3-25>,
+    "neckline_width": <number 5-15>, "bicep": <number 25-45>,
+    "wrist": <number 15-25>, "cap_height": <number 8-18>,
+    "collar_height": <number 3-10>, "flare": <number 0-15>
   },
   "features": {
-    "has_collar": <true/false>,
-    "collar_type": "<standard, mandarin, peter_pan, or none>",
-    "has_cuffs": <true/false>,
-    "has_pockets": <true/false>,
-    "pocket_type": "<patch, welt, or none>",
-    "has_hood": <true/false>,
-    "fit": "<fitted, regular, oversized, or loose>"
+    "has_collar": <true/false>, "collar_type": "<standard/mandarin/peter_pan/none>",
+    "has_cuffs": <true/false>, "has_pockets": <true/false>,
+    "pocket_type": "<patch/welt/none>", "has_hood": <true/false>,
+    "fit": "<fitted/regular/oversized/loose>"
   }
 }
 
-Be precise with the garment type. Estimate realistic measurements for an average adult body.
-Only include measurements relevant to the garment type (e.g., skip pant_length for a shirt).
+Be precise. Estimate realistic measurements in cm for an average adult.
+Only include measurements relevant to the garment type.
 """
 
-# Model configurations: (model_id, provider, display_name)
-# Verified working via HF Inference Providers (April 2026)
-VISION_MODELS = [
-    ("Qwen/Qwen3.5-9B", "together", "Qwen 3.5 9B"),
-    ("google/gemma-4-31B-it", "together", "Gemma 4 31B"),
-    ("moonshotai/Kimi-K2.5", "together", "Kimi K2.5"),
-]
+EDIT_PROMPT_TEMPLATE = """You are a fashion pattern editing assistant. The user wants to edit their garment pattern.
+
+Current pattern parameters:
+{current_json}
+
+User request: {user_message}
+
+Apply the edit and return ONLY the complete updated JSON (no markdown, no explanation) with the same structure. Keep all unchanged values the same. Only modify what the user asked to change.
 
-TEXT_MODELS = [
+{{
+  "garment_type": "<type>",
+  "description": "<updated description>",
+  "measurements": {{
+    "bust": <number>, "waist": <number>, "hip": <number>,
+    "shoulder_width": <number>, "bodice_length": <number>,
+    "sleeve_length": <number>, "skirt_length": <number>,
+    "pant_length": <number>, "neckline_depth": <number>,
+    "neckline_width": <number>, "bicep": <number>, "wrist": <number>,
+    "cap_height": <number>, "collar_height": <number>, "flare": <number>
+  }},
+  "features": {{
+    "has_collar": <bool>, "collar_type": "<type>",
+    "has_cuffs": <bool>, "has_pockets": <bool>,
+    "pocket_type": "<type>", "has_hood": <bool>,
+    "fit": "<type>"
+  }}
+}}"""
+
+VISION_MODELS = [
     ("Qwen/Qwen3.5-9B", "together", "Qwen 3.5 9B"),
     ("google/gemma-4-31B-it", "together", "Gemma 4 31B"),
     ("moonshotai/Kimi-K2.5", "together", "Kimi K2.5"),
 ]
+TEXT_MODELS = VISION_MODELS
 
-
-def _extract_response_text(message: dict) -> str:
-    """
-    Extract text from a model response message.
-    
-    Newer models (Qwen3.5, Gemma4) use 'reasoning' field for chain-of-thought
-    and 'content' for the final answer. We prefer 'content' when non-empty.
-    """
+def _extract_response_text(message):
     content = message.get('content', '') or ''
     reasoning = message.get('reasoning', '') or ''
-    
-    # Prefer content (final answer) over reasoning
     if content.strip():
         return content.strip()
     if reasoning.strip():
         return reasoning.strip()
     return ''
 
-
-def _extract_json_from_text(text: str) -> Optional[str]:
-    """Extract JSON object from text that may contain markdown or other wrappers."""
-    # Try markdown code block first
+def _extract_json_from_text(text):
     json_match = re.search(r'```(?:json)?\s*([\s\S]*?)\s*```', text)
     if json_match:
         return json_match.group(1)
-    
-    # Try raw JSON object
     json_match = re.search(r'\{[\s\S]*\}', text)
     if json_match:
         return json_match.group()
-    
     return None
 
-
-def analyze_with_vlm(image: Image.Image) -> Dict:
-    """
-    Analyze garment image using modern VLMs via HF Inference Providers.
-    
-    Tries models in priority order:
-    1. Qwen 3.5 9B (fast, good structured output)
-    2. Gemma 4 31B (Google, strong vision)
-    3. Kimi K2.5 (Moonshot AI, good general VLM)
-    """
-    import requests
-    import base64
+def _call_vlm(messages, timeout=180):
+    """Call a VLM model via HF Inference Providers."""
+    import requests, base64
     from io import BytesIO
-    
     hf_token = os.environ.get("HF_TOKEN", "")
     if not hf_token:
         return None
-    
-    # Resize image if too large (save bandwidth & speed)
-    max_dim = 1024
-    if max(image.size) > max_dim:
-        ratio = max_dim / max(image.size)
-        new_size = (int(image.size[0] * ratio), int(image.size[1] * ratio))
-        image = image.resize(new_size, Image.LANCZOS)
-    
-    buf = BytesIO()
-    image_rgb = image.convert('RGB')
-    image_rgb.save(buf, format='JPEG', quality=85)
-    img_b64 = base64.b64encode(buf.getvalue()).decode('utf-8')
-    
     for model_id, provider, display_name in VISION_MODELS:
         try:
             url = f"https://router.huggingface.co/{provider}/v1/chat/completions"
-            headers = {
-                "Authorization": f"Bearer {hf_token}",
-                "Content-Type": "application/json"
-            }
-            
-            payload = {
-                "model": model_id,
-                "messages": [{
-                    "role": "user",
-                    "content": [
-                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img_b64}"}},
-                        {"type": "text", "text": GARMENT_ANALYSIS_PROMPT}
-                    ]
-                }],
-                "max_tokens": 2000,
-                "temperature": 0.1,
-            }
-            
-            print(f"[VLM] Trying {display_name} ({model_id}) via {provider}...")
-            response = requests.post(url, headers=headers, json=payload, timeout=180)
-            
+            headers = {"Authorization": f"Bearer {hf_token}", "Content-Type": "application/json"}
+            payload = {"model": model_id, "messages": messages, "max_tokens": 2000, "temperature": 0.1}
+            print(f"[VLM] Trying {display_name} via {provider}...")
+            response = requests.post(url, headers=headers, json=payload, timeout=timeout)
             if response.status_code == 200:
                 result = response.json()
-                message = result['choices'][0]['message']
-                text = _extract_response_text(message)
-                
+                text = _extract_response_text(result['choices'][0]['message'])
                 if not text:
-                    print(f"[VLM] {display_name}: empty response")
                     continue
-                
                 json_str = _extract_json_from_text(text)
                 if not json_str:
-                    print(f"[VLM] {display_name}: no JSON found in response")
                     continue
-                
                 analysis = json.loads(json_str)
-                analysis['_model_used'] = f"{display_name} ({model_id})"
-                print(f"[VLM] ✅ {display_name}: detected '{analysis.get('garment_type', '?')}'")
+                analysis['_model_used'] = f"{display_name}"
+                print(f"[VLM] OK: {display_name} detected {analysis.get('garment_type','?')}")
                 return analysis
             else:
                 print(f"[VLM] {display_name}: HTTP {response.status_code}")
-                
-        except json.JSONDecodeError as e:
-            print(f"[VLM] {display_name}: JSON parse error: {e}")
-            continue
-        except requests.exceptions.Timeout:
-            print(f"[VLM] {display_name}: timeout (180s)")
-            continue
         except Exception as e:
             print(f"[VLM] {display_name} failed: {e}")
             continue
-    
     return None
 
+def analyze_with_vlm(image):
+    import base64
+    from io import BytesIO
+    hf_token = os.environ.get("HF_TOKEN", "")
+    if not hf_token:
+        return None
+    max_dim = 1024
+    if max(image.size) > max_dim:
+        ratio = max_dim / max(image.size)
+        image = image.resize((int(image.size[0]*ratio), int(image.size[1]*ratio)), Image.LANCZOS)
+    buf = BytesIO()
+    image.convert('RGB').save(buf, format='JPEG', quality=85)
+    img_b64 = base64.b64encode(buf.getvalue()).decode('utf-8')
+    messages = [{"role": "user", "content": [
+        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img_b64}"}},
+        {"type": "text", "text": GARMENT_ANALYSIS_PROMPT}
+    ]}]
+    return _call_vlm(messages)
 
-def get_default_analysis(garment_type: str = "shirt") -> Dict:
-    """Return default analysis when VLM is unavailable."""
+def get_default_analysis(garment_type="shirt"):
     defaults = {
-        "shirt": {
-            "garment_type": "shirt",
-            "description": "Standard button-up shirt with collar and long sleeves",
-            "measurements": {
-                "bust": 96, "waist": 80, "shoulder_width": 44,
-                "bodice_length": 72, "sleeve_length": 62,
-                "neckline_depth": 8, "neckline_width": 7,
-                "bicep": 32, "wrist": 18, "cap_height": 14,
-                "collar_height": 4, "flare": 0
-            },
-            "features": {
-                "has_collar": True, "collar_type": "standard",
-                "has_cuffs": True, "has_pockets": True,
-                "pocket_type": "patch", "has_hood": False, "fit": "regular"
-            }
-        },
-        "dress": {
-            "garment_type": "dress",
-            "description": "A-line dress with fitted bodice and flared skirt",
-            "measurements": {
-                "bust": 90, "waist": 72, "hip": 96,
-                "shoulder_width": 40, "bodice_length": 42,
-                "sleeve_length": 25, "skirt_length": 55,
-                "neckline_depth": 12, "neckline_width": 8,
-                "bicep": 28, "wrist": 17, "cap_height": 12,
-                "flare": 8
-            },
-            "features": {
-                "has_collar": False, "collar_type": "none",
-                "has_cuffs": False, "has_pockets": False,
-                "pocket_type": "none", "has_hood": False, "fit": "fitted"
-            }
-        },
-        "pants": {
-            "garment_type": "pants",
-            "description": "Classic straight-leg trousers",
-            "measurements": {
-                "waist": 78, "hip": 98, "thigh": 56,
-                "knee": 40, "ankle": 26,
-                "pant_length": 100, "crotch_depth": 27,
-                "waistband_height": 4, "flare": 0
-            },
-            "features": {
-                "has_pockets": True, "pocket_type": "welt",
-                "has_collar": False, "has_hood": False, "fit": "regular"
-            }
-        },
-        "skirt": {
-            "garment_type": "skirt",
-            "description": "A-line knee-length skirt",
-            "measurements": {
-                "waist": 72, "hip": 96,
-                "skirt_length": 55, "waistband_height": 4,
-                "flare": 6
-            },
-            "features": {
-                "has_pockets": False, "has_collar": False,
-                "has_hood": False, "fit": "regular"
-            }
-        },
-        "jacket": {
-            "garment_type": "jacket",
-            "description": "Tailored blazer with notched collar",
-            "measurements": {
-                "bust": 100, "waist": 86, "shoulder_width": 46,
-                "jacket_length": 70, "sleeve_length": 62,
-                "neckline_depth": 15, "neckline_width": 9,
-                "bicep": 34, "wrist": 20, "cap_height": 15,
-                "collar_height": 6, "flare": 0
-            },
-            "features": {
-                "has_collar": True, "collar_type": "standard",
-                "has_cuffs": False, "has_pockets": True,
-                "pocket_type": "welt", "has_hood": False, "fit": "regular"
-            }
-        },
-        "hoodie": {
-            "garment_type": "hoodie",
-            "description": "Pullover hoodie with kangaroo pocket",
-            "measurements": {
-                "bust": 108, "waist": 100, "shoulder_width": 50,
-                "jacket_length": 68, "sleeve_length": 65,
-                "neckline_depth": 10, "neckline_width": 8,
-                "bicep": 36, "wrist": 22, "cap_height": 13,
-                "head_circumference": 57, "flare": 0
-            },
-            "features": {
-                "has_collar": False, "collar_type": "none",
-                "has_cuffs": True, "has_pockets": True,
-                "pocket_type": "patch", "has_hood": True, "fit": "oversized"
-            }
-        },
-        "vest": {
-            "garment_type": "vest",
-            "description": "Classic vest/waistcoat",
-            "measurements": {
-                "bust": 96, "waist": 80, "shoulder_width": 42,
-                "vest_length": 55, "neckline_depth": 18,
-                "neckline_width": 8, "flare": 0
-            },
-            "features": {
-                "has_collar": False, "has_cuffs": False,
-                "has_pockets": False, "has_hood": False, "fit": "fitted"
-            }
-        }
+        "shirt": {"garment_type":"shirt","description":"Standard button-up shirt","measurements":{"bust":96,"waist":80,"shoulder_width":44,"bodice_length":72,"sleeve_length":62,"neckline_depth":8,"neckline_width":7,"bicep":32,"wrist":18,"cap_height":14,"collar_height":4,"flare":0},"features":{"has_collar":True,"collar_type":"standard","has_cuffs":True,"has_pockets":True,"pocket_type":"patch","has_hood":False,"fit":"regular"}},
+        "dress": {"garment_type":"dress","description":"A-line dress","measurements":{"bust":90,"waist":72,"hip":96,"shoulder_width":40,"bodice_length":42,"sleeve_length":25,"skirt_length":55,"neckline_depth":12,"neckline_width":8,"bicep":28,"wrist":17,"cap_height":12,"flare":8},"features":{"has_collar":False,"collar_type":"none","has_cuffs":False,"has_pockets":False,"pocket_type":"none","has_hood":False,"fit":"fitted"}},
+        "pants": {"garment_type":"pants","description":"Straight-leg trousers","measurements":{"waist":78,"hip":98,"thigh":56,"knee":40,"ankle":26,"pant_length":100,"crotch_depth":27,"waistband_height":4,"flare":0},"features":{"has_pockets":True,"pocket_type":"welt","has_collar":False,"has_hood":False,"fit":"regular"}},
+        "skirt": {"garment_type":"skirt","description":"A-line knee skirt","measurements":{"waist":72,"hip":96,"skirt_length":55,"waistband_height":4,"flare":6},"features":{"has_pockets":False,"has_collar":False,"has_hood":False,"fit":"regular"}},
+        "jacket": {"garment_type":"jacket","description":"Tailored blazer","measurements":{"bust":100,"waist":86,"shoulder_width":46,"jacket_length":70,"sleeve_length":62,"neckline_depth":15,"neckline_width":9,"bicep":34,"wrist":20,"cap_height":15,"collar_height":6,"flare":0},"features":{"has_collar":True,"collar_type":"standard","has_cuffs":False,"has_pockets":True,"pocket_type":"welt","has_hood":False,"fit":"regular"}},
+        "hoodie": {"garment_type":"hoodie","description":"Pullover hoodie","measurements":{"bust":108,"waist":100,"shoulder_width":50,"jacket_length":68,"sleeve_length":65,"neckline_depth":10,"neckline_width":8,"bicep":36,"wrist":22,"cap_height":13,"head_circumference":57,"flare":0},"features":{"has_collar":False,"collar_type":"none","has_cuffs":True,"has_pockets":True,"pocket_type":"patch","has_hood":True,"fit":"oversized"}},
+        "vest": {"garment_type":"vest","description":"Classic vest","measurements":{"bust":96,"waist":80,"shoulder_width":42,"vest_length":55,"neckline_depth":18,"neckline_width":8,"flare":0},"features":{"has_collar":False,"has_cuffs":False,"has_pockets":False,"has_hood":False,"fit":"fitted"}},
     }
     return defaults.get(garment_type, defaults["shirt"])
 
+# Global state for current analysis
+_current_analysis = {"data": None}
 
-# ── Main App Functions ──
-
-def process_image(image: Optional[Image.Image], garment_type_override: str = "Auto-detect") -> Tuple:
-    """Main processing: analyze image → generate pattern."""
+def _generate_all_outputs(analysis):
+    """Generate 2D pattern, 3D figure, and summary from analysis."""
+    pattern_image, summary = generate_pattern_from_analysis(analysis)
+    fig_3d = create_3d_figure(analysis)
+    display = {k: v for k, v in analysis.items() if k != '_model_used'}
+    model_info = f"\n\n*AI: {analysis.get('_model_used', 'Default')}*" if analysis.get('_model_used') else ""
+    desc = analysis.get('description', 'No description')
+    summary = f"**Garment:** {desc}\n\n{summary}{model_info}"
+    return pattern_image, fig_3d, summary, json.dumps(display, indent=2)
+
+def process_image(image, garment_type_override="Auto-detect"):
     if image is None and garment_type_override == "Auto-detect":
-        return None, "Please upload a garment image or select a garment type.", "{}"
-    
+        return None, None, "Please upload a garment image or select a type.", "{}", []
     analysis = None
-    model_info = ""
-    
     if image is not None:
         try:
             analysis = analyze_with_vlm(image)
-            if analysis:
-                model_info = f"\n\n*🤖 Analysis by: {analysis.get('_model_used', 'VLM')}*"
         except Exception as e:
-            print(f"VLM analysis failed: {e}")
-            traceback.print_exc()
-    
+            print(f"VLM failed: {e}")
     if analysis is None:
-        if garment_type_override != "Auto-detect":
-            gt = garment_type_override.lower()
-        elif image is not None:
-            gt = "shirt"
-            model_info = "\n\n*⚠️ VLM analysis unavailable. Using default parameters. Set HF_TOKEN for AI-powered analysis.*"
-        else:
-            gt = "shirt"
+        gt = garment_type_override.lower() if garment_type_override != "Auto-detect" else "shirt"
         analysis = get_default_analysis(gt)
-    
+        if image is not None and garment_type_override == "Auto-detect":
+            analysis['_model_used'] = 'Default (set HF_TOKEN for AI)'
     if garment_type_override != "Auto-detect":
         analysis['garment_type'] = garment_type_override.lower()
-    
+    _current_analysis["data"] = copy.deepcopy(analysis)
     try:
-        pattern_image, summary = generate_pattern_from_analysis(analysis)
-        description = analysis.get('description', 'No description')
-        summary = f"**Garment:** {description}\n\n{summary}{model_info}"
-        display_analysis = {k: v for k, v in analysis.items() if k != '_model_used'}
-        return pattern_image, summary, json.dumps(display_analysis, indent=2)
+        p2d, p3d, summary, j = _generate_all_outputs(analysis)
+        return p2d, p3d, summary, j, []
     except Exception as e:
         traceback.print_exc()
-        return None, f"Error generating pattern: {str(e)}", "{}"
+        return None, None, f"Error: {e}", "{}", []
 
-
-def process_text_description(description: str) -> Tuple:
-    """Generate pattern from text description using VLM."""
-    import requests
-    
-    hf_token = os.environ.get("HF_TOKEN", "")
-    
+def process_text(description):
     if not description.strip():
-        return None, "Please enter a garment description.", "{}"
-    
-    # Try VLM-based analysis
+        return None, None, "Enter a description.", "{}", []
+    analysis = None
+    hf_token = os.environ.get("HF_TOKEN", "")
     if hf_token:
-        TEXT_PROMPT = f"""You are a professional fashion pattern maker. Based on this garment description, extract precise sewing pattern parameters.
+        messages = [{"role": "user", "content": f"""Based on this garment description, extract sewing pattern parameters.
 
 Description: {description}
 
-Return ONLY a JSON object (no markdown, no explanation) with this exact structure:
-
-{{
-  "garment_type": "<one of: shirt, blouse, top, t-shirt, dress, skirt, pants, trousers, jeans, jacket, coat, blazer, hoodie, vest>",
-  "description": "{description}",
-  "measurements": {{
-    "bust": <number>, "waist": <number>, "hip": <number>,
-    "shoulder_width": <number>, "bodice_length": <number>,
-    "sleeve_length": <number>, "skirt_length": <number>,
-    "pant_length": <number>, "neckline_depth": <number>,
-    "neckline_width": <number>, "bicep": <number>, "wrist": <number>,
-    "cap_height": <number>, "collar_height": <number>, "flare": <number>
-  }},
-  "features": {{
-    "has_collar": <true/false>, "collar_type": "<standard/mandarin/peter_pan/none>",
-    "has_cuffs": <true/false>, "has_pockets": <true/false>,
-    "pocket_type": "<patch/welt/none>", "has_hood": <true/false>,
-    "fit": "<fitted/regular/oversized/loose>"
-  }}
-}}
-
-Only include measurements relevant to the garment type. Use realistic values in cm."""
-
-        for model_id, provider, display_name in TEXT_MODELS:
-            try:
-                url = f"https://router.huggingface.co/{provider}/v1/chat/completions"
-                headers = {"Authorization": f"Bearer {hf_token}", "Content-Type": "application/json"}
-                payload = {
-                    "model": model_id,
-                    "messages": [{"role": "user", "content": TEXT_PROMPT}],
-                    "max_tokens": 2000, "temperature": 0.1
-                }
-                
-                print(f"[Text] Trying {display_name} via {provider}...")
-                response = requests.post(url, headers=headers, json=payload, timeout=90)
-                
-                if response.status_code == 200:
-                    message = response.json()['choices'][0]['message']
-                    text = _extract_response_text(message)
-                    json_str = _extract_json_from_text(text)
-                    
-                    if json_str:
-                        analysis = json.loads(json_str)
-                        pattern_image, summary = generate_pattern_from_analysis(analysis)
-                        summary += f"\n\n*🤖 Analysis by: {display_name} ({model_id})*"
-                        return pattern_image, summary, json.dumps(analysis, indent=2)
-                        
-            except Exception as e:
-                print(f"[Text] {display_name} failed: {e}")
-                continue
-    
-    # Fallback: keyword matching
-    desc_lower = description.lower()
-    for gt in ['hoodie', 'jacket', 'coat', 'blazer', 'dress', 'skirt', 'pants', 'trousers', 'jeans', 'vest', 'shirt', 'blouse', 'top']:
-        if gt in desc_lower:
-            analysis = get_default_analysis(gt)
+Return ONLY JSON with: garment_type, description, measurements (bust, waist, hip, shoulder_width, bodice_length, sleeve_length, skirt_length, pant_length, neckline_depth, neckline_width, bicep, wrist, cap_height, collar_height, flare), features (has_collar, collar_type, has_cuffs, has_pockets, pocket_type, has_hood, fit)."""}]
+        analysis = _call_vlm(messages, timeout=90)
+    if analysis is None:
+        desc_lower = description.lower()
+        for gt in ['hoodie','jacket','coat','blazer','dress','skirt','pants','trousers','jeans','vest','shirt','blouse','top']:
+            if gt in desc_lower:
+                analysis = get_default_analysis(gt)
+                analysis['description'] = description
+                break
+        if analysis is None:
+            analysis = get_default_analysis("shirt")
             analysis['description'] = description
-            pattern_image, summary = generate_pattern_from_analysis(analysis)
-            summary += "\n\n*Using default parameters (set HF_TOKEN for AI-powered analysis)*"
-            return pattern_image, summary, json.dumps(analysis, indent=2)
-    
-    analysis = get_default_analysis("shirt")
-    analysis['description'] = description
-    pattern_image, summary = generate_pattern_from_analysis(analysis)
-    summary += "\n\n*Could not detect garment type — defaulting to shirt*"
-    return pattern_image, summary, json.dumps(analysis, indent=2)
-
-
-def process_manual_params(
-    garment_type, bust, waist, hip, shoulder, bodice_len,
-    sleeve_len, skirt_len, pant_len, neckline_depth,
-    has_collar, collar_type, has_cuffs, has_pockets, has_hood, flare, fit
-):
-    """Generate pattern from manual parameter input."""
-    analysis = {
-        "garment_type": garment_type.lower(),
-        "description": f"Custom {garment_type.lower()} with manual measurements",
-        "measurements": {
-            "bust": bust, "waist": waist, "hip": hip,
-            "shoulder_width": shoulder, "bodice_length": bodice_len,
-            "sleeve_length": sleeve_len, "skirt_length": skirt_len,
-            "pant_length": pant_len, "neckline_depth": neckline_depth,
-            "neckline_width": 7, "bicep": 30, "wrist": 18,
-            "cap_height": 14, "collar_height": 5, "flare": flare,
-        },
-        "features": {
-            "has_collar": has_collar, "collar_type": collar_type.lower(),
-            "has_cuffs": has_cuffs, "has_pockets": has_pockets,
-            "pocket_type": "patch", "has_hood": has_hood,
-            "fit": fit.lower()
-        }
-    }
-    
-    pattern_image, summary = generate_pattern_from_analysis(analysis)
-    return pattern_image, summary, json.dumps(analysis, indent=2)
-
+    _current_analysis["data"] = copy.deepcopy(analysis)
+    try:
+        p2d, p3d, summary, j = _generate_all_outputs(analysis)
+        return p2d, p3d, summary, j, []
+    except Exception as e:
+        return None, None, f"Error: {e}", "{}", []
 
-# ── Gradio UI ──
+def process_manual(gt,bust,waist,hip,shoulder,bodice,sleeve,skirt,pant,neck,flare_c,collar,ctype,cuffs,pockets,hood,fit):
+    analysis = {"garment_type":gt.lower(),"description":f"Custom {gt.lower()}","measurements":{"bust":bust,"waist":waist,"hip":hip,"shoulder_width":shoulder,"bodice_length":bodice,"sleeve_length":sleeve,"skirt_length":skirt,"pant_length":pant,"neckline_depth":neck,"neckline_width":7,"bicep":30,"wrist":18,"cap_height":14,"collar_height":5,"flare":flare_c},"features":{"has_collar":collar,"collar_type":ctype.lower(),"has_cuffs":cuffs,"has_pockets":pockets,"pocket_type":"patch","has_hood":hood,"fit":fit.lower()}}
+    _current_analysis["data"] = copy.deepcopy(analysis)
+    try:
+        p2d, p3d, summary, j = _generate_all_outputs(analysis)
+        return p2d, p3d, summary, j, []
+    except Exception as e:
+        return None, None, f"Error: {e}", "{}", []
+
+def chat_edit(message, history):
+    """Chat-based pattern editing."""
+    if not message.strip():
+        return history, None, None, "Please enter an edit request.", "{}"
+    current = _current_analysis.get("data")
+    if current is None:
+        current = get_default_analysis("shirt")
+        _current_analysis["data"] = current
+    # Build edit prompt
+    current_clean = {k: v for k, v in current.items() if k != '_model_used'}
+    edit_prompt = EDIT_PROMPT_TEMPLATE.format(
+        current_json=json.dumps(current_clean, indent=2),
+        user_message=message
+    )
+    # Try VLM edit
+    updated = None
+    hf_token = os.environ.get("HF_TOKEN", "")
+    if hf_token:
+        messages = [{"role": "user", "content": edit_prompt}]
+        try:
+            updated = _call_vlm(messages, timeout=90)
+        except Exception as e:
+            print(f"Edit VLM failed: {e}")
+    if updated is None:
+        # Simple rule-based fallback for common edits
+        updated = copy.deepcopy(current)
+        msg_lower = message.lower()
+        if "long sleeve" in msg_lower or "longer sleeve" in msg_lower:
+            updated['measurements']['sleeve_length'] = 65
+        elif "short sleeve" in msg_lower or "shorter sleeve" in msg_lower:
+            updated['measurements']['sleeve_length'] = 25
+        if "no collar" in msg_lower or "remove collar" in msg_lower:
+            updated['features']['has_collar'] = False
+            updated['features']['collar_type'] = 'none'
+        if "add collar" in msg_lower:
+            updated['features']['has_collar'] = True
+            updated['features']['collar_type'] = 'standard'
+        if "add hood" in msg_lower or "hoodie" in msg_lower:
+            updated['features']['has_hood'] = True
+        if "no hood" in msg_lower or "remove hood" in msg_lower:
+            updated['features']['has_hood'] = False
+        if "add pocket" in msg_lower:
+            updated['features']['has_pockets'] = True
+            updated['features']['pocket_type'] = 'patch'
+        if "no pocket" in msg_lower or "remove pocket" in msg_lower:
+            updated['features']['has_pockets'] = False
+        if "oversized" in msg_lower or "loose" in msg_lower:
+            updated['features']['fit'] = 'oversized'
+            updated['measurements']['bust'] = updated['measurements'].get('bust', 96) + 10
+        if "fitted" in msg_lower or "slim" in msg_lower:
+            updated['features']['fit'] = 'fitted'
+        if "flare" in msg_lower or "a-line" in msg_lower:
+            updated['measurements']['flare'] = max(updated['measurements'].get('flare', 0), 8)
+        if "straight" in msg_lower:
+            updated['measurements']['flare'] = 0
+        if "mini" in msg_lower:
+            updated['measurements']['skirt_length'] = 30
+        if "midi" in msg_lower:
+            updated['measurements']['skirt_length'] = 80
+        if "maxi" in msg_lower:
+            updated['measurements']['skirt_length'] = 110
+        updated['_model_used'] = 'Rule-based edit'
+    # Preserve garment type unless explicitly changed
+    if 'garment_type' not in updated:
+        updated['garment_type'] = current.get('garment_type', 'shirt')
+    _current_analysis["data"] = copy.deepcopy(updated)
+    # Generate updated outputs
+    try:
+        p2d, p3d, summary, j = _generate_all_outputs(updated)
+    except Exception as e:
+        p2d, p3d, summary, j = None, None, f"Error: {e}", "{}"
+    # Build chat response
+    ai_msg = f"Applied edit: {message}\n\n"
+    changes = []
+    old_m = current.get('measurements', {})
+    new_m = updated.get('measurements', {})
+    old_f = current.get('features', {})
+    new_f = updated.get('features', {})
+    for k in set(list(old_m.keys()) + list(new_m.keys())):
+        ov, nv = old_m.get(k), new_m.get(k)
+        if ov != nv and ov is not None and nv is not None:
+            changes.append(f"  {k}: {ov} -> {nv}")
+    for k in set(list(old_f.keys()) + list(new_f.keys())):
+        ov, nv = old_f.get(k), new_f.get(k)
+        if ov != nv:
+            changes.append(f"  {k}: {ov} -> {nv}")
+    if changes:
+        ai_msg += "Changes:\n" + "\n".join(changes)
+    else:
+        ai_msg += "No changes detected."
+    history = history or []
+    history.append((message, ai_msg))
+    return history, p2d, p3d, summary, j
 
 CSS = """
 .main-header { text-align: center; margin-bottom: 20px; }
@@ -476,168 +328,155 @@ CSS = """
 .ref-box { padding: 10px; border-radius: 8px; background: #f8f8f8; border: 1px solid #e0e0e0; font-size: 0.85em; }
 """
 
-with gr.Blocks(css=CSS, title="Garment → 2D Sewing Pattern", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(css=CSS, title="Garment Pattern Studio", theme=gr.themes.Soft()) as demo:
     gr.HTML("""
     <div class="main-header">
-        <h1>🧵 Garment Image → 2D Sewing Pattern</h1>
+        <h1>Garment Pattern Studio</h1>
         <p style="font-size: 1.1em; color: #555;">
-            Upload a garment image or describe one — get flat 2D sewing pattern pieces
+            Analyze garments, edit with chat, preview in 3D
         </p>
     </div>
-    """)
-    
-    gr.HTML("""
     <div class="info-box">
-        <b>How it works:</b> A Vision-Language Model analyzes the garment to identify type, style, and proportions.
-        These parameters feed into a parametric pattern generator that produces 2D sewing pattern pieces
-        with seam allowances, grain lines, and notches.
-        <br><br>
-        <b>Powered by:</b> Qwen 3.5 · Gemma 4 · Kimi K2.5 via
+        <b>Powered by:</b> Qwen 3.5 &middot; Gemma 4 &middot; Kimi K2.5 via
         <a href="https://huggingface.co/docs/inference-providers" target="_blank">HF Inference Providers</a>
-        <br>
-        <b>Based on research:</b>
-        <a href="https://arxiv.org/abs/2412.17811" target="_blank">ChatGarment</a> &
-        <a href="https://arxiv.org/abs/2602.20700" target="_blank">NGL-Prompter</a>
+        &nbsp;|&nbsp;
+        <b>Research:</b>
+        <a href="https://arxiv.org/abs/2412.17811">ChatGarment</a> &
+        <a href="https://arxiv.org/abs/2602.20700">NGL-Prompter</a>
     </div>
     """)
-    
-    with gr.Tabs():
-        # Tab 1: Image Input
-        with gr.Tab("📸 From Image", id="image_tab"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    input_image = gr.Image(type="pil", label="Upload Garment Image", height=400)
-                    garment_override = gr.Dropdown(
-                        choices=["Auto-detect", "Shirt", "Dress", "Skirt", "Pants", "Jacket", "Hoodie", "Vest"],
-                        value="Auto-detect",
-                        label="Garment Type (override auto-detection)"
-                    )
-                    analyze_btn = gr.Button("🔍 Analyze & Generate Pattern", variant="primary", size="lg")
-                
-                with gr.Column(scale=2):
-                    output_pattern = gr.Image(label="2D Sewing Pattern", height=500)
-                    output_summary = gr.Markdown(label="Pattern Summary")
-                    with gr.Accordion("Raw Analysis JSON", open=False):
-                        output_json = gr.Code(language="json", label="Analysis Parameters")
-            
-            analyze_btn.click(
-                process_image,
-                inputs=[input_image, garment_override],
-                outputs=[output_pattern, output_summary, output_json]
-            )
-        
-        # Tab 2: Text Description
-        with gr.Tab("✍️ From Text", id="text_tab"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    text_input = gr.Textbox(
-                        label="Describe the garment",
-                        placeholder="e.g., 'A fitted A-line dress with short cap sleeves, V-neckline, and knee length'",
-                        lines=4
-                    )
-                    text_btn = gr.Button("🧵 Generate Pattern", variant="primary", size="lg")
-                    
-                    gr.Examples(
-                        examples=[
-                            ["A classic men's dress shirt with long sleeves, button-down collar, and chest pocket"],
-                            ["A flared midi skirt with high waist, A-line silhouette"],
-                            ["Slim-fit straight-leg jeans with front and back pockets"],
-                            ["An oversized hoodie with kangaroo pocket and drawstring hood"],
-                            ["A fitted blazer with notched lapel collar and two welt pockets"],
-                            ["A knee-length A-line dress with cap sleeves and round neckline"],
-                        ],
-                        inputs=text_input
-                    )
-                
-                with gr.Column(scale=2):
-                    text_output_pattern = gr.Image(label="2D Sewing Pattern", height=500)
-                    text_output_summary = gr.Markdown(label="Pattern Summary")
-                    with gr.Accordion("Raw Analysis JSON", open=False):
-                        text_output_json = gr.Code(language="json", label="Analysis Parameters")
-            
-            text_btn.click(
-                process_text_description,
-                inputs=[text_input],
-                outputs=[text_output_pattern, text_output_summary, text_output_json]
-            )
-        
-        # Tab 3: Manual Parameters
-        with gr.Tab("📐 Manual Parameters", id="manual_tab"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    m_type = gr.Dropdown(
-                        choices=["Shirt", "Dress", "Skirt", "Pants", "Jacket", "Hoodie", "Vest"],
-                        value="Shirt", label="Garment Type"
-                    )
-                    
-                    gr.Markdown("### Body Measurements (cm)")
-                    with gr.Row():
-                        m_bust = gr.Slider(70, 130, value=92, step=1, label="Bust")
-                        m_waist = gr.Slider(55, 110, value=74, step=1, label="Waist")
-                    with gr.Row():
-                        m_hip = gr.Slider(75, 130, value=96, step=1, label="Hip")
-                        m_shoulder = gr.Slider(35, 55, value=42, step=1, label="Shoulder Width")
-                    
-                    gr.Markdown("### Garment Dimensions (cm)")
-                    with gr.Row():
-                        m_bodice = gr.Slider(30, 80, value=42, step=1, label="Bodice/Top Length")
-                        m_sleeve = gr.Slider(10, 75, value=60, step=1, label="Sleeve Length")
-                    with gr.Row():
-                        m_skirt = gr.Slider(25, 120, value=55, step=1, label="Skirt Length")
-                        m_pant = gr.Slider(25, 115, value=100, step=1, label="Pant Length")
-                    with gr.Row():
-                        m_neck = gr.Slider(3, 25, value=8, step=1, label="Neckline Depth")
-                        m_flare = gr.Slider(0, 20, value=0, step=1, label="Hem Flare")
-                    
-                    gr.Markdown("### Features")
-                    with gr.Row():
-                        m_collar = gr.Checkbox(value=True, label="Collar")
-                        m_collar_type = gr.Dropdown(["Standard", "Mandarin", "Peter_pan"], value="Standard", label="Collar Type")
-                    with gr.Row():
-                        m_cuffs = gr.Checkbox(value=True, label="Cuffs")
-                        m_pockets = gr.Checkbox(value=False, label="Pockets")
-                    with gr.Row():
-                        m_hood = gr.Checkbox(value=False, label="Hood")
-                        m_fit = gr.Dropdown(["Fitted", "Regular", "Oversized", "Loose"], value="Regular", label="Fit")
-                    
-                    manual_btn = gr.Button("🧵 Generate Pattern", variant="primary", size="lg")
-                
-                with gr.Column(scale=2):
-                    manual_output_pattern = gr.Image(label="2D Sewing Pattern", height=500)
-                    manual_output_summary = gr.Markdown(label="Pattern Summary")
-                    with gr.Accordion("Raw Parameters JSON", open=False):
-                        manual_output_json = gr.Code(language="json", label="Parameters")
-            
-            manual_btn.click(
-                process_manual_params,
-                inputs=[m_type, m_bust, m_waist, m_hip, m_shoulder, m_bodice,
-                       m_sleeve, m_skirt, m_pant, m_neck,
-                       m_collar, m_collar_type, m_cuffs, m_pockets, m_hood, m_flare, m_fit],
-                outputs=[manual_output_pattern, manual_output_summary, manual_output_json]
-            )
-    
+
+    # === Tab 1: From Image ===
+    with gr.Tab("From Image"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                input_image = gr.Image(type="pil", label="Upload Garment Image", height=350)
+                garment_override = gr.Dropdown(choices=["Auto-detect","Shirt","Dress","Skirt","Pants","Jacket","Hoodie","Vest"], value="Auto-detect", label="Garment Type Override")
+                analyze_btn = gr.Button("Analyze & Generate", variant="primary", size="lg")
+            with gr.Column(scale=2):
+                with gr.Row():
+                    with gr.Column():
+                        out_pattern_2d = gr.Image(label="2D Sewing Pattern", height=400)
+                    with gr.Column():
+                        out_3d = gr.Plot(label="3D Garment Preview")
+                out_summary = gr.Markdown(label="Pattern Summary")
+                with gr.Accordion("Raw JSON", open=False):
+                    out_json = gr.Code(language="json", label="Analysis")
+        analyze_btn.click(process_image, inputs=[input_image, garment_override], outputs=[out_pattern_2d, out_3d, out_summary, out_json])
+
+    # === Tab 2: From Text ===
+    with gr.Tab("From Text"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                text_input = gr.Textbox(label="Describe the garment", placeholder="e.g., A fitted A-line dress with cap sleeves", lines=3)
+                text_btn = gr.Button("Generate Pattern", variant="primary", size="lg")
+                gr.Examples(examples=[
+                    ["A classic dress shirt with long sleeves and button-down collar"],
+                    ["A flared midi skirt with high waist"],
+                    ["An oversized hoodie with kangaroo pocket"],
+                    ["A fitted blazer with notched lapel collar"],
+                    ["Slim-fit straight-leg jeans with pockets"],
+                    ["A knee-length A-line dress with cap sleeves"],
+                ], inputs=text_input)
+            with gr.Column(scale=2):
+                with gr.Row():
+                    with gr.Column():
+                        txt_pattern_2d = gr.Image(label="2D Pattern", height=400)
+                    with gr.Column():
+                        txt_3d = gr.Plot(label="3D Preview")
+                txt_summary = gr.Markdown()
+                with gr.Accordion("Raw JSON", open=False):
+                    txt_json = gr.Code(language="json")
+        text_btn.click(process_text, inputs=[text_input], outputs=[txt_pattern_2d, txt_3d, txt_summary, txt_json])
+
+    # === Tab 3: Manual Parameters ===
+    with gr.Tab("Manual Parameters"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                m_type = gr.Dropdown(choices=["Shirt","Dress","Skirt","Pants","Jacket","Hoodie","Vest"], value="Shirt", label="Garment Type")
+                gr.Markdown("### Measurements (cm)")
+                with gr.Row():
+                    m_bust = gr.Slider(70,130,value=92,step=1,label="Bust")
+                    m_waist = gr.Slider(55,110,value=74,step=1,label="Waist")
+                with gr.Row():
+                    m_hip = gr.Slider(75,130,value=96,step=1,label="Hip")
+                    m_shoulder = gr.Slider(35,55,value=42,step=1,label="Shoulder")
+                with gr.Row():
+                    m_bodice = gr.Slider(30,80,value=42,step=1,label="Bodice Length")
+                    m_sleeve = gr.Slider(10,75,value=60,step=1,label="Sleeve Length")
+                with gr.Row():
+                    m_skirt = gr.Slider(25,120,value=55,step=1,label="Skirt Length")
+                    m_pant = gr.Slider(25,115,value=100,step=1,label="Pant Length")
+                with gr.Row():
+                    m_neck = gr.Slider(3,25,value=8,step=1,label="Neckline Depth")
+                    m_flare = gr.Slider(0,20,value=0,step=1,label="Hem Flare")
+                gr.Markdown("### Features")
+                with gr.Row():
+                    m_collar = gr.Checkbox(value=True,label="Collar")
+                    m_ctype = gr.Dropdown(["Standard","Mandarin","Peter_pan"],value="Standard",label="Collar Type")
+                with gr.Row():
+                    m_cuffs = gr.Checkbox(value=True,label="Cuffs")
+                    m_pockets = gr.Checkbox(value=False,label="Pockets")
+                with gr.Row():
+                    m_hood = gr.Checkbox(value=False,label="Hood")
+                    m_fit = gr.Dropdown(["Fitted","Regular","Oversized","Loose"],value="Regular",label="Fit")
+                manual_btn = gr.Button("Generate Pattern", variant="primary", size="lg")
+            with gr.Column(scale=2):
+                with gr.Row():
+                    with gr.Column():
+                        man_pattern_2d = gr.Image(label="2D Pattern", height=400)
+                    with gr.Column():
+                        man_3d = gr.Plot(label="3D Preview")
+                man_summary = gr.Markdown()
+                with gr.Accordion("Raw JSON", open=False):
+                    man_json = gr.Code(language="json")
+        manual_btn.click(process_manual, inputs=[m_type,m_bust,m_waist,m_hip,m_shoulder,m_bodice,m_sleeve,m_skirt,m_pant,m_neck,m_flare,m_collar,m_ctype,m_cuffs,m_pockets,m_hood,m_fit], outputs=[man_pattern_2d, man_3d, man_summary, man_json])
+
+    # === Tab 4: Chat & Edit ===
+    with gr.Tab("Chat & Edit"):
+        gr.Markdown("### Edit your pattern with natural language\nFirst generate a pattern (from Image/Text/Manual tabs), then edit it here. Each edit updates both 2D and 3D views.")
+        with gr.Row():
+            with gr.Column(scale=1):
+                chatbot = gr.Chatbot(label="Pattern Editor", height=400)
+                chat_input = gr.Textbox(label="Edit instruction", placeholder="e.g., Make the sleeves longer, Add a hood, Change to A-line skirt", lines=2)
+                with gr.Row():
+                    chat_send = gr.Button("Apply Edit", variant="primary")
+                    chat_clear = gr.Button("Clear Chat")
+            with gr.Column(scale=2):
+                with gr.Row():
+                    with gr.Column():
+                        chat_pattern_2d = gr.Image(label="Updated 2D Pattern", height=400)
+                    with gr.Column():
+                        chat_3d = gr.Plot(label="Updated 3D Preview")
+                chat_summary = gr.Markdown()
+                with gr.Accordion("Updated JSON", open=False):
+                    chat_json = gr.Code(language="json")
+
+        def clear_chat():
+            return [], None, None, "", "{}"
+
+        chat_send.click(chat_edit, inputs=[chat_input, chatbot], outputs=[chatbot, chat_pattern_2d, chat_3d, chat_summary, chat_json])
+        chat_input.submit(chat_edit, inputs=[chat_input, chatbot], outputs=[chatbot, chat_pattern_2d, chat_3d, chat_summary, chat_json])
+        chat_clear.click(clear_chat, outputs=[chatbot, chat_pattern_2d, chat_3d, chat_summary, chat_json])
+
     # References
     gr.HTML("""
     <div class="ref-box" style="margin-top: 20px;">
-        <h4>📚 Research References</h4>
+        <h4>Research References</h4>
         <ul>
-            <li><b>ChatGarment</b> (Bian et al., 2024) — VLM → GarmentCode JSON → sewing patterns
+            <li><b>ChatGarment</b> (Bian et al., 2024) -- VLM + multi-turn dialogue for garment editing
                 [<a href="https://arxiv.org/abs/2412.17811">Paper</a>]
                 [<a href="https://github.com/biansy000/ChatGarment">Code</a>]
                 [<a href="https://huggingface.co/datasets/sy000/ChatGarmentDataset">Dataset</a>]</li>
-            <li><b>NGL-Prompter</b> (2025) — Training-free VLM + Natural Garment Language
+            <li><b>NGL-Prompter</b> (2025) -- Training-free VLM pattern estimation
                 [<a href="https://arxiv.org/abs/2602.20700">Paper</a>]</li>
-            <li><b>SewFormer</b> (Liu et al., 2023) — Two-level Transformer for pattern reconstruction
+            <li><b>SewFormer</b> (Liu et al., 2023) -- Two-level Transformer pattern reconstruction
                 [<a href="https://arxiv.org/abs/2311.04218">Paper</a>]</li>
-            <li><b>GarmentDiffusion</b> (2025) — DiT-based multimodal pattern generation
+            <li><b>GarmentDiffusion</b> (2025) -- DiT-based multimodal pattern generation
                 [<a href="https://arxiv.org/abs/2504.21476">Paper</a>]</li>
-            <li><b>GarmageNet</b> (Style3D, 2025) — Geometry image diffusion for sewing patterns
-                [<a href="https://arxiv.org/abs/2504.01483">Paper</a>]
-                [<a href="https://huggingface.co/datasets/Style3D/GarmageSet">Dataset</a>]</li>
         </ul>
     </div>
     """)
 
-
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)