3D view now built FROM actual 2D pattern pieces (triangulate → cylindrical wrap → Mesh3d)

garment_3d.py

@@ -1,574 +1,409 @@
 """
-3D Garment Visualizer — Anatomically Correct Mannequin + Garment Surfaces
+3D Garment Visualizer — Built FROM 2D Pattern Pieces
 
-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)
+Takes the actual 2D sewing pattern pieces from pattern_generator.py,
+triangulates them, and wraps each piece onto the correct body region
+using cylindrical/cone projections.
 
-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
+Each 3D surface directly corresponds to a 2D pattern piece.
 """
 import numpy as np
 import plotly.graph_objects as go
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Optional
 
-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
+# ── Body constants (cm, Z=0 at floor, Z=170 at head top) ───────────────────
+BODY_HEIGHT = 170.0
 Z_ANKLE = 7
 Z_KNEE = 45
+Z_CROTCH = 82
 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
-
-
-# ── 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),
-    )
+Z_NECK = 150
+Z_HEAD = 170
+
+_BODY_Z  = [0, 7, 30, 45, 65, 82, 88, 100, 104, 112, 120, 132, 140, 145, 150, 158, 162, 170]
+_BODY_RX = [4, 3, 4.5, 4, 6.5, 8, 9.5, 8, 7, 8.5, 10, 9, 8.5, 11.5, 3.5, 3, 5.5, 4.5]
+_BODY_RY = [3, 2.5, 4, 4, 6, 7.5, 8.5, 7.5, 6.5, 8, 9, 8, 7.5, 8, 3.5, 3, 5, 4.5]
+
+R_NECK = 5.5
+R_WRIST = 3.5
+
+PIECE_COLORS = {
+    'Front Bodice': '#5B9BD5', 'Back Bodice': '#4472C4',
+    'Sleeve': '#6BB3E0', 'Collar': '#FFFFFF', 'Cuff': '#E8E8E8',
+    'Front Skirt': '#C48BB8', 'Back Skirt': '#A86CA8',
+    'Front Pant': '#2C5F8A', 'Back Pant': '#1A4570',
+    'Waistband': '#333333', 'Hood': '#3A7BD5', 'Pocket': '#7A7A7A',
+}
 
 
-# ── Body mannequin ──────────────────────────────────────────────────────────
-def _make_body():
-    """Create the translucent mannequin body."""
-    X, Y, Z = _revolution_surface(_BODY_Z, _BODY_RX, _BODY_RY, n_theta=48)
+def _point_in_polygon(x, y, polygon):
+    n = len(polygon)
+    inside = False
+    j = n - 1
+    for i in range(n):
+        xi, yi = polygon[i]
+        xj, yj = polygon[j]
+        if ((yi > y) != (yj > y)) and (x < (xj - xi) * (y - yi) / (yj - yi + 1e-12) + xi):
+            inside = not inside
+        j = i
+    return inside
+
+
+def _triangulate_piece(pts_2d, nu=16, nv=16):
+    pts = np.array(pts_2d, dtype=float)
+    if len(pts) < 3:
+        return pts, np.zeros((0, 3), dtype=int)
+    if np.allclose(pts[0], pts[-1]):
+        pts = pts[:-1]
+
+    x_min, x_max = pts[:, 0].min(), pts[:, 0].max()
+    y_min, y_max = pts[:, 1].min(), pts[:, 1].max()
+    dx = max(x_max - x_min, 0.1)
+    dy = max(y_max - y_min, 0.1)
+
+    us = np.linspace(x_min - dx * 0.01, x_max + dx * 0.01, nu)
+    vs = np.linspace(y_min - dy * 0.01, y_max + dy * 0.01, nv)
+
+    grid_idx = -np.ones((nv, nu), dtype=int)
+    valid_pts = []
+    for i in range(nv):
+        for j in range(nu):
+            if _point_in_polygon(us[j], vs[i], pts):
+                grid_idx[i, j] = len(valid_pts)
+                valid_pts.append([us[j], vs[i]])
+
+    if len(valid_pts) < 3:
+        return _triangulate_fan(pts)
+
+    tris = []
+    for i in range(nv - 1):
+        for j in range(nu - 1):
+            a, b = grid_idx[i, j], grid_idx[i, j + 1]
+            c, d = grid_idx[i + 1, j], grid_idx[i + 1, j + 1]
+            if a >= 0 and b >= 0 and c >= 0:
+                tris.append([a, b, c])
+            if b >= 0 and c >= 0 and d >= 0:
+                tris.append([b, d, c])
+
+    if len(tris) == 0:
+        return _triangulate_fan(pts)
+    return np.array(valid_pts), np.array(tris)
+
+
+def _triangulate_fan(pts):
+    n = len(pts)
+    if n < 3:
+        return pts, np.zeros((0, 3), dtype=int)
+    centroid = pts.mean(axis=0, keepdims=True)
+    all_pts = np.vstack([pts, centroid])
+    tris = np.array([[i, (i + 1) % n, n] for i in range(n)])
+    return all_pts, tris
+
+
+def _wrap_cylinder(pts_2d, radius, z_bottom, z_top, angle_start, angle_range,
+                   x_offset=0.0, y_offset=0.0):
+    pts = np.array(pts_2d, dtype=float)
+    x_min, x_max = pts[:, 0].min(), pts[:, 0].max()
+    y_min, y_max = pts[:, 1].min(), pts[:, 1].max()
+    x_norm = (pts[:, 0] - x_min) / max(x_max - x_min, 0.01)
+    y_norm = (pts[:, 1] - y_min) / max(y_max - y_min, 0.01)
+    theta = angle_start + x_norm * angle_range
+    z = z_bottom + y_norm * (z_top - z_bottom)
+    x_3d = radius * np.cos(theta) + x_offset
+    y_3d = radius * np.sin(theta) + y_offset
+    return np.stack([x_3d, y_3d, z], axis=1)
+
+
+def _wrap_cone(pts_2d, r_top, r_bottom, z_top, z_bottom, angle_start, angle_range):
+    pts = np.array(pts_2d, dtype=float)
+    x_min, x_max = pts[:, 0].min(), pts[:, 0].max()
+    y_min, y_max = pts[:, 1].min(), pts[:, 1].max()
+    x_norm = (pts[:, 0] - x_min) / max(x_max - x_min, 0.01)
+    y_norm = (pts[:, 1] - y_min) / max(y_max - y_min, 0.01)
+    theta = angle_start + x_norm * angle_range
+    z = z_top - y_norm * (z_top - z_bottom)
+    radius = r_top + y_norm * (r_bottom - r_top)
+    x_3d = radius * np.cos(theta)
+    y_3d = radius * np.sin(theta)
+    return np.stack([x_3d, y_3d, z], axis=1)
+
+
+def _wrap_sleeve(pts_2d, side='right', shoulder_x=14.0, shoulder_z=142.0,
+                 arm_length=35.0, arm_angle_deg=25.0, r_top=5.5, r_bottom=3.5):
+    pts = np.array(pts_2d, dtype=float)
+    x_min, x_max = pts[:, 0].min(), pts[:, 0].max()
+    y_min, y_max = pts[:, 1].min(), pts[:, 1].max()
+    x_norm = (pts[:, 0] - x_min) / max(x_max - x_min, 0.01)
+    y_norm = (pts[:, 1] - y_min) / max(y_max - y_min, 0.01)
+    theta = x_norm * 2 * np.pi
+    t_arm = 1.0 - y_norm
+    radius = r_top + t_arm * (r_bottom - r_top)
+    lx = radius * np.cos(theta)
+    ly = -t_arm * arm_length
+    lz = radius * np.sin(theta)
+    ang = np.radians(arm_angle_deg)
+    rx = lx * np.cos(ang) - ly * np.sin(ang)
+    rz_local = lx * np.sin(ang) + ly * np.cos(ang)
+    sign = 1.0 if side == 'right' else -1.0
+    return np.stack([sign * (rx + shoulder_x), lz, rz_local + shoulder_z], axis=1)
+
+
+def _wrap_pant_leg(pts_2d, side='right', hip_x=5.0, z_top=88.0, z_bottom=7.0,
+                   r_top=8.5, r_bottom=4.5, is_front=True):
+    pts = np.array(pts_2d, dtype=float)
+    x_min, x_max = pts[:, 0].min(), pts[:, 0].max()
+    y_min, y_max = pts[:, 1].min(), pts[:, 1].max()
+    x_norm = (pts[:, 0] - x_min) / max(x_max - x_min, 0.01)
+    y_norm = (pts[:, 1] - y_min) / max(y_max - y_min, 0.01)
+    if is_front:
+        theta = -np.pi / 2 + x_norm * np.pi
+    else:
+        theta = np.pi / 2 + x_norm * np.pi
+    z = z_bottom + y_norm * (z_top - z_bottom)
+    radius = r_bottom + y_norm * (r_top - r_bottom)
+    sign = 1.0 if side == 'right' else -1.0
+    x_3d = sign * hip_x + radius * np.cos(theta)
+    y_3d = radius * np.sin(theta)
+    return np.stack([x_3d, y_3d, z], axis=1)
+
+
+def _wrap_hood(pts_2d, z_base=145.0, z_top=172.0, r_base=12.0, r_top=7.0):
+    pts = np.array(pts_2d, dtype=float)
+    x_min, x_max = pts[:, 0].min(), pts[:, 0].max()
+    y_min, y_max = pts[:, 1].min(), pts[:, 1].max()
+    x_norm = (pts[:, 0] - x_min) / max(x_max - x_min, 0.01)
+    y_norm = (pts[:, 1] - y_min) / max(y_max - y_min, 0.01)
+    theta = x_norm * np.pi
+    z = z_base + y_norm * (z_top - z_base)
+    radius = r_base + y_norm * (r_top - r_base)
+    radius *= (1.0 - 0.3 * y_norm ** 2)
+    x_3d = radius * np.cos(theta)
+    y_3d = radius * np.sin(theta) - 3
+    return np.stack([x_3d, y_3d, z], axis=1)
+
+
+def _match_piece_type(name):
+    name_lower = name.lower()
+    if 'front bodice' in name_lower: return 'front_bodice'
+    if 'back bodice' in name_lower: return 'back_bodice'
+    if 'sleeve' in name_lower: return 'sleeve'
+    if 'collar' in name_lower: return 'collar'
+    if 'cuff' in name_lower: return 'cuff'
+    if 'front skirt' in name_lower: return 'front_skirt'
+    if 'back skirt' in name_lower: return 'back_skirt'
+    if 'front pant' in name_lower: return 'front_pant'
+    if 'back pant' in name_lower: return 'back_pant'
+    if 'waistband' in name_lower: return 'waistband'
+    if 'hood' in name_lower: return 'hood'
+    if 'pocket' in name_lower: return 'pocket'
+    return 'unknown'
+
+
+def _get_piece_color(name):
+    for key, color in PIECE_COLORS.items():
+        if key.lower() in name.lower():
+            return color
+    return '#888888'
+
+
+def _make_body_trace():
+    theta = np.linspace(0, 2 * np.pi, 48)
+    z_arr = np.array(_BODY_Z, float)
+    rx = np.array(_BODY_RX, float)
+    ry = np.array(_BODY_RY, float)
+    Z = np.outer(z_arr, np.ones(48))
+    X = np.outer(rx, np.cos(theta))
+    Y = np.outer(ry, np.sin(theta))
     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",
+        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)
-    shoulder = params.get("shoulder_width", 42)
-    bodice_len = params.get("bodice_length", 72)
-    sleeve_len = params.get("sleeve_length", 60)
-    bicep = params.get("bicep", 30)
-    wrist_circ = params.get("wrist", 18)
-    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 = []
-
-    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:
-            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 + (bust_rx * 0.92 - bust_rx) * f
-            ry = bust_ry + (bust_ry * 0.92 - bust_ry) * f
-        else:
-            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]:
-        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)
-        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 _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)
-    fit = params.get("fit", "regular")
-    flare = params.get("flare", 0)
-
-    ease = {"fitted": 0.5, "regular": 1.0, "oversized": 2.5, "loose": 2.0}.get(fit, 1.0)
-
-    surfaces = []
-
-    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 _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)
-    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
-            rx = waist_rx + (hip_rx - waist_rx) * f
-            ry = waist_ry + (hip_ry - waist_ry) * f
-        else:
-            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:
-            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
-
-
-# ── 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 on a mannequin body."""
+def create_3d_figure(analysis: Dict, pattern_pieces: Optional[List[Dict]] = None) -> go.Figure:
     garment_type = analysis.get("garment_type", "shirt").lower()
     measurements = analysis.get("measurements", {})
     features = analysis.get("features", {})
-    params = {**measurements, **features}
 
     fig = go.Figure()
+    fig.add_trace(_make_body_trace())
 
-    # Mannequin body
-    fig.add_trace(_make_body())
+    if pattern_pieces is None or len(pattern_pieces) == 0:
+        _setup_layout(fig, garment_type)
+        return fig
 
-    # Garment surfaces
-    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)
+    for piece in pattern_pieces:
+        name = piece['name']
+        pts_2d = piece['points']
+        piece_type = _match_piece_type(name)
+        color = _get_piece_color(name)
 
-    # Scene layout
+        mesh_pts, tris = _triangulate_piece(pts_2d)
+        if len(tris) == 0:
+            continue
+
+        traces = _wrap_piece(piece_type, mesh_pts, tris, name, color,
+                             measurements, features, garment_type)
+        for trace in traces:
+            fig.add_trace(trace)
+
+    _setup_layout(fig, garment_type)
+    return fig
+
+
+def _wrap_piece(piece_type, mesh_pts, tris, name, color,
+                measurements, features, garment_type):
+    traces = []
+    bust = measurements.get('bust', 92)
+    waist = measurements.get('waist', 74)
+    hip = measurements.get('hip', 96)
+    sleeve_len = measurements.get('sleeve_length', 60)
+    skirt_len = measurements.get('skirt_length', 55)
+    pant_len = measurements.get('pant_length', 100)
+
+    r_torso = bust / (2 * np.pi) + 1.5
+    r_waist = waist / (2 * np.pi) + 1.5
+    r_hip = hip / (2 * np.pi) + 1.5
+
+    if piece_type == 'front_bodice':
+        pts_3d = _wrap_cylinder(mesh_pts, r_torso, Z_WAIST, Z_SHOULDER,
+                                -np.pi / 2, np.pi)
+        traces.append(_make_mesh3d(pts_3d, tris, color, name))
+
+    elif piece_type == 'back_bodice':
+        pts_3d = _wrap_cylinder(mesh_pts, r_torso, Z_WAIST, Z_SHOULDER,
+                                np.pi / 2, np.pi)
+        traces.append(_make_mesh3d(pts_3d, tris, color, name))
+
+    elif piece_type == 'sleeve':
+        shoulder_x = r_torso + 1.0
+        for side in ['right', 'left']:
+            pts_3d = _wrap_sleeve(mesh_pts, side=side, shoulder_x=shoulder_x,
+                                  shoulder_z=Z_SHOULDER - 2,
+                                  arm_length=sleeve_len * 0.55,
+                                  arm_angle_deg=25, r_top=5.5, r_bottom=3.5)
+            traces.append(_make_mesh3d(pts_3d, tris, color,
+                                       f"{name} ({'R' if side == 'right' else 'L'})"))
+
+    elif piece_type == 'collar':
+        pts_3d = _wrap_cylinder(mesh_pts, R_NECK + 1.0, Z_NECK - 2, Z_NECK + 3,
+                                -np.pi, 2 * np.pi)
+        traces.append(_make_mesh3d(pts_3d, tris, color, name))
+
+    elif piece_type == 'cuff':
+        for side in ['right', 'left']:
+            sign = 1.0 if side == 'right' else -1.0
+            wrist_x = sign * (r_torso + sleeve_len * 0.3 + 2)
+            wrist_z = Z_SHOULDER - sleeve_len * 0.5
+            pts_3d = _wrap_cylinder(mesh_pts, R_WRIST + 0.5,
+                                    wrist_z - 3, wrist_z,
+                                    0, 2 * np.pi, x_offset=wrist_x)
+            traces.append(_make_mesh3d(pts_3d, tris, color,
+                                       f"{name} ({'R' if side == 'right' else 'L'})"))
+
+    elif piece_type == 'front_skirt':
+        hem_z = max(Z_WAIST - skirt_len, Z_ANKLE)
+        flare = measurements.get('flare', 5)
+        r_hem = r_hip + flare * 0.5
+        pts_3d = _wrap_cone(mesh_pts, r_waist, r_hem, Z_WAIST, hem_z,
+                            -np.pi / 2, np.pi)
+        traces.append(_make_mesh3d(pts_3d, tris, color, name))
+
+    elif piece_type == 'back_skirt':
+        hem_z = max(Z_WAIST - skirt_len, Z_ANKLE)
+        flare = measurements.get('flare', 5)
+        r_hem = r_hip + flare * 0.5
+        pts_3d = _wrap_cone(mesh_pts, r_waist, r_hem, Z_WAIST, hem_z,
+                            np.pi / 2, np.pi)
+        traces.append(_make_mesh3d(pts_3d, tris, color, name))
+
+    elif piece_type == 'front_pant':
+        hem_z = max(Z_HIP - pant_len * 0.85, Z_ANKLE)
+        thigh_circ = measurements.get('thigh', 56)
+        ankle_circ = measurements.get('ankle', 24)
+        r_thigh = thigh_circ / (2 * np.pi) + 1
+        r_ankle_r = ankle_circ / (2 * np.pi) + 1
+        for side in ['right', 'left']:
+            pts_3d = _wrap_pant_leg(mesh_pts, side=side, hip_x=r_hip * 0.4,
+                                    z_top=Z_HIP, z_bottom=hem_z,
+                                    r_top=r_thigh, r_bottom=r_ankle_r, is_front=True)
+            traces.append(_make_mesh3d(pts_3d, tris, color,
+                                       f"{name} ({'R' if side == 'right' else 'L'})"))
+
+    elif piece_type == 'back_pant':
+        hem_z = max(Z_HIP - pant_len * 0.85, Z_ANKLE)
+        thigh_circ = measurements.get('thigh', 56)
+        ankle_circ = measurements.get('ankle', 24)
+        r_thigh = thigh_circ / (2 * np.pi) + 1
+        r_ankle_r = ankle_circ / (2 * np.pi) + 1
+        for side in ['right', 'left']:
+            pts_3d = _wrap_pant_leg(mesh_pts, side=side, hip_x=r_hip * 0.4,
+                                    z_top=Z_HIP, z_bottom=hem_z,
+                                    r_top=r_thigh, r_bottom=r_ankle_r, is_front=False)
+            traces.append(_make_mesh3d(pts_3d, tris, color,
+                                       f"{name} ({'R' if side == 'right' else 'L'})"))
+
+    elif piece_type == 'waistband':
+        wb_h = measurements.get('waistband_height', 4)
+        pts_3d = _wrap_cylinder(mesh_pts, r_waist + 0.5, Z_WAIST, Z_WAIST + wb_h,
+                                -np.pi, 2 * np.pi)
+        traces.append(_make_mesh3d(pts_3d, tris, color, name))
+
+    elif piece_type == 'hood':
+        pts_3d_r = _wrap_hood(mesh_pts, z_base=Z_SHOULDER, z_top=Z_HEAD + 2,
+                              r_base=r_torso, r_top=7)
+        traces.append(_make_mesh3d(pts_3d_r, tris, color, f"{name} (R)"))
+        pts_3d_l = pts_3d_r.copy()
+        pts_3d_l[:, 0] = -pts_3d_l[:, 0]
+        traces.append(_make_mesh3d(pts_3d_l, tris, color, f"{name} (L)"))
+
+    elif piece_type == 'pocket':
+        pocket_z = (Z_WAIST + Z_BUST) / 2
+        pts_3d = _wrap_cylinder(mesh_pts, r_torso + 0.3,
+                                pocket_z - 8, pocket_z, -0.3, 0.6)
+        traces.append(_make_mesh3d(pts_3d, tris, color, name))
+
+    return traces
+
+
+def _make_mesh3d(pts_3d, tris, color, name):
+    return go.Mesh3d(
+        x=pts_3d[:, 0], y=pts_3d[:, 1], z=pts_3d[:, 2],
+        i=tris[:, 0], j=tris[:, 1], k=tris[:, 2],
+        color=color, opacity=0.85, name=name,
+        flatshading=False,
+        lighting=dict(ambient=0.55, diffuse=0.8, specular=0.2, roughness=0.6),
+        lightposition=dict(x=100, y=200, z=300),
+        hoverinfo="name",
+    )
+
+
+def _setup_layout(fig, garment_type):
     fig.update_layout(
         scene=dict(
             xaxis=dict(showgrid=False, showticklabels=False, title="",
-                       zeroline=False, range=[-35, 35]),
+                       zeroline=False, range=[-40, 40]),
             yaxis=dict(showgrid=False, showticklabels=False, title="",
-                       zeroline=False, range=[-35, 35]),
+                       zeroline=False, range=[-40, 40]),
             zaxis=dict(showgrid=False, showticklabels=False, title="",
                        zeroline=False, range=[0, 180]),
             aspectmode="data",
-            camera=dict(
-                eye=dict(x=1.8, y=1.2, z=0.5),
-                center=dict(x=0, y=0, z=-0.1),
-            ),
+            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)),
+        title=dict(text=f"3D Preview: {garment_type.title()} (from pattern pieces)",
+                   font=dict(size=14)),
         paper_bgcolor="#fafafa",
+        showlegend=True,
+        legend=dict(font=dict(size=10), bgcolor="rgba(255,255,255,0.8)"),
     )
-
-    return fig