# Piupiu v3 — discrete flax strands on a rigid waistband.
#
#   python tools/md_bridge.py --file tools/tailor/md_piupiu_v3.py --timeout 600
#
# v2 stays untouched; backup in tools/tailor/backup/2026-07-31-pre-v3/.
# Continuous-panel variant kept at md_piupiu_v3_flare_fallback.py — reach for it
# only if strands prove unworkable.
#
# ── WHY ──────────────────────────────────────────────────────────────────────
# v2 is a taut pencil wrap: waist cut 1000 mm against Lena's 1095 mm hips, so it
# arrives stretched over the thighs with 1-3 cm ease (the skirt-rig session
# measured cloth at r 0.19-0.24 m against body r 0.18-0.22 m). Downstream agrees:
# G3 finds 8 mm penetration AT REST, G5 finds 216-231 verts up to 8.5 cm deep
# across Idle/Walk.
#
# A real piupiu is discrete hanging flax strands, not a closed tube. Modelling it
# that way is the cheapest fix available, because it changes what counts as a
# defect: leg visible BETWEEN strands is correct, and strands cannot crease the way
# a continuous panel does. It also happens to match the spring rig exactly — the
# ring IS 8 strands (skirt_00…skirt_07), so 32 strands = 4 per bundle, and each
# bundle swings independently instead of dragging a tube with it.
#
# ── CONSTRUCTION ─────────────────────────────────────────────────────────────
# Two comb-shaped panels: a 60 mm solid band with M teeth cut into the OUTLINE,
# reaching all the way up to the band. Only the two band side edges are sewn —
# whole-edge seams, per doctrine. 24-32 partial seams (one per strand) were
# considered and rejected: the failure catalogue says partial seams twist
# unpredictably, and cutting shapes into the outline is how the tee's neck gap and
# armholes were done.
#
# The panel is a TRAPEZOID comb, not a rectangular one. Teeth cannot be wider at
# the hem than their pitch, so hem fullness has to come from flaring the panel
# itself: band edge W_TOP, hem edge W_HEM, teeth cut from the flared body.
#
# Waistband is cut SMALLER than the hips (750 mm vs 1095 mm) so the hip below
# physically blocks it from sliding — no elastic needed, and it keeps the
# waistband rigid, which the rig requires (a waistband that swings reads broken).
# MD arranges cloth at the arrangement point rather than simulating donning, so
# "must pass over the hips" is a real-world constraint that does not apply here.
#
# ── WHAT THIS ANSWERS FROM THE SKIRT-RIG SESSION ─────────────────────────────
#   ask 2 (more ease)      → COLLISION_MM standoff + strand flare
#   ask 3 (real strands)   → this file; approved by Jeremy 2026-07-31
#   ask 4 (even density)   → every strand is an identical strip, so azimuthal
#                            density is uniform BY CONSTRUCTION (was 5-6:1), and
#                            PARTICLE_MM sets the vertical row count directly
#   ask 5 (verts above the ring) → the wrap-overlap fold is gone; a 60 mm band
#                            puts ~17% of verts above y 0.952, not 40%
#   ask 1 (32 skirt joints) is NOT solvable here — it needs their 32-bone
#                            SkirtRig body first, then a pipeline re-export.
#
# HONEST LIMIT: hem target 0.45 m sits 0.495 m below the hip pivot, so 30 deg of
# hip flexion sweeps the leg ~25 cm forward. No believable piupiu silhouette
# clears that. Strands make the residual legible instead of wrong; the spring rig
# still does the last part of the job.
#
# QC targets (tools/tailor/qc_placement.py verifies): waistband top 1.05 m +-3 cm,
# hem 0.45 m +-4 cm. G1 measured v2 at +8 cm / +14 cm off, so expect to correct
# placement either via ARR_Y here or `align.z_nudge` in the downstream config.
import os
import tempfile

# ── parameters — this block exists so iteration is one edit ───────────────────
M_TEETH = 16       # strands PER PANEL. x2 = 32 total = 4 per rig bundle.
W_TOP = 375.0      # mm, band edge per panel.  x2 = 750 (waist 675 + 75 ease)
W_HEM = 700.0      # mm, hem edge per panel.   x2 = 1400 of flare
BAND_H = 60.0      # mm, solid waistband depth — the part that must ride rigidly
STRAND_H = 530.0   # mm. 570 measured a 0.672 m span (band 1.087 / hem 0.415)
                   # but the QC targets imply 0.60; 530 puts BOTH in tolerance.
GAP_TOP = 6.0      # mm, slit width at the band
GAP_HEM = 11.0     # mm, slit width at the hem
PARTICLE_MM = 20.0 # sim/mesh resolution. Lower = more vertical rows per strand,
                   # which ask 4 also wants between bone joints. 20 gives ~29 rows
                   # per strand; 15 gives ~38 and blows the vert budget.
COLLISION_MM = 10.0    # Additional Thickness - Collision: MD resolves the cloth
                       # standing off the skin. Better than the downstream `fit`
                       # normal-push, which self-intersects between touching thighs.
ARR_FRONT = "Leg_Skirt_Front"   # NOT Body_*_Waist. v2 used the body-waist points
ARR_BACK = "Leg_Skirt_Back"     # and G1 measured it +8/+14 cm high; the skill
                                # prescribes the Leg_Skirt_* points for skirts.
ARR_X_FRONT = 50   # These MUST DIFFER. Swept all four combos with a validated control
ARR_X_BACK = 0     # (md_piupiu_arrsweep.py): 50/0 and 0/50 both drape correctly
                   # (band top 1.093 / 1.095), while 50/50 and 0/0 make the skirt FALL TO
                   # THE FLOOR (band top 0.10 / 0.14). So for Leg_Skirt_Front/Back the x
                   # arg selects which half each panel wraps and the split is load-bearing
                   # - NOT a copy-paste artefact. Note this is the OPPOSITE of the top,
                   # where Body_*_Center_1 needed x MATCHED on both panels. Do not
                   # "harmonise" these two recipes.
ARR_Y = 92         # per the skill's skirt recipe: SetArrangementPosition(p,x,92,50).
                   # NB: SetArrangementPosition takes 4 INTS — a float raises.
                   # A 60 mm band has far less mass than v2's solid panel, so it
                   # does NOT slide down to the waist on its own — it stays where
                   # it is arranged. Arrangement height IS the placement here.
ZFAB = r"C:\Users\Public\Documents\MarvelousDesigner\New Assets\Fabric\(Default for Simulation).zfab"
# fabric_api has NO physics setters — stiffness comes from the .zfab. If thin
# strands curl or the flare collapses, climb this ladder (one change at a time):
#   V2_Woven_Canvas_1.zfab  <  V2_Woven_Denim_1.zfab  <  V2_Non-Fabric_Tyvek_1.zfab
PLAIN = False       # Judge SHAPE with the texture off. Cloth is white on its front face
                   # and grey on its back, so a panel showing grey from outside is inside
                   # out and a white streak is a fold. The piupiu texture is vertical
                   # strands on a busy band - it hides both. See the skill's
                   # references/tooling.md SS0 and SS1.3.
EXPORT = True      # band side seams fixed + arrangement split verified 2026-07-31
VERSION = "v3"

AVATAR_FBX = r"C:\Users\Jeremy\tinqs\animation\tools\tailor\avatar\Lena_QuatSkin_Avatar.fbx"
TEX = r"C:\Users\Jeremy\tinqs\animation\tools\tailor\textures\piupiu.png"
OUT = r"C:\Users\Jeremy\tinqs\animation\tools\tailor"
SHOTS = r"C:\Users\Jeremy\tinqs\animation\tools\tailor\screenshots"

report = {"params": {"M_TEETH": M_TEETH, "W_TOP": W_TOP, "W_HEM": W_HEM,
                     "BAND_H": BAND_H, "STRAND_H": STRAND_H,
                     "GAP_TOP": GAP_TOP, "GAP_HEM": GAP_HEM,
                     "PARTICLE_MM": PARTICLE_MM, "COLLISION_MM": COLLISION_MM,
                     "ARR_Y": ARR_Y, "zfab": os.path.basename(ZFAB),
                     "EXPORT": EXPORT}}

utility_api.NewProject()            # NB: deletes the avatar — import after
op = ApiTypes.ImportExportOption()
op.scale = 10.0                     # Blender-exported FBX avatars import 10x small
op.bAddArrangementPoints = True     # else there is nowhere to hang cloth
op.bAutoTranslate = True
report["avatar"] = import_api.ImportFBX(AVATAR_FBX, op)

# ── the comb outline ─────────────────────────────────────────────────────────
# 2D y+ maps to UP in 3D, so hem sits at y=0 and the band top at y=BAND_TOP.
# Drafting y-down drapes the garment upside-down over the head.
BAND_TOP = STRAND_H + BAND_H
BAND_BOT = STRAND_H
INSET = (W_HEM - W_TOP) / 2.0       # trapezoid: band edge centred over the hem edge

pitch_top = W_TOP / M_TEETH
pitch_hem = W_HEM / M_TEETH
report["strand_mm"] = {"at_band": round(pitch_top - GAP_TOP, 1),
                       "at_hem": round(pitch_hem - GAP_HEM, 1),
                       "hem_cloth_total": round(2 * M_TEETH * (pitch_hem - GAP_HEM), 1)}

def outline(dx):
    """Comb: band top, band RIGHT edge, M teeth right-to-left, band LEFT edge.

    Both band side edges are exact 60 mm VERTICALS and both end teeth get a half-gap,
    so the two panels meet symmetrically. The first version got this wrong in two ways
    and it produced a notch with the cloth's reverse face showing at the side seams:
      - for j = M-1 it skipped the band-bottom step point, so the rightmost tooth sat
        FLUSH with the panel edge and was GAP_TOP/2 wider than every other tooth;
      - it closed straight from the last tooth to the band's top-left corner, making
        the LEFT band edge a slanted 60.07 mm instead of a vertical 60.0 mm.
    Sewing a flush tooth to a half-gapped one across a slanted seam is what folded it.
    The seam-length fingerprint showed this as [60.0, 60.075, 60.0, 60.075] - unequal
    paired edges are never "close enough".
    """
    pts = [(INSET, BAND_TOP), (INSET + W_TOP, BAND_TOP), (INSET + W_TOP, BAND_BOT)]
    for j in range(M_TEETH - 1, -1, -1):
        ta = INSET + j * pitch_top + GAP_TOP / 2.0          # tooth left  @ band
        tb = INSET + (j + 1) * pitch_top - GAP_TOP / 2.0    # tooth right @ band
        ha = j * pitch_hem + GAP_HEM / 2.0                  # tooth left  @ hem
        hb = (j + 1) * pitch_hem - GAP_HEM / 2.0            # tooth right @ hem
        pts.append((tb, BAND_BOT))       # ALWAYS - including j = M-1 (the old bug)
        pts.append((hb, 0.0))            # down the tooth's right side
        pts.append((ha, 0.0))            # across the hem
        pts.append((ta, BAND_BOT))       # up the tooth's left side
    pts.append((INSET, BAND_BOT))        # band bottom-left corner, so the closing
                                         # LEFT band edge is a true vertical
    return [(x + dx, y, 0) for (x, y) in pts]

pts_f = outline(0.0)
pts_b = outline(W_HEM + 400.0)
sf = pattern_api.CreatePatternWithPoints(pts_f)
sb = pattern_api.CreatePatternWithPoints(pts_b)
report["ids"] = [sf, sb]

# Line indices follow from the point order above: 0 = band top, 1 = band RIGHT
# edge, last = band LEFT edge. Everything between is teeth and must stay unsewn.
L_RIGHT = 1
L_LEFT = len(pts_f) - 1
report["lines"] = {"n_points": len(pts_f), "L_RIGHT": L_RIGHT, "L_LEFT": L_LEFT}
# Fingerprint by length, per doctrine — a band side edge is ~BAND_H long, so if
# these come back near BAND_H the indices are right and the seams are safe.
try:
    report["seam_line_lengths"] = [pattern_api.GetLineLength(sf, L_RIGHT),
                                   pattern_api.GetLineLength(sf, L_LEFT),
                                   pattern_api.GetLineLength(sb, L_RIGHT),
                                   pattern_api.GetLineLength(sb, L_LEFT)]
except Exception as e:
    report["line_length_error"] = "%s: %s" % (type(e).__name__, e)

# Panels are identical, not mirrored, so right↔left rather than same-index.
pattern_api.AddSeamlinePairGroup(sf, L_RIGHT, sb, L_LEFT, False, False)
pattern_api.AddSeamlinePairGroup(sf, L_LEFT, sb, L_RIGHT, False, False)

fab = fabric_api.AddFabric(ZFAB)                          # never reuse index 0
if not PLAIN:
    fabric_api.SetBaseTextureMapImageGivenFilePath(TEX, fab)  # path is arg0
for p in (sf, sb):
    pattern_api.SetPatternPieceFabricIndex(p, fab)

for setter, val, key in ((pattern_api.SetParticleDistanceOfPattern, PARTICLE_MM, "particle"),
                         (pattern_api.SetAddlThicknessCollision, COLLISION_MM, "collision")):
    if not val:
        continue
    try:
        for p in (sf, sb):
            setter(p, val)
        report[key] = val
    except Exception as e:
        report[key + "_error"] = "%s: %s" % (type(e).__name__, e)

arr = {a["ArrangementName"]: int(a["ArrangementIndex"])
       for a in pattern_api.GetArrangementList()}   # indices regenerate per import
pattern_api.SetArrangement(sf, arr[ARR_FRONT])
pattern_api.SetArrangement(sb, arr[ARR_BACK])
# The x arg MUST match across panels. This recipe inherited front=50 / back=0 from
# md_piupiu.py, and that asymmetry folded ONE SIDE only: turntable side B showed a
# waistband flap jutting out with a grey reverse-face wedge and a strand group folded
# over itself, while side A was clean. The identical 50/0 pair folded one shoulder of
# the top. An asymmetric defect needs an asymmetric input, and this is the only one.
pattern_api.SetArrangementPosition(sf, ARR_X_FRONT, int(ARR_Y), 50)
pattern_api.SetArrangementPosition(sb, ARR_X_BACK, int(ARR_Y), 50)

pattern_api.SetPatternStrengthen(sf, True)      # stiff so cloth wraps, not crumples
pattern_api.SetPatternStrengthen(sb, True)
utility_api.ResetClothArrangement()             # SetArrangement only assigns

# The diagnostic that unsticks everything: where the panels actually start, before
# physics muddies it. Zero simulation frames. With a comb outline this is doubly
# worth it — it shows whether the teeth read as separate strands or the outline
# self-intersected.
utility_api.Refresh3DWindow()
utility_api.SetCamViewPoint(2)                  # front view, comparable shots
pre = os.path.join(tempfile.gettempdir(), "tinqs_md_piupiu_%s_presim.png" % VERSION)
export_api.ExportSnapshot3D(pre)
report["presim_snap"] = pre

report["sim1"] = utility_api.Simulate(250)      # main settle, still stiff
pattern_api.SetPatternStrengthen(sf, False)     # relax into natural folds
pattern_api.SetPatternStrengthen(sb, False)
report["sim2"] = utility_api.Simulate(50)
utility_api.Refresh3DWindow()

utility_api.SetCamViewPoint(2)
snap = os.path.join(SHOTS, "lena_piupiu_%s.png" % VERSION)
export_api.ExportSnapshot3D(snap)               # required repo review render
report["snap"] = snap

# SetCamViewPoint has NO REAR VIEW (0 bottom, 1/3 front quarters, 2 front, 4/6/7 sides,
# 5 top), so ExportSnapshot3D can never show the back. Every render of this garment so
# far has been a front view - the same blind spot that hid four defects in the top.
utility_api.SetCamViewPoint(5)                  # top-down: best view of a waistband
utility_api.Refresh3DWindow()
topv = os.path.join(tempfile.gettempdir(), "tinqs_md_piupiu_%s_top.png" % VERSION)
export_api.ExportSnapshot3D(topv)
report["top_snap"] = topv
utility_api.SetCamViewPoint(2)
report["turntable"] = export_api.ExportTurntableImages(4)   # idx 0 front, 1 side, 2 BACK

# ── measurement ──────────────────────────────────────────────────────────────
# qc_placement.py cannot read this garment: its pixel classifier needs a solid
# silhouette and a strand skirt is mostly gaps (it reported a 1.71 m span on the
# first v3 drape — nonsense). Measure the geometry instead. Export a throwaway OBJ
# and read the verts: exact, and it also answers the skirt-rig session's ease
# question directly, in the same radius units they measured (body r 0.18-0.22 m).
mop = ApiTypes.ImportExportOption()
mop.bExportGarment = True
mop.bExportAvatar = False
probe = os.path.join(tempfile.gettempdir(), "tinqs_md_piupiu_%s_probe.obj" % VERSION)
export_api.ExportOBJ(probe, mop)

vs = []
with open(probe) as fh:
    for line in fh:
        if line.startswith("v "):
            _, x, y, z = line.split()[:4]
            vs.append((float(x), float(y), float(z)))
if vs:
    # OBJ exports in MM (measured: raw 1086.9 == 1.0869 m). Note this differs from
    # the FBX path, where the census reads decimetres and align.scale_z of 0.1
    # converts — the two exporters do not agree on units.
    S = 0.001
    zs = sorted(v[1] * S for v in vs)          # OBJ y is up
    cx = sum(v[0] for v in vs) / len(vs)
    cz = sum(v[2] for v in vs) / len(vs)
    def band(lo, hi):
        r = [((v[0] - cx) ** 2 + (v[2] - cz) ** 2) ** 0.5 * S
             for v in vs if lo <= v[1] * S <= hi]
        if not r:
            return None
        r.sort()
        return {"n": len(r), "r_med": round(r[len(r) // 2], 3),
                "r_max": round(r[-1], 3)}
    report["measured"] = {
        "verts": len(vs),
        "band_top_m": round(zs[-1], 3),      # target 1.05 +-0.03
        "hem_m": round(zs[0], 3),            # target 0.45 +-0.04
        "frac_above_ring_0952": round(sum(1 for z in zs if z > 0.952) / len(zs), 3),
        "radius_at_hip_0.90_0.96": band(0.90, 0.96),
        "radius_at_thigh_0.82_0.88": band(0.82, 0.88),
        "radius_at_knee_0.50_0.56": band(0.50, 0.56),
    }

if EXPORT:
    base = os.path.join(OUT, "lena_piupiu_%s" % VERSION)
    eop = ApiTypes.ImportExportOption()
    eop.bExportGarment = True
    eop.bExportAvatar = False
    report["zprj"] = export_api.ExportZPrj(base + ".zprj")
    report["fbx"] = export_api.ExportFBX(base + "_garment.fbx", eop)
    report["obj"] = export_api.ExportOBJ(base + "_garment.obj", eop)
    report["zpac"] = export_api.ExportZPac(base + ".zpac")

result = report