Add main Gradio app with VLM integration

app.py

@@ -0,0 +1,569 @@
+"""
+Garment Image → 2D Sewing Pattern Demo
+
+Uses a VLM (via HF Inference API) to analyze garment images and extract
+structured parameters, then generates flat 2D sewing pattern pieces.
+
+Approach inspired by:
+- ChatGarment (arxiv:2412.17811): VLM → JSON → GarmentCode → 2D patterns
+- NGL-Prompter (arxiv:2602.20700): Training-free VLM → semantic params → patterns
+"""
+
+import json
+import os
+import re
+import traceback
+from typing import Dict, Optional, Tuple
+
+import gradio as gr
+from PIL import Image
+
+from pattern_generator import generate_pattern_from_analysis, get_pattern_pieces, render_pattern_pieces
+
+# ── VLM Analysis ──
+
+GARMENT_ANALYSIS_PROMPT = """You are a professional fashion pattern maker. Analyze this garment image and extract precise sewing pattern parameters.
+
+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": "<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>
+  },
+  "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>"
+  }
+}
+
+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).
+"""
+
+def analyze_with_vlm(image: Image.Image) -> Dict:
+    """Analyze garment image using HF Inference API (Qwen2.5-VL)."""
+    import requests
+    import base64
+    from io import BytesIO
+    
+    hf_token = os.environ.get("HF_TOKEN", "")
+    if not hf_token:
+        return None
+    
+    buf = BytesIO()
+    image_rgb = image.convert('RGB')
+    image_rgb.save(buf, format='JPEG', quality=85)
+    img_b64 = base64.b64encode(buf.getvalue()).decode('utf-8')
+    
+    models = [
+        "Qwen/Qwen2.5-VL-72B-Instruct",
+        "Qwen/Qwen2.5-VL-32B-Instruct",
+        "Qwen/Qwen2.5-VL-7B-Instruct",
+        "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+    ]
+    
+    for model_id in models:
+        try:
+            url = f"https://router.huggingface.co/hf-inference/models/{model_id}/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,
+            }
+            
+            response = requests.post(url, headers=headers, json=payload, timeout=120)
+            
+            if response.status_code == 200:
+                result = response.json()
+                content = result['choices'][0]['message']['content']
+                
+                json_match = re.search(r'```(?:json)?\s*([\s\S]*?)\s*```', content)
+                if json_match:
+                    json_str = json_match.group(1)
+                else:
+                    json_match = re.search(r'\{[\s\S]*\}', content)
+                    if json_match:
+                        json_str = json_match.group()
+                    else:
+                        continue
+                
+                analysis = json.loads(json_str)
+                analysis['_model_used'] = model_id
+                return analysis
+            
+        except Exception as e:
+            print(f"Model {model_id} failed: {e}")
+            continue
+    
+    return None
+
+
+def get_default_analysis(garment_type: str = "shirt") -> Dict:
+    """Return default analysis when VLM is unavailable."""
+    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"
+            }
+        }
+    }
+    return defaults.get(garment_type, defaults["shirt"])
+
+
+# ── Main App Functions ──
+
+def process_image(image: Optional[Image.Image], garment_type_override: str = "Auto-detect") -> Tuple:
+    """Main processing: analyze image → generate pattern."""
+    if image is None and garment_type_override == "Auto-detect":
+        return None, "Please upload a garment image or select a garment 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()
+    
+    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"
+        analysis = get_default_analysis(gt)
+    
+    if garment_type_override != "Auto-detect":
+        analysis['garment_type'] = garment_type_override.lower()
+    
+    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)
+    except Exception as e:
+        traceback.print_exc()
+        return None, f"Error generating pattern: {str(e)}", "{}"
+
+
+def process_text_description(description: str) -> Tuple:
+    """Generate pattern from text description."""
+    import requests
+    
+    hf_token = os.environ.get("HF_TOKEN", "")
+    
+    if not description.strip():
+        return None, "Please enter a garment description.", "{}"
+    
+    # Try VLM-based analysis first
+    if hf_token:
+        TEXT_PROMPT = f"""You are a professional fashion pattern maker. Based on this garment description, extract precise 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."""
+
+        try:
+            models = ["Qwen/Qwen2.5-72B-Instruct", "meta-llama/Llama-3.3-70B-Instruct"]
+            for model_id in models:
+                try:
+                    url = f"https://router.huggingface.co/hf-inference/models/{model_id}/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": 1500, "temperature": 0.1
+                    }
+                    response = requests.post(url, headers=headers, json=payload, timeout=60)
+                    if response.status_code == 200:
+                        content = response.json()['choices'][0]['message']['content']
+                        json_match = re.search(r'```(?:json)?\s*([\s\S]*?)\s*```', content)
+                        if json_match:
+                            json_str = json_match.group(1)
+                        else:
+                            json_match = re.search(r'\{[\s\S]*\}', content)
+                            json_str = json_match.group() if json_match else None
+                        if json_str:
+                            analysis = json.loads(json_str)
+                            pattern_image, summary = generate_pattern_from_analysis(analysis)
+                            summary += f"\n\n*Analysis by: {model_id}*"
+                            return pattern_image, summary, json.dumps(analysis, indent=2)
+                except Exception as e:
+                    print(f"Text model {model_id} failed: {e}")
+                    continue
+        except Exception as e:
+            print(f"Text analysis failed: {e}")
+    
+    # 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)
+            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)
+
+
+# ── Gradio UI ──
+
+CSS = """
+.main-header { text-align: center; margin-bottom: 20px; }
+.info-box { padding: 15px; border-radius: 10px; background: #f0f7ff; border: 1px solid #cce0ff; margin: 10px 0; }
+.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:
+    gr.HTML("""
+    <div class="main-header">
+        <h1>🧵 Garment Image → 2D Sewing Pattern</h1>
+        <p style="font-size: 1.1em; color: #555;">
+            Upload a garment image or describe one — get flat 2D sewing pattern pieces
+        </p>
+    </div>
+    """)
+    
+    gr.HTML("""
+    <div class="info-box">
+        <b>How it works:</b> A Vision-Language Model analyzes the garment image to identify type, style, and proportions.
+        These parameters feed into a parametric pattern generator that produces anatomically-correct 2D sewing pattern pieces
+        with seam allowances, grain lines, and notches.
+        <br><br>
+        <b>Based on research:</b>
+        <a href="https://arxiv.org/abs/2412.17811" target="_blank">ChatGarment</a> (VLM → JSON → 2D patterns) &
+        <a href="https://arxiv.org/abs/2602.20700" target="_blank">NGL-Prompter</a> (training-free VLM approach)
+    </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]
+            )
+    
+    # References
+    gr.HTML("""
+    <div class="ref-box" style="margin-top: 20px;">
+        <h4>📚 Research References</h4>
+        <ul>
+            <li><b>ChatGarment</b> (Bian et al., 2024) — VLM → GarmentCode JSON → sewing patterns
+                [<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
+                [<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
+                [<a href="https://arxiv.org/abs/2311.04218">Paper</a>]</li>
+            <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)