The showcase prompt, round 3, Gemini 4 Carbon

agent (cont.)

+42:44
  • read_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.