Function tryCollapse

js/regularize.js:392–525

(u, v)

  // unrelated texels.  thinness catches it (≈ 1800 in that case) while still
  // reporting ≈ 1.15 for an equilateral triangle, so the threshold scale is
  // similar to the old edge-ratio metric.
  function triAspectSq(t) {
    const a = corners[t*3], b = corners[t*3+1], c = corners[t*3+2];
    const ax = vertX[a], ay = vertY[a], az = vertZ[a];
    const abx = vertX[b]-ax, aby = vertY[b]-ay, abz = vertZ[b]-az;
    const acx = vertX[c]-ax, acy = vertY[c]-ay, acz = vertZ[c]-az;
    const bcx = vertX[c]-vertX[b], bcy = vertY[c]-vertY[b], bcz = vertZ[c]-vertZ[b];
    const lAB2 = abx*abx + aby*aby + abz*abz;
    const lAC2 = acx*acx + acy*acy + acz*acz;
    const lBC2 = bcx*bcx + bcy*bcy + bcz*bcz;
    const lmax2 = Math.max(lAB2, lAC2, lBC2);
    const nx = aby*acz - abz*acy;
    const ny = abz*acx - abx*acz;
    const nz = abx*acy - aby*acx;
    const cross2 = nx*nx + ny*ny + nz*nz;
    return cross2 > 0 ? lmax2 * lmax2 / cross2 : Infinity;
  }

  function countDeleted() {
    let n = 0;
    for (let i = 0; i < triCount; i++) if (triDeleted[i]) n++;
    return n;
  }

  // Attempt collapse of edge (u, v).  Returns true if applied.
  function tryCollapse(u, v) {
    if (u === v) return false;

    // Sharp-edge vertices stay put — refuse the collapse outright.
    if (frozenVert[u] || frozenVert[v]) { rejectStats.frozen++; return false; }

    // Wing triangles — must be exactly 2 (manifold interior edge).
    const wings = trianglesSharingEdge(u, v);
    if (wings.length !== 2) { rejectStats.wingCount++; return false; }

    const apexW1 = thirdVertex(wings[0], u, v);
    const apexW2 = thirdVertex(wings[1], u, v);
    if (apexW1 === apexW2) { rejectStats.foldedApex++; return false; }

    // Two-tier gate selection.  Edge-cap loosens if EITHER wing is extreme
    // (cheap to relax — easy to recover from with re-subdivide).  Normal-cap
    // loosens only if BOTH wings are extreme (asymmetric: protects fillets).
    const w1Asp2 = triAspectSq(wings[0]);
    const w2Asp2 = triAspectSq(wings[1]);
    const eitherExtreme = w1Asp2 > extremeAspect2 || w2Asp2 > extremeAspect2;
    const bothExtreme   = w1Asp2 > extremeAspect2 && w2Asp2 > extremeAspect2;
    const effMaxLenSq  = eitherExtreme ? aggressiveMaxLenSqAllowed : baseMaxLenSqAllowed;
    const effNormalCos = bothExtreme   ? aggressiveNormalDeltaCos  : maxNormalDeltaCos;


    // Link condition — vertices that share a triangle with BOTH u and v
    // (other than the wing apexes) would become non-manifold after the merge.
    // Stamp v's neighbours, then scan u's neighbours against the stamps.
    stampGen++;
    for (let s = vfHead[v]; s !== -1; s = slotNext[s]) {
      const t = (s / 3) | 0;
      if (triDeleted[t]) continue;
      const a = corners[t*3], b = corners[t*3+1], c = corners[t*3+2];