Fix 3D garment visualization: anatomically correct body, proper garment positioning and scaling

- 17-landmark shaped body (not a simple cylinder)
- Garment radii derived from circumference/(2*pi) (not raw measurement*body_radius)
- Shirt/dress torso at Z=89-145 (chest area, not starting from feet)
- Sleeves as tilted tubes from shoulder outward/downward
- Pants legs offset from center (cx=±hip_rx*0.45)
- Skirt flares from waist downward
- Collar at neck height (Z=148-156)
- Fabric-like Plotly lighting (high ambient, low specular)
- aspectmode="data" prevents distortion

garment_3d.py

@@ -1,278 +1,574 @@
 """
-3D Garment Visualizer - Surface Mesh Approach
-Creates realistic 3D garment surfaces on a parametric body using Plotly.
+3D Garment Visualizer — Anatomically Correct Mannequin + Garment Surfaces
+
+Creates realistic 3D garment previews on a shaped parametric body using Plotly.
+Uses two core primitives:
+  1. Revolution surfaces (body, torso, skirt, collar, waistband)
+  2. Tilted tubes (sleeves)
+
+All Z values are in cm, Z=0 at floor, Z=170 at head top.
+Garment radii are derived from circumference measurements:
+  radius = circumference / (2*pi)  (for circular cross-section)
+  For elliptical: rx = circ / (2*pi) * 1.1, ry = circ / (2*pi) * 0.9
 """
 import numpy as np
 import plotly.graph_objects as go
-from typing import Dict
-
-def _make_body_surface(height=170, chest=88, waist=74, hip=96):
-    """Create a parametric human body as a mesh surface."""
-    n_theta = 36
-    n_z = 50
-    theta = np.linspace(0, 2*np.pi, n_theta)
-    z = np.linspace(0, height, n_z)
-    Theta, Z = np.meshgrid(theta, z)
-    R = np.zeros_like(Z)
-    for i in range(n_z):
-        t = Z[i,0] / height
-        if t < 0.08:
-            r = 6 + t*50
-        elif t < 0.15:
-            f = (t-0.08)/0.07
-            r = 10 + (chest/2*0.5 - 10)*f
-        elif t < 0.44:
-            f = (t-0.15)/0.29
-            r = chest/2 * (1 - 0.05*f)
-        elif t < 0.55:
-            f = (t-0.44)/0.11
-            r = chest/2*0.95 - (chest/2*0.95 - waist/2)*f
-        elif t < 0.72:
-            f = (t-0.55)/0.17
-            r = waist/2 + (hip/2 - waist/2)*f
-        else:
-            f = (t-0.72)/0.28
-            r = hip/2 * (1 - 0.6*f)
-        R[i,:] = r
-    X = R * np.cos(Theta) * 0.85
-    Y = R * np.sin(Theta) * 0.55
+from typing import Dict, List, Tuple
+
+TWO_PI = 2 * np.pi
+
+# ── Anatomical body profile (female mannequin, 170 cm) ─────────────────────
+# 17 landmarks from feet to head (all radii in cm)
+_BODY_Z  = [0,    7,   30,  45,   65,   88,  100, 104, 112,  120, 132,  140,  145,  150, 158, 162, 170]
+_BODY_RX = [4.0, 3.0, 4.5, 4.0,  6.5,  9.5,  8.0, 7.0, 8.5, 10.0, 9.0,  8.5, 11.5,  3.5, 3.0, 5.5, 4.5]
+_BODY_RY = [3.0, 2.5, 4.0, 4.0,  6.0,  8.5,  7.5, 6.5, 8.0,  9.0, 8.0,  7.5,  8.0,  3.5, 3.0, 5.0, 4.5]
+
+# Key anatomical Z heights (cm from floor)
+Z_FLOOR = 0
+Z_ANKLE = 7
+Z_KNEE = 45
+Z_HIP = 88
+Z_WAIST = 104
+Z_BUST = 120
+Z_SHOULDER = 145
+Z_NECK_BASE = 150
+Z_HEAD_TOP = 170
+
+
+# ── Helpers: circumference → elliptical radii ──────────────────────────────
+def _circ_to_rx(circ):
+    """Convert circumference to X-radius (wider front-back)."""
+    return circ / TWO_PI * 1.10
+
+def _circ_to_ry(circ):
+    """Convert circumference to Y-radius (narrower side-side)."""
+    return circ / TWO_PI * 0.90
+
+
+# ── Primitive 1: Revolution surface ─────────────────────────────────────────
+def _revolution_surface(z_heights, rx_vals, ry_vals,
+                        n_theta=36, cx=0.0, cy=0.0):
+    """Surface of revolution with elliptical cross-sections."""
+    theta = np.linspace(0, 2 * np.pi, n_theta)
+    z_arr = np.asarray(z_heights, float)
+    rx = np.asarray(rx_vals, float)
+    ry = np.asarray(ry_vals, float)
+    Z = np.outer(z_arr, np.ones(n_theta))
+    X = cx + np.outer(rx, np.cos(theta))
+    Y = cy + np.outer(ry, np.sin(theta))
+    return X, Y, Z
+
+
+# ── Primitive 2: Tilted tube (for sleeves) ──────────────────────────────────
+def _tilted_tube(start, end, r_start, r_end, n_theta=24, n_z=12):
+    """Tapered tube between two 3D points."""
+    s = np.array(start, float)
+    e = np.array(end, float)
+    axis = e - s
+    length = np.linalg.norm(axis)
+    if length < 0.01:
+        return np.zeros((n_z, n_theta)), np.zeros((n_z, n_theta)), np.zeros((n_z, n_theta))
+
+    axis_n = axis / length
+    ref = np.array([0., 0., 1.]) if abs(axis_n[2]) < 0.9 else np.array([1., 0., 0.])
+    right = np.cross(axis_n, ref)
+    right /= np.linalg.norm(right)
+    up = np.cross(right, axis_n)
+
+    theta = np.linspace(0, 2 * np.pi, n_theta)
+    t_vals = np.linspace(0, 1, n_z)
+
+    X = np.zeros((n_z, n_theta))
+    Y = np.zeros((n_z, n_theta))
+    Z = np.zeros((n_z, n_theta))
+
+    for i, t in enumerate(t_vals):
+        center = s + t * axis
+        r = r_start + t * (r_end - r_start)
+        for j, th in enumerate(theta):
+            offset = r * (np.cos(th) * right + np.sin(th) * up)
+            X[i, j] = center[0] + offset[0]
+            Y[i, j] = center[1] + offset[1]
+            Z[i, j] = center[2] + offset[2]
+
     return X, Y, Z
 
-def _garment_surface_shirt(params):
-    """Create shirt/t-shirt/blouse as 3D surface mesh."""
+
+# ── Surface helper ──────────────────────────────────────────────────────────
+def _make_surface(X, Y, Z, color, name, opacity=0.88, lighting=None):
+    """Create a Plotly Surface trace with fabric-like shading."""
+    if lighting is None:
+        lighting = dict(ambient=0.65, diffuse=0.85, specular=0.15, roughness=0.8)
+    return go.Surface(
+        x=X, y=Y, z=Z,
+        surfacecolor=np.ones_like(X),
+        colorscale=[[0, color], [1, color]],
+        opacity=opacity,
+        showscale=False,
+        name=name,
+        hoverinfo="name",
+        lighting=lighting,
+        lightposition=dict(x=100, y=200, z=300),
+    )
+
+
+# ── Body mannequin ──────────────────────────────────────────────────────────
+def _make_body():
+    """Create the translucent mannequin body."""
+    X, Y, Z = _revolution_surface(_BODY_Z, _BODY_RX, _BODY_RY, n_theta=48)
+    return go.Surface(
+        x=X, y=Y, z=Z,
+        surfacecolor=np.ones_like(X) * 0.8,
+        colorscale=[[0, "#E8D0B0"], [1, "#E8D0B0"]],
+        opacity=0.20,
+        showscale=False,
+        name="Body",
+        hoverinfo="skip",
+        lighting=dict(ambient=0.9, diffuse=0.1, specular=0, roughness=1.0),
+    )
+
+
+# ── Helper: interpolate body radius at arbitrary Z ──────────────────────────
+def _body_rx(z_val):
+    return float(np.interp(z_val, _BODY_Z, _BODY_RX))
+
+def _body_ry(z_val):
+    return float(np.interp(z_val, _BODY_Z, _BODY_RY))
+
+
+# ── Garment builders ────────────────────────────────────────────────────────
+
+def _build_shirt(params, color="#4A90D9"):
+    """Build shirt/blouse/top/t-shirt surfaces."""
     bust = params.get("bust", 92)
     waist = params.get("waist", 74)
-    hip = params.get("hip", 96)
     shoulder = params.get("shoulder_width", 42)
-    body_len = params.get("bodice_length", 72)
+    bodice_len = params.get("bodice_length", 72)
     sleeve_len = params.get("sleeve_length", 60)
-    bicep_r = params.get("bicep", 30) / 2 + 2
-    wrist_r = params.get("wrist", 18) / 2 + 1
-    flare = params.get("flare", 0)
+    bicep = params.get("bicep", 30)
+    wrist_circ = params.get("wrist", 18)
     fit = params.get("fit", "regular")
-    ease = {"fitted": 2, "regular": 4, "oversized": 10, "loose": 8}.get(fit, 4)
-    n_theta = 36
-    theta = np.linspace(0, 2*np.pi, n_theta)
+    flare = params.get("flare", 0)
+
+    ease = {"fitted": 0.5, "regular": 1.2, "oversized": 3.0, "loose": 2.2}.get(fit, 1.2)
+
+    bust_rx = _circ_to_rx(bust) + ease
+    bust_ry = _circ_to_ry(bust) + ease
+    waist_rx = _circ_to_rx(waist) + ease
+    waist_ry = _circ_to_ry(waist) + ease
+    shoulder_rx = shoulder / 2
+
     surfaces = []
 
-    # Torso - main body of shirt
-    n_z_torso = 30
-    z_torso = np.linspace(0, body_len, n_z_torso)
-    Theta_t, Z_t = np.meshgrid(theta, z_torso)
-    R_t = np.zeros_like(Z_t)
-    for i in range(n_z_torso):
-        t = z_torso[i] / body_len
+    extra_length = max(0, bodice_len - 42) * 0.5
+    hem_z = max(Z_WAIST - extra_length, Z_HIP - 5)
+
+    n_torso = 16
+    torso_z = np.linspace(hem_z, Z_SHOULDER, n_torso)
+    torso_rx_arr = []
+    torso_ry_arr = []
+
+    for z in torso_z:
+        t = (z - hem_z) / (Z_SHOULDER - hem_z)
+
         if t < 0.25:
-            r = (shoulder/2 + ease) * (1 - 0.15*t)
+            rx = waist_rx + flare * (0.25 - t) / 0.25
+            ry = waist_ry + flare * 0.8 * (0.25 - t) / 0.25
         elif t < 0.55:
-            f = (t-0.25)/0.3
-            r_top = (shoulder/2 + ease) * 0.962
-            r_bot = (bust/2 + ease)
-            r = r_top + (r_bot - r_top) * f
-        elif t < 0.7:
-            f = (t-0.55)/0.15
-            r = (bust/2 + ease) * (1 - 0.05*f)
+            f = (t - 0.25) / 0.30
+            rx = waist_rx + (bust_rx - waist_rx) * f
+            ry = waist_ry + (bust_ry - waist_ry) * f
+        elif t < 0.8:
+            f = (t - 0.55) / 0.25
+            rx = bust_rx + (bust_rx * 0.92 - bust_rx) * f
+            ry = bust_ry + (bust_ry * 0.92 - bust_ry) * f
         else:
-            f = (t-0.7)/0.3
-            r_bust = (bust/2 + ease) * 0.95
-            r_waist = (waist/2 + ease + flare)
-            r = r_bust + (r_waist - r_bust) * f
-        R_t[i,:] = r
-    X_t = R_t * np.cos(Theta_t) * 0.85
-    Y_t = R_t * np.sin(Theta_t) * 0.55
-    surfaces.append((X_t, Y_t, Z_t, "#5B9BD5", "Torso", 0.7))
-
-    # Sleeves
+            f = (t - 0.8) / 0.2
+            rx = bust_rx * 0.92 + (shoulder_rx - bust_rx * 0.92) * f
+            ry = bust_ry * 0.92 * (1 - 0.15 * f)
+
+        rx = max(rx, _body_rx(z) + 0.8)
+        ry = max(ry, _body_ry(z) + 0.8)
+        torso_rx_arr.append(rx)
+        torso_ry_arr.append(ry)
+
+    X, Y, Zt = _revolution_surface(torso_z, torso_rx_arr, torso_ry_arr, n_theta=36)
+    surfaces.append(_make_surface(X, Y, Zt, color, "Torso", opacity=0.85))
+
+    shoulder_attach_rx = torso_rx_arr[-1]
+    shoulder_attach_z = Z_SHOULDER - 3
+
+    sleeve_drop = sleeve_len * 0.45
+    sleeve_spread = sleeve_len * 0.30
+
+    r_bicep = bicep / TWO_PI + ease * 0.4
+    r_wrist = wrist_circ / TWO_PI + ease * 0.3
+
     for side in [1, -1]:
-        n_sl = 15
-        z_sl = np.linspace(0, sleeve_len, n_sl)
-        n_th_sl = 16
-        th_sl = np.linspace(0, 2*np.pi, n_th_sl)
-        Theta_s, Z_s = np.meshgrid(th_sl, z_sl)
-        R_s = np.zeros_like(Z_s)
-        for j in range(n_sl):
-            t = z_sl[j] / sleeve_len
-            R_s[j,:] = bicep_r * (1-t) + wrist_r * t + ease*0.5
-        sx_center = side * (shoulder*0.85 + ease*0.3)
-        sy_center = 0
-        sz_top = body_len * 0.92
-        X_s = sx_center + R_s * np.cos(Theta_s) * 0.7 + side * np.linspace(0, sleeve_len*0.15, n_sl).reshape(-1,1)
-        Y_s = sy_center + R_s * np.sin(Theta_s) * 0.5 + np.linspace(0, -sleeve_len*0.4, n_sl).reshape(-1,1)
-        Z_s = sz_top - Z_s * 0.3
-        color = "#6BB3E0" if side > 0 else "#4A90D9"
-        surfaces.append((X_s, Y_s, Z_s, color, "Sleeve", 0.65))
-
-    # Collar
+        start = (side * shoulder_attach_rx, 0, shoulder_attach_z)
+        end = (side * (shoulder_attach_rx + sleeve_spread), 0,
+               shoulder_attach_z - sleeve_drop)
+        Xs, Ys, Zs = _tilted_tube(start, end, r_bicep, r_wrist, n_theta=20, n_z=14)
+        sleeve_color = _lighten_color(color, 0.08) if side > 0 else _darken_color(color, 0.08)
+        surfaces.append(_make_surface(Xs, Ys, Zs, sleeve_color, "Sleeve", opacity=0.80))
+
     if params.get("has_collar", False):
         collar_h = params.get("collar_height", 4)
-        neck_r = params.get("neckline_width", 7) + 1
-        n_c = 24
-        th_c = np.linspace(0, 2*np.pi, n_c)
-        n_zc = 5
-        z_c = np.linspace(0, collar_h, n_zc)
-        Theta_c, Z_c = np.meshgrid(th_c, z_c)
-        R_c = np.ones_like(Z_c) * neck_r
-        X_c = R_c * np.cos(Theta_c) * 0.85
-        Y_c = R_c * np.sin(Theta_c) * 0.55
-        Z_c = Z_c + body_len - 2
-        surfaces.append((X_c, Y_c, Z_c, "#FFFFFF", "Collar", 0.9))
+        n_c = 6
+        collar_z = np.linspace(Z_NECK_BASE - 2, Z_NECK_BASE + collar_h, n_c)
+        collar_rx = []
+        collar_ry = []
+        for z in collar_z:
+            collar_rx.append(_body_rx(z) + 1.5)
+            collar_ry.append(_body_ry(z) + 1.5)
+        Xc, Yc, Zc = _revolution_surface(collar_z, collar_rx, collar_ry, n_theta=28)
+        surfaces.append(_make_surface(Xc, Yc, Zc, "#FFFFFF", "Collar", opacity=0.92))
 
     return surfaces
-def _garment_surface_pants(params):
-    """Create pants/trousers as 3D surface mesh."""
+
+
+def _build_pants(params, color="#2C5F8A"):
+    """Build pants/trousers/jeans surfaces."""
     waist = params.get("waist", 74)
     hip = params.get("hip", 96)
     thigh = params.get("thigh", 56)
     ankle = params.get("ankle", 24)
     pant_len = params.get("pant_length", 100)
-    crotch = params.get("crotch_depth", 27)
     fit = params.get("fit", "regular")
-    ease = {"fitted":1,"regular":3,"oversized":6,"loose":5}.get(fit, 3)
-    body_h = 170
-    n_theta = 24
-    theta = np.linspace(0, 2*np.pi, n_theta)
+    flare = params.get("flare", 0)
+
+    ease = {"fitted": 0.5, "regular": 1.0, "oversized": 2.5, "loose": 2.0}.get(fit, 1.0)
+
     surfaces = []
-    for side in [1, -1]:
-        n_z = 25
-        z = np.linspace(0, pant_len, n_z)
-        Theta, Z = np.meshgrid(theta, z)
-        R = np.zeros_like(Z)
-        for i in range(n_z):
-            t = z[i] / pant_len
-            if t < 0.2:
-                f = t/0.2
-                r = (hip/2+ease) * (1-f) + (thigh/2+ease)*f
-            elif t < 0.35:
-                r = thigh/2 + ease
-            else:
-                f = (t-0.35)/0.65
-                r = (thigh/2+ease) * (1-f) + (ankle/2+ease) * f
-            R[i,:] = r
-        cx = side * (hip/4 + ease*0.3)
-        X = cx + R * np.cos(Theta) * 0.8
-        Y = R * np.sin(Theta) * 0.55
-        Z = (body_h * 0.58 - crotch * 0.3) - Z * 0.3 + Z * 0.7
-        color = "#2C5F8A" if side > 0 else "#3A6FA0"
-        surfaces.append((X, Y, Z, color, "Leg", 0.7))
-    # Waistband
-    n_wb = 24
-    th_wb = np.linspace(0, 2*np.pi, n_wb)
-    n_zw = 4
-    z_wb = np.linspace(0, params.get("waistband_height", 4), n_zw)
-    Theta_w, Z_w = np.meshgrid(th_wb, z_wb)
-    R_w = np.ones_like(Z_w) * (waist/2 + ease)
-    X_w = R_w * np.cos(Theta_w) * 0.85
-    Y_w = R_w * np.sin(Theta_w) * 0.55
-    Z_w = Z_w + body_h * 0.58
-    surfaces.append((X_w, Y_w, Z_w, "#1A3D5C", "Waistband", 0.85))
+
+    hip_rx = _circ_to_rx(hip) + ease
+    hip_ry = _circ_to_ry(hip) + ease
+    waist_rx = _circ_to_rx(waist) + ease
+    waist_ry = _circ_to_ry(waist) + ease
+
+    n_wb = 8
+    wb_z = np.linspace(Z_HIP, Z_WAIST, n_wb)
+    wb_rx_arr = []
+    wb_ry_arr = []
+    for z in wb_z:
+        t = (z - Z_HIP) / (Z_WAIST - Z_HIP)
+        rx = hip_rx + (waist_rx - hip_rx) * t
+        ry = hip_ry + (waist_ry - hip_ry) * t
+        rx = max(rx, _body_rx(z) + 0.8)
+        ry = max(ry, _body_ry(z) + 0.8)
+        wb_rx_arr.append(rx)
+        wb_ry_arr.append(ry)
+
+    Xw, Yw, Zw = _revolution_surface(wb_z, wb_rx_arr, wb_ry_arr, n_theta=36)
+    surfaces.append(_make_surface(Xw, Yw, Zw, _darken_color(color, 0.12), "Waistband", opacity=0.90))
+
+    hem_z = max(Z_HIP - pant_len * 0.85, Z_ANKLE - 5)
+    hem_z = max(hem_z, 2)
+
+    leg_cx = hip_rx * 0.45
+
+    r_thigh = thigh / TWO_PI + ease
+    r_ankle = ankle / TWO_PI + ease + flare * 0.15
+
+    n_leg = 18
+    leg_z = np.linspace(Z_HIP, hem_z, n_leg)
+
+    for side_idx, side in enumerate([1, -1]):
+        leg_rx = []
+        leg_ry = []
+        for i, z in enumerate(leg_z):
+            t = i / (n_leg - 1)
+            rx = r_thigh + (r_ankle - r_thigh) * t
+            ry = rx * 0.85
+            leg_rx.append(rx)
+            leg_ry.append(ry)
+
+        cx = side * leg_cx
+        Xl, Yl, Zl = _revolution_surface(leg_z, leg_rx, leg_ry, n_theta=28, cx=cx)
+        leg_color = color if side_idx == 0 else _lighten_color(color, 0.06)
+        surfaces.append(_make_surface(Xl, Yl, Zl, leg_color, "Leg", opacity=0.85))
+
     return surfaces
 
-def _garment_surface_skirt(params):
-    """Create skirt as 3D surface mesh."""
-    waist = params.get("waist", 74)
+
+def _build_skirt(params, color="#C48BB8"):
+    """Build skirt surfaces."""
+    waist = params.get("waist", 72)
     hip = params.get("hip", 96)
     skirt_len = params.get("skirt_length", 55)
     flare = params.get("flare", 5)
-    body_h = 170
-    n_theta = 36
-    theta = np.linspace(0, 2*np.pi, n_theta)
-    n_z = 25
-    z = np.linspace(0, skirt_len, n_z)
-    Theta, Z = np.meshgrid(theta, z)
-    R = np.zeros_like(Z)
-    for i in range(n_z):
-        t = z[i] / skirt_len
+    fit = params.get("fit", "regular")
+
+    ease = {"fitted": 0.5, "regular": 1.0, "oversized": 2.5, "loose": 2.0}.get(fit, 1.0)
+
+    surfaces = []
+
+    hem_z = max(Z_WAIST - skirt_len, Z_ANKLE - 5)
+    hem_z = max(hem_z, 2)
+
+    waist_rx = _circ_to_rx(waist) + ease
+    waist_ry = _circ_to_ry(waist) + ease
+    hip_rx = _circ_to_rx(hip) + ease
+    hip_ry = _circ_to_ry(hip) + ease
+
+    n_sk = 16
+    skirt_z = np.linspace(Z_WAIST, hem_z, n_sk)
+    skirt_rx = []
+    skirt_ry = []
+
+    for i, z in enumerate(skirt_z):
+        t = i / (n_sk - 1)
         if t < 0.3:
             f = t / 0.3
-            r = (waist/2+2) * (1-f) + (hip/2+2) * f
+            rx = waist_rx + (hip_rx - waist_rx) * f
+            ry = waist_ry + (hip_ry - waist_ry) * f
         else:
-            f = (t-0.3)/0.7
-            r = (hip/2+2) + flare * f * (1 + 0.5*np.sin(3*theta)**2)[np.newaxis,:]
-        R[i,:] = r
-    X = R * np.cos(Theta) * 0.85
-    Y = R * np.sin(Theta) * 0.55
-    waist_z = body_h * 0.58
-    Z = waist_z - Z
-    return [(X, Y, Z, "#C48BB8", "Skirt", 0.7)]
-def _garment_surface_dress(params):
-    return _garment_surface_shirt(params) + _garment_surface_skirt(params)
-
-def _garment_surface_hoodie(params):
-    surfaces = _garment_surface_shirt(params)
-    head_r = params.get("head_circumference", 57) / 2
-    n_th = 24
-    theta = np.linspace(0, 2*np.pi, n_th)
-    n_z = 15
-    z = np.linspace(0, head_r*1.3, n_z)
-    Theta, Z = np.meshgrid(theta, z)
-    R = np.zeros_like(Z)
-    for i in range(n_z):
-        t = z[i] / (head_r*1.3)
-        if t < 0.3:
-            R[i,:] = head_r * (0.8 + 0.2*t)
-        elif t < 0.7:
-            R[i,:] = head_r * (1.0 - 0.1*(t-0.3)/0.4)
+            f = (t - 0.3) / 0.7
+            rx = hip_rx + flare * f
+            ry = hip_ry + flare * 0.85 * f
+
+        rx = max(rx, _body_rx(z) + 1.0)
+        ry = max(ry, _body_ry(z) + 1.0)
+        skirt_rx.append(rx)
+        skirt_ry.append(ry)
+
+    Xs, Ys, Zs = _revolution_surface(skirt_z, skirt_rx, skirt_ry, n_theta=36)
+    surfaces.append(_make_surface(Xs, Ys, Zs, color, "Skirt", opacity=0.82))
+
+    n_wb = 4
+    wb_height = params.get("waistband_height", 4)
+    wb_z = np.linspace(Z_WAIST, Z_WAIST + wb_height, n_wb)
+    wb_rx = [waist_rx + 0.3] * n_wb
+    wb_ry = [waist_ry + 0.3] * n_wb
+    Xwb, Ywb, Zwb = _revolution_surface(wb_z, wb_rx, wb_ry, n_theta=36)
+    surfaces.append(_make_surface(Xwb, Ywb, Zwb, _darken_color(color, 0.15), "Waistband", opacity=0.92))
+
+    return surfaces
+
+
+def _build_dress(params, color="#8E44AD"):
+    """Build dress = bodice top + skirt bottom."""
+    surfaces = []
+    bodice_params = dict(params)
+    bodice_params["bodice_length"] = params.get("bodice_length", 42)
+    surfaces.extend(_build_shirt(bodice_params, color=color))
+
+    skirt_params = dict(params)
+    skirt_params["skirt_length"] = params.get("skirt_length", 55)
+    surfaces.extend(_build_skirt(skirt_params, color=_lighten_color(color, 0.05)))
+
+    return surfaces
+
+
+def _build_hoodie(params, color="#27AE60"):
+    """Build hoodie = shirt + hood."""
+    surfaces = _build_shirt(params, color=color)
+
+    n_hood = 10
+    hood_z = np.linspace(Z_SHOULDER, Z_HEAD_TOP + 2, n_hood)
+    hood_rx = []
+    hood_ry = []
+
+    for i, z in enumerate(hood_z):
+        t = i / (n_hood - 1)
+        if t < 0.2:
+            rx = _body_rx(Z_SHOULDER) + 2.5
+        elif t < 0.6:
+            f = (t - 0.2) / 0.4
+            rx = _body_rx(min(z, Z_HEAD_TOP)) + 3.0 + 2.0 * np.sin(f * np.pi)
+        else:
+            f = (t - 0.6) / 0.4
+            rx = _body_rx(min(z, Z_HEAD_TOP)) + 3.0 * (1 - f * 0.6)
+        hood_rx.append(rx)
+        hood_ry.append(rx * 0.85)
+
+    Xh, Yh, Zh = _revolution_surface(hood_z, hood_rx, hood_ry, n_theta=28)
+    surfaces.append(_make_surface(Xh, Yh, Zh, _darken_color(color, 0.12), "Hood", opacity=0.78))
+
+    return surfaces
+
+
+def _build_jacket(params, color="#7F8C8D"):
+    """Build jacket/coat/blazer — like a shirt but longer, wider."""
+    jacket_params = dict(params)
+    jacket_len = params.get("jacket_length", params.get("bodice_length", 70))
+    jacket_params["bodice_length"] = jacket_len
+
+    original_fit = params.get("fit", "regular")
+    if original_fit == "fitted":
+        jacket_params["fit"] = "regular"
+    elif original_fit == "regular":
+        jacket_params["fit"] = "loose"
+
+    surfaces = _build_shirt(jacket_params, color=color)
+
+    if params.get("has_hood", False):
+        surfaces.extend(_build_hood_only(params, color))
+
+    return surfaces
+
+
+def _build_hood_only(params, color):
+    """Just the hood part."""
+    n_hood = 10
+    hood_z = np.linspace(Z_SHOULDER, Z_HEAD_TOP + 2, n_hood)
+    hood_rx = []
+    hood_ry = []
+
+    for i, z in enumerate(hood_z):
+        t = i / (n_hood - 1)
+        if t < 0.2:
+            rx = _body_rx(Z_SHOULDER) + 2.5
+        elif t < 0.6:
+            f = (t - 0.2) / 0.4
+            rx = _body_rx(min(z, Z_HEAD_TOP)) + 3.0 + 2.0 * np.sin(f * np.pi)
+        else:
+            f = (t - 0.6) / 0.4
+            rx = _body_rx(min(z, Z_HEAD_TOP)) + 3.0 * (1 - f * 0.6)
+        hood_rx.append(rx)
+        hood_ry.append(rx * 0.85)
+
+    Xh, Yh, Zh = _revolution_surface(hood_z, hood_rx, hood_ry, n_theta=28)
+    return [_make_surface(Xh, Yh, Zh, _darken_color(color, 0.12), "Hood", opacity=0.78)]
+
+
+def _build_vest(params, color="#D4A574"):
+    """Build vest — sleeveless bodice."""
+    bust = params.get("bust", 92)
+    waist = params.get("waist", 74)
+    shoulder = params.get("shoulder_width", 42)
+    fit = params.get("fit", "regular")
+    flare = params.get("flare", 0)
+
+    ease = {"fitted": 0.5, "regular": 1.2, "oversized": 3.0, "loose": 2.2}.get(fit, 1.2)
+
+    bust_rx = _circ_to_rx(bust) + ease
+    bust_ry = _circ_to_ry(bust) + ease
+    waist_rx = _circ_to_rx(waist) + ease
+    waist_ry = _circ_to_ry(waist) + ease
+    shoulder_rx = shoulder / 2
+
+    surfaces = []
+    vest_len = params.get("vest_length", params.get("bodice_length", 55))
+    extra = max(0, vest_len - 42) * 0.5
+    hem_z = max(Z_WAIST - extra, Z_HIP)
+
+    n = 14
+    torso_z = np.linspace(hem_z, Z_SHOULDER, n)
+    torso_rx = []
+    torso_ry = []
+
+    for z in torso_z:
+        t = (z - hem_z) / (Z_SHOULDER - hem_z)
+        if t < 0.25:
+            rx = waist_rx + flare * (0.25 - t) / 0.25
+            ry = waist_ry + flare * 0.8 * (0.25 - t) / 0.25
+        elif t < 0.55:
+            f = (t - 0.25) / 0.30
+            rx = waist_rx + (bust_rx - waist_rx) * f
+            ry = waist_ry + (bust_ry - waist_ry) * f
+        elif t < 0.8:
+            f = (t - 0.55) / 0.25
+            rx = bust_rx * (1 - 0.08 * f)
+            ry = bust_ry * (1 - 0.08 * f)
         else:
-            R[i,:] = head_r * 0.9 * (1 - 0.5*(t-0.7)/0.3)
-    body_len = params.get("bodice_length", 65)
-    body_h = 170
-    X = R * np.cos(Theta) * 0.85
-    Y = R * np.sin(Theta) * 0.55 + np.linspace(0, head_r*0.3, n_z).reshape(-1,1)
-    Z = Z + body_h * 0.92
-    surfaces.append((X, Y, Z, "#3A7BD5", "Hood", 0.65))
+            f = (t - 0.8) / 0.2
+            rx = bust_rx * 0.92 + (shoulder_rx - bust_rx * 0.92) * f
+            ry = bust_ry * 0.92 * (1 - 0.15 * f)
+
+        rx = max(rx, _body_rx(z) + 0.8)
+        ry = max(ry, _body_ry(z) + 0.8)
+        torso_rx.append(rx)
+        torso_ry.append(ry)
+
+    X, Y, Zt = _revolution_surface(torso_z, torso_rx, torso_ry, n_theta=36)
+    surfaces.append(_make_surface(X, Y, Zt, color, "Vest", opacity=0.85))
+
     return surfaces
 
-def _garment_surface_jacket(params):
-    return _garment_surface_shirt(params)
-
-GARMENT_SURFACE_FUNCS = {
-    "shirt": _garment_surface_shirt, "blouse": _garment_surface_shirt,
-    "top": _garment_surface_shirt, "t-shirt": _garment_surface_shirt, "tee": _garment_surface_shirt,
-    "dress": _garment_surface_dress,
-    "skirt": _garment_surface_skirt,
-    "pants": _garment_surface_pants, "trousers": _garment_surface_pants, "jeans": _garment_surface_pants,
-    "jacket": _garment_surface_jacket, "coat": _garment_surface_jacket, "blazer": _garment_surface_jacket,
-    "hoodie": _garment_surface_hoodie, "sweatshirt": _garment_surface_hoodie,
-    "vest": _garment_surface_shirt,
+
+# ── Color helpers ───────────────────────────────────────────────────────────
+def _hex_to_rgb(hex_color):
+    hex_color = hex_color.lstrip('#')
+    return tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4))
+
+def _rgb_to_hex(r, g, b):
+    return f"#{int(r):02x}{int(g):02x}{int(b):02x}"
+
+def _lighten_color(hex_color, amount=0.1):
+    r, g, b = _hex_to_rgb(hex_color)
+    return _rgb_to_hex(min(255, r + int(255 * amount)),
+                       min(255, g + int(255 * amount)),
+                       min(255, b + int(255 * amount)))
+
+def _darken_color(hex_color, amount=0.1):
+    r, g, b = _hex_to_rgb(hex_color)
+    return _rgb_to_hex(max(0, r - int(255 * amount)),
+                       max(0, g - int(255 * amount)),
+                       max(0, b - int(255 * amount)))
+
+
+# ── Default garment colors ─────────────────────────────────────────────────
+GARMENT_COLORS = {
+    "shirt": "#4A90D9", "blouse": "#D98CB3", "top": "#5B9BD5",
+    "t-shirt": "#4A90D9", "tee": "#4A90D9",
+    "dress": "#8E44AD", "skirt": "#C48BB8",
+    "pants": "#2C5F8A", "trousers": "#2C5F8A", "jeans": "#1A3D6C",
+    "jacket": "#7F8C8D", "coat": "#5D6D7E", "blazer": "#6C757D",
+    "hoodie": "#27AE60", "sweatshirt": "#27AE60",
+    "vest": "#D4A574",
 }
+
+GARMENT_BUILDERS = {
+    "shirt": _build_shirt, "blouse": _build_shirt,
+    "top": _build_shirt, "t-shirt": _build_shirt, "tee": _build_shirt,
+    "dress": _build_dress, "skirt": _build_skirt,
+    "pants": _build_pants, "trousers": _build_pants, "jeans": _build_pants,
+    "jacket": _build_jacket, "coat": _build_jacket, "blazer": _build_jacket,
+    "hoodie": _build_hoodie, "sweatshirt": _build_hoodie,
+    "vest": _build_vest,
+}
+
+
+# ── Main entry point ───────────────────────────────────────────────────────
 def create_3d_figure(analysis: Dict) -> go.Figure:
-    """Create interactive 3D garment visualization with surface meshes."""
+    """Create interactive 3D garment visualization on a mannequin body."""
     garment_type = analysis.get("garment_type", "shirt").lower()
     measurements = analysis.get("measurements", {})
     features = analysis.get("features", {})
     params = {**measurements, **features}
-    chest = params.get("bust", 92)
-    waist_m = params.get("waist", 74)
-    hip_m = params.get("hip", 96)
+
     fig = go.Figure()
-    # Body - translucent skin-toned surface
-    BX, BY, BZ = _make_body_surface(chest=chest, waist=waist_m, hip=hip_m)
-    fig.add_trace(go.Surface(
-        x=BX, y=BY, z=BZ,
-        surfacecolor=np.ones_like(BX) * 0.8,
-        colorscale=[[0,"#E8D0B0"],[1,"#E8D0B0"]],
-        opacity=0.25, showscale=False, name="Body",
-        hoverinfo="skip", lighting=dict(ambient=0.9, diffuse=0.1, specular=0)))
+
+    # Mannequin body
+    fig.add_trace(_make_body())
+
     # Garment surfaces
-    func = GARMENT_SURFACE_FUNCS.get(garment_type, _garment_surface_shirt)
-    surfaces = func(params)
-    for X, Y, Z, color, name, opacity in surfaces:
-        fig.add_trace(go.Surface(
-            x=X, y=Y, z=Z,
-            surfacecolor=np.ones_like(X) * 0.5,
-            colorscale=[[0, color], [1, color]],
-            opacity=opacity, showscale=False, name=name,
-            hoverinfo="name",
-            lighting=dict(ambient=0.6, diffuse=0.4, specular=0.2, roughness=0.5)))
+    color = GARMENT_COLORS.get(garment_type, "#4A90D9")
+    builder = GARMENT_BUILDERS.get(garment_type, _build_shirt)
+    for surf in builder(params, color=color):
+        fig.add_trace(surf)
+
+    # Scene layout
     fig.update_layout(
         scene=dict(
-            xaxis=dict(showgrid=False, showticklabels=False, title="", zeroline=False),
-            yaxis=dict(showgrid=False, showticklabels=False, title="", zeroline=False),
-            zaxis=dict(showgrid=False, showticklabels=False, title="", zeroline=False),
+            xaxis=dict(showgrid=False, showticklabels=False, title="",
+                       zeroline=False, range=[-35, 35]),
+            yaxis=dict(showgrid=False, showticklabels=False, title="",
+                       zeroline=False, range=[-35, 35]),
+            zaxis=dict(showgrid=False, showticklabels=False, title="",
+                       zeroline=False, range=[0, 180]),
             aspectmode="data",
-            camera=dict(eye=dict(x=1.8, y=0.8, z=0.9), center=dict(x=0, y=0, z=-0.15))),
-        margin=dict(l=0, r=0, t=30, b=0),
-        height=500,
+            camera=dict(
+                eye=dict(x=1.8, y=1.2, z=0.5),
+                center=dict(x=0, y=0, z=-0.1),
+            ),
+            bgcolor="rgba(245,245,248,1)",
+        ),
+        margin=dict(l=0, r=0, t=35, b=0),
+        height=550,
         title=dict(text=f"3D Preview: {garment_type.title()}", font=dict(size=14)),
-        paper_bgcolor="#fafafa")
-    return fig
+        paper_bgcolor="#fafafa",
+    )
+
+    return fig