The showcase prompt, round 3, Gemini 4 Carbon
agent (cont.)
+42:44read_file{"EndLine":1380,"Path":"~/run/index.html","StartLine":530}
input
{ "EndLine": 1380, "Path": "~/run/index.html", "StartLine": 530 }result, 801 lines
Showing lines 530-1329 of 3137 530: <!-- Floating Target & Glass Relief Sculptor Loupe --> 531: <div class="loupe-card" id="loupeCard"> 532: <div class="loupe-head"> 533: <div class="loupe-tabs"> 534: <button id="tabTarget" class="active">Target I(x,y)</button> 535: <button id="tabHeight">Glass h(x,y)</button> 536: </div> 537: <button class="loupe-toggle-btn" id="btnToggleLoupe" title="Minimize/Expand Pad">–</button> 538: </div> 539: <div class="loupe-body"> 540: <div class="pad-wrap"> 541: <canvas id="padCanvas" width="256" height="256"></canvas> 542: <div class="pad-badge" id="padBadge">Draw to carve lens</div> 543: </div> 544: <div class="sculpt-tools"> 545: <div class="tool-row"> 546: <button id="btnBrushDraw" class="active">✎ Glow Brush</button> 547: <button id="btnBrushErase">⌫ Erase</button> 548: <button id="btnPadClear">Clear</button> 549: </div> 550: <div class="text-input-row"> 551: <input type="text" id="glyphInput" maxlength="9" placeholder="Type word / symbol…" /> 552: <button id="btnCarveText">Carve</button> 553: </div> 554: </div> 555: </div> 556: </div> 557: 558: <script> 559: (() => { 560: "use strict"; 561: 562: // ============================================================================ 563: // 1. INLINE WEB WORKER: MULTISCALE MOSER–SNELL OPTIMAL TRANSPORT PDE SOLVER 564: // Solves nabla^2 psi = I_sim - I_target + Exact 3D Inverse Snell's Law 565: // using radix-2 Makhoul 2D DCT-II Neumann Poisson on 128x128 -> 256x256. 566: // ============================================================================ 567: const WORKER_SOURCE = ` 568: "use strict"; 569: class DCT2D { 570: constructor(N) { 571: this.N = N; 572: this.bitRev = new Uint32Array(N); 573: const bits = Math.log2(N) | 0; 574: for (let i = 0; i < N; i++) { 575: let r = 0, x = i; 576: for (let b = 0; b < bits; b++) { r = (r << 1) | (x & 1); x >>= 1; } 577: this.bitRev[i] = r; 578: } 579: this.cosTab = new Float32Array(N / 2); 580: this.sinTab = new Float32Array(N / 2); 581: for (let k = 0; k < N / 2; k++) { 582: const ang = -2 * Math.PI * k / N; 583: this.cosTab[k] = Math.cos(ang); 584: this.sinTab[k] = Math.sin(ang); 585: } 586: this.dctCos = new Float32Array(N); 587: this.dctSin = new Float32Array(N); 588: for (let k = 0; k < N; k++) { 589: const ang = -Math.PI * k / (2 * N); 590: this.dctCos[k] = Math.cos(ang); 591: this.dctSin[k] = Math.sin(ang); 592: } 593: this.eig1D = new Float32Array(N); 594: for (let k = 0; k < N; k++) { 595: this.eig1D[k] = 2 * Math.cos(Math.PI * k / N) - 2; 596: } 597: this.re = new Float32Array(N); 598: this.im = new Float32Array(N); 599: this.tmp = new Float32Array(N * N); 600: } 601: 602: fft(re, im, invert) { 603: const N = this.N, bitRev = this.bitRev; 604: for (let i = 0; i < N; i++) { 605: const j = bitRev[i]; 606: if (i < j) { 607: let t = re[i]; re[i] = re[j]; re[j] = t; 608: t = im[i]; im[i] = im[j]; im[j] = t; 609: } 610: } 611: const sign = invert ? -1 : 1; 612: for (let len = 2; len <= N; len <<= 1) { 613: const half = len >> 1, step = N / len; 614: for (let i = 0; i < N; i += len) { 615: for (let j = 0; j < half; j++) { 616: const idx = j * step; 617: const wr = this.cosTab[idx], wi = sign * this.sinTab[idx]; 618: const uRe = re[i + j], uIm = im[i + j]; 619: const vRe = re[i + j + half] * wr - im[i + j + half] * wi; 620: const vIm = re[i + j + half] * wi + im[i + j + half] * wr; 621: re[i + j] = uRe + vRe; im[i + j] = uIm + vIm; 622: re[i + j + half] = uRe - vRe; im[i + j + half] = uIm - vIm; 623: } 624: } 625: } 626: if (invert) { 627: const invN = 1 / N; 628: for (let i = 0; i < N; i++) { re[i] *= invN; im[i] *= invN; } 629: } 630: } 631: 632: dct1d(src, offset, stride, dst, dOffset, dStride) { 633: const N = this.N, half = N >> 1, re = this.re, im = this.im; 634: for (let i = 0; i < half; i++) { 635: re[i] = src[offset + (2 * i) * stride]; 636: re[N - 1 - i] = src[offset + (2 * i + 1) * stride]; 637: im[i] = 0; im[N - 1 - i] = 0; 638: } 639: this.fft(re, im, false); 640: for (let k = 0; k < N; k++) { 641: dst[dOffset + k * dStride] = 2 * (re[k] * this.dctCos[k] - im[k] * this.dctSin[k]); 642: } 643: } 644: 645: idct1d(src, offset, stride, dst, dOffset, dStride) { 646: const N = this.N, half = N >> 1, re = this.re, im = this.im; 647: re[0] = src[offset] * 0.5; im[0] = 0; 648: for (let k = 1; k < N; k++) { 649: const a = 0.5 * src[offset + k * stride]; 650: const b = -0.5 * src[offset + (N - k) * stride]; 651: const cs = this.dctCos[k], sn = -this.dctSin[k]; 652: re[k] = a * cs - b * sn; 653: im[k] = a * sn + b * cs; 654: } 655: this.fft(re, im, true); 656: for (let i = 0; i < half; i++) { 657: dst[dOffset + (2 * i) * dStride] = re[i]; 658: dst[dOffset + (2 * i + 1) * dStride] = re[N - 1 - i]; 659: } 660: } 661: 662: solvePoisson(rhs, out) { 663: const N = this.N, tmp = this.tmp, eig = this.eig1D; 664: for (let y = 0; y < N; y++) this.dct1d(rhs, y * N, 1, tmp, y * N, 1); 665: for (let x = 0; x < N; x++) this.dct1d(tmp, x, N, out, x, N); 666: out[0] = 0; 667: for (let y = 0; y < N; y++) { 668: const ey = eig[y]; 669: for (let x = 0; x < N; x++) { 670: if (x === 0 && y === 0) continue; 671: out[y * N + x] /= (eig[x] + ey); 672: } 673: } 674: for (let x = 0; x < N; x++) this.idct1d(out, x, N, tmp, x, N); 675: for (let y = 0; y < N; y++) this.idct1d(tmp, y * N, 1, out, y * N, 1); 676: } 677: 678: gaussianBlur(src, out, sigma) { 679: if (sigma <= 0) { out.set(src); return; } 680: const N = this.N, tmp = this.tmp; 681: for (let y = 0; y < N; y++) this.dct1d(src, y * N, 1, tmp, y * N, 1); 682: for (let x = 0; x < N; x++) this.dct1d(tmp, x, N, out, x, N); 683: const sigScale = 0.5 * sigma * sigma * (Math.PI * Math.PI) / (N * N); 684: for (let y = 0; y < N; y++) { 685: for (let x = 0; x < N; x++) { 686: out[y * N + x] *= Math.exp(-sigScale * (x * x + y * y)); 687: } 688: } 689: for (let x = 0; x < N; x++) this.idct1d(out, x, N, tmp, x, N); 690: for (let y = 0; y < N; y++) this.idct1d(tmp, y * N, 1, out, y * N, 1); 691: } 692: } 693: 694: function createLevel(N) { 695: return { 696: N, dct: new DCT2D(N), dx: 2.0 / N, 697: IinX: new Float32Array(N * N), IinY: new Float32Array(N * N), IinZ: new Float32Array(N * N), 698: rho0: new Float32Array(N * N), sumRho0: 0, 699: Isim: new Float32Array(N * N), targBlur: new Float32Array(N * N), 700: rhs: new Float32Array(N * N), psi: new Float32Array(N * N), 701: gpX: new Float32Array(N * N), gpY: new Float32Array(N * N), 702: rX: new Float32Array(N * N), rY: new Float32Array(N * N), 703: desX: new Float32Array(N * N), desY: new Float32Array(N * N), 704: gx: new Float32Array(N * N), gy: new Float32Array(N * N) 705: }; 706: } 707: 708: function updateIncidentRays(lv, F, T_glass, nGlass, Z_light) { 709: const N = lv.N; 710: lv.F = F; lv.nGlass = nGlass; 711: let sum = 0; 712: for (let y = 0; y < N; y++) { 713: const py = ((y + 0.5) / N) * 2 - 1; 714: for (let x = 0; x < N; x++) { 715: const px = ((x + 0.5) / N) * 2 - 1; 716: const dz = -(Z_light - (F + T_glass)); 717: const len = Math.hypot(px, py, dz); 718: const ix = px / len, iy = py / len, iz = dz / len; 719: const eta = 1.0 / nGlass, cosI = -iz; 720: const idx = y * N + x; 721: lv.IinX[idx] = eta * ix; 722: lv.IinY[idx] = eta * iy; 723: lv.IinZ[idx] = -Math.sqrt(Math.max(1e-6, 1 - eta * eta * (1 - cosI * cosI))); 724: const flux = Math.pow(cosI, 3); 725: lv.rho0[idx] = flux; 726: sum += flux; 727: } 728: } 729: lv.sumRho0 = sum; 730: } 731: 732: function solveInverseSnellH(lv, desX, desY, h) { 733: const { N, dx, F, nGlass, IinX, IinY, IinZ, gx, gy, rhs, dct } = lv; 734: for (let y = 0; y < N; y++) { 735: const py = ((y + 0.5) / N) * 2 - 1; 736: for (let x = 0; x < N; x++) { 737: const i = y * N + x; 738: const px = ((x + 0.5) / N) * 2 - 1; 739: const pz = F + h[i]; 740: const dxP = (desX[i] / N) * 2 - 1 - px; 741: const dyP = (desY[i] / N) * 2 - 1 - py; 742: const dzP = -pz; 743: const invL = 1.0 / Math.hypot(dxP, dyP, dzP); 744: const Vx = dxP * invL - nGlass * IinX[i]; 745: const Vy = dyP * invL - nGlass * IinY[i]; 746: const Vz = dzP * invL - nGlass * IinZ[i]; 747: gx[i] = -Vx / Vz; 748: gy[i] = -Vy / Vz; 749: } 750: } 751: for (let y = 0; y < N; y++) { 752: for (let x = 0; x < N; x++) { 753: const fr = (x < N - 1) ? 0.5 * (gx[y * N + x] + gx[y * N + x + 1]) : 0; 754: const fl = (x > 0) ? 0.5 * (gx[y * N + x - 1] + gx[y * N + x]) : 0; 755: const ft = (y < N - 1) ? 0.5 * (gy[y * N + x] + gy[(y + 1) * N + x]) : 0; 756: const fb = (y > 0) ? 0.5 * (gy[(y - 1) * N + x] + gy[y * N + x]) : 0; 757: rhs[y * N + x] = (fr - fl + ft - fb) * dx; 758: } 759: } 760: dct.solvePoisson(rhs, h); 761: } 762: 763: function traceSplatFast(lv, h) { 764: const { N, dx, F, nGlass, IinX, IinY, IinZ, rho0, sumRho0, Isim, rX, rY } = lv; 765: Isim.fill(0); 766: for (let y = 0; y < N; y++) { 767: for (let x = 0; x < N; x++) { 768: const idx = y * N + x; 769: const hx = (x > 0 && x < N - 1) ? (h[idx + 1] - h[idx - 1]) / (2 * dx) 770: : (x === 0 ? (h[idx + 1] - h[idx]) / dx : (h[idx] - h[idx - 1]) / dx); 771: const hy = (y > 0 && y < N - 1) ? (h[idx + N] - h[idx - N]) / (2 * dx) 772: : (y === 0 ? (h[idx + N] - h[idx]) / dx : (h[idx] - h[idx - N]) / dx); 773: const invN = 1.0 / Math.sqrt(hx * hx + hy * hy + 1.0); 774: const nx = -hx * invN, ny = -hy * invN, nz = invN; 775: const ix = IinX[idx], iy = IinY[idx], iz = IinZ[idx]; 776: const cosI = -(ix * nx + iy * ny + iz * nz); 777: const k = 1.0 - nGlass * nGlass * (1.0 - cosI * cosI); 778: const s = nGlass * cosI - Math.sqrt(Math.max(1e-6, k)); 779: const tx = nGlass * ix + s * nx, ty = nGlass * iy + s * ny, tz = nGlass * iz + s * nz; 780: const px = ((x + 0.5) / N) * 2 - 1, py = ((y + 0.5) / N) * 2 - 1, pz = F + h[idx]; 781: const t = -pz / tz; 782: rX[idx] = ((px + t * tx) * 0.5 + 0.5) * N; 783: rY[idx] = ((py + t * ty) * 0.5 + 0.5) * N; 784: } 785: } 786: for (let y = 0; y < N - 1; y++) { 787: for (let x = 0; x < N - 1; x++) { 788: const i00 = y * N + x, i10 = i00 + 1, i01 = i00 + N, i11 = i01 + 1; 789: const x00 = rX[i00], y00 = rY[i00], x10 = rX[i10], y10 = rY[i10]; 790: const x01 = rX[i01], y01 = rY[i01], x11 = rX[i11], y11 = rY[i11]; 791: const flux = 0.25 * (rho0[i00] + rho0[i10] + rho0[i01] + rho0[i11]); 792: const span = Math.max(Math.abs(x11 - x00), Math.abs(y11 - y00), Math.abs(x10 - x01), Math.abs(y10 - y01)); 793: const subs = span > 3.5 ? (span > 7 ? 5 : 3) : 2; 794: const wSub = flux / (subs * subs); 795: for (let sy = 0; sy < subs; sy++) { 796: const v = (sy + 0.5) / subs, mv = 1 - v; 797: for (let sx = 0; sx < subs; sx++) { 798: const u = (sx + 0.5) / subs, mu = 1 - u; 799: const px = Math.max(0, Math.min(N - 1.001, mu * mv * x00 + u * mv * x10 + mu * v * x01 + u * v * x11 - 0.5)); 800: const py = Math.max(0, Math.min(N - 1.001, mu * mv * y00 + u * mv * y10 + mu * v * y01 + u * v * y11 - 0.5)); 801: const ix = px | 0, iy = py | 0, fx = px - ix, fy = py - iy; 802: const base = iy * N + ix; 803: Isim[base] += wSub * (1 - fx) * (1 - fy); 804: Isim[base + 1] += wSub * fx * (1 - fy); 805: Isim[base + N] += wSub * (1 - fx) * fy; 806: Isim[base + N + 1] += wSub * fx * fy; 807: } 808: } 809: } 810: } 811: let s = 0; 812: for (let i = 0; i < N * N; i++) s += Isim[i]; 813: if (s > 0) { const sc = sumRho0 / s; for (let i = 0; i < N * N; i++) Isim[i] *= sc; } 814: } 815: 816: function bSample(arr, N, gxPos, gyPos) { 817: const px = Math.max(0, Math.min(N - 1.001, gxPos - 0.5)); 818: const py = Math.max(0, Math.min(N - 1.001, gyPos - 0.5)); 819: const ix = px | 0, iy = py | 0, fx = px - ix, fy = py - iy; 820: const row = iy * N + ix; 821: return (1 - fx) * (1 - fy) * arr[row] + fx * (1 - fy) * arr[row + 1] + 822: (1 - fx) * fy * arr[row + N] + fx * fy * arr[row + N + 1]; 823: } 824: 825: const lv128 = createLevel(128); 826: const lv256 = createLevel(256); 827: 828: self.onmessage = (e) => { 829: const { id, target256, F, T_glass, nGlass, Z_light } = e.data; 830: const t0 = performance.now(); 831: updateIncidentRays(lv128, F, T_glass, nGlass, Z_light); 832: updateIncidentRays(lv256, F, T_glass, nGlass, Z_light); 833: 834: const N = 128; 835: const targ128 = new Float32Array(N * N); 836: let sumT128 = 0; 837: for (let y = 0; y < N; y++) { 838: for (let x = 0; x < N; x++) { 839: const i0 = (2 * y) * 256 + (2 * x); 840: // Enforce clean C^2 ambient floor & soft aperture margin so boundary stays diffeomorphic 841: const u = (x + 0.5) / N * 2 - 1, v = (y + 0.5) / N * 2 - 1; 842: const edge = Math.max(Math.abs(u), Math.abs(v)); 843: const wEdge = edge > 0.85 ? Math.max(0, 1 - (edge - 0.85) / 0.13) : 1.0; 844: let raw = 0.25 * (target256[i0] + target256[i0 + 1] + target256[i0 + 256] + target256[i0 + 257]); 845: raw = 0.032 + Math.max(0, raw - 0.032) * (wEdge * wEdge); 846: targ128[y * N + x] = raw; 847: sumT128 += raw; 848: } 849: } 850: const sc128 = lv128.sumRho0 / sumT128; 851: for (let i = 0; i < N * N; i++) targ128[i] *= sc128; 852: 853: const h128 = new Float32Array(N * N); 854: for (let y = 0; y < N; y++) { 855: for (let x = 0; x < N; x++) { 856: lv128.desX[y * N + x] = x + 0.5; 857: lv128.desY[y * N + x] = y + 0.5; 858: } 859: } 860: solveInverseSnellH(lv128, lv128.desX, lv128.desY, h128); 861: solveInverseSnellH(lv128, lv128.desX, lv128.desY, h128); 862: 863: const sigmas = [7.0, 4.2, 2.5, 1.4, 0.7, 0.0, 0.0, 0.0, 0.0]; 864: const meanI = lv128.sumRho0 / (N * N); 865: for (let iter = 0; iter < sigmas.length; iter++) { 866: const sig = sigmas[iter]; 867: lv128.dct.gaussianBlur(targ128, lv128.targBlur, sig); 868: traceSplatFast(lv128, h128); 869: if (sig > 0.2) lv128.dct.gaussianBlur(lv128.Isim, lv128.Isim, sig * 0.45); 870: for (let i = 0; i < N * N; i++) lv128.rhs[i] = lv128.Isim[i] - lv128.targBlur[i]; 871: lv128.dct.solvePoisson(lv128.rhs, lv128.psi); 872: for (let y = 0; y < N; y++) { 873: const ym = Math.max(0, y - 1), yp = Math.min(N - 1, y + 1), dyS = yp - ym; 874: for (let x = 0; x < N; x++) { 875: const xm = Math.max(0, x - 1), xp = Math.min(N - 1, x + 1), dxS = xp - xm; 876: lv128.gpX[y * N + x] = (lv128.psi[y * N + xp] - lv128.psi[y * N + xm]) / dxS; 877: lv128.gpY[y * N + x] = (lv128.psi[yp * N + x] - lv128.psi[ym * N + x]) / dyS; 878: } 879: } 880: for (let i = 0; i < N * N; i++) { 881: const rx = lv128.rX[i], ry = lv128.rY[i]; 882: const denom = Math.max(0.08 * meanI, 0.5 * (bSample(lv128.Isim, N, rx, ry) + bSample(lv128.targBlur, N, rx, ry))); 883: lv128.desX[i] = Math.max(0.5, Math.min(N - 0.5, rx + 0.80 * (bSample(lv128.gpX, N, rx, ry) / denom))); 884: lv128.desY[i] = Math.max(0.5, Math.min(N - 0.5, ry + 0.80 * (bSample(lv128.gpY, N, rx, ry) / denom))); 885: } 886: solveInverseSnellH(lv128, lv128.desX, lv128.desY, h128); 887: } 888: 889: const N2 = 256; 890: const h256 = new Float32Array(N2 * N2); 891: for (let y = 0; y < N2; y++) { 892: const gy = (y + 0.5) * 0.5; 893: for (let x = 0; x < N2; x++) { 894: h256[y * N2 + x] = bSample(h128, N, (x + 0.5) * 0.5, gy); 895: } 896: } 897: const targ256 = new Float32Array(N2 * N2); 898: let sumT2 = 0; 899: for (let y = 0; y < N2; y++) { 900: const v = (y + 0.5) / N2 * 2 - 1; 901: for (let x = 0; x < N2; x++) { 902: const u = (x + 0.5) / N2 * 2 - 1; 903: const edge = Math.max(Math.abs(u), Math.abs(v)); 904: const wEdge = edge > 0.85 ? Math.max(0, 1 - (edge - 0.85) / 0.13) : 1.0; 905: const idx = y * N2 + x; 906: const raw = 0.032 + Math.max(0, target256[idx] - 0.032) * (wEdge * wEdge); 907: targ256[idx] = raw; 908: sumT2 += raw; 909: } 910: } 911: const sc2 = lv256.sumRho0 / sumT2; 912: for (let i = 0; i < N2 * N2; i++) targ256[i] *= sc2; 913: const meanI2 = lv256.sumRho0 / (N2 * N2); 914: 915: for (let iter = 0; iter < 3; iter++) { 916: traceSplatFast(lv256, h256); 917: for (let i = 0; i < N2 * N2; i++) lv256.rhs[i] = lv256.Isim[i] - targ256[i]; 918: lv256.dct.solvePoisson(lv256.rhs, lv256.psi); 919: for (let y = 0; y < N2; y++) { 920: const ym = Math.max(0, y - 1), yp = Math.min(N2 - 1, y + 1), dyS = yp - ym; 921: for (let x = 0; x < N2; x++) { 922: const xm = Math.max(0, x - 1), xp = Math.min(N2 - 1, x + 1), dxS = xp - xm; 923: lv256.gpX[y * N2 + x] = (lv256.psi[y * N2 + xp] - lv256.psi[y * N2 + xm]) / dxS; 924: lv256.gpY[y * N2 + x] = (lv256.psi[yp * N2 + x] - lv256.psi[ym * N2 + x]) / dyS; 925: } 926: } 927: for (let i = 0; i < N2 * N2; i++) { 928: const rx = lv256.rX[i], ry = lv256.rY[i];401 more lines not shown.