gladly-plot 0.0.5 → 0.0.7

package/src/compute/fft.js

@@ -1,4 +1,6 @@
-import { registerTextureComputation, TextureComputation, EXPRESSION_REF } from "./ComputationRegistry.js"
+import { registerTextureComputation, registerComputedData, EXPRESSION_REF, resolveQuantityKind } from "./ComputationRegistry.js"
+import { TextureComputation, ComputedData } from "../data/Computation.js"
+import { ArrayColumn } from "../data/ColumnData.js"
 
 /* ============================================================
    Utilities
@@ -8,6 +10,8 @@ function nextPow2(n) {
   return 1 << Math.ceil(Math.log2(n));
 }
 
+// Internal: complex texture (R=real, G=imag per frequency bin), 1 element per texel.
+// Not exposed via sampleColumn — only used as intermediate within this module.
 function makeComplexTexture(regl, data, N) {
   // data: Float32Array (real), imag assumed 0
   const texData = new Float32Array(N * 4);
@@ -39,7 +43,7 @@ function makeEmptyComplexTexture(regl, N) {
 }
 
 function makeFBO(regl, tex) {
-  return regl.framebuffer({ color: tex });
+  return regl.framebuffer({ color: tex, depth: false, stencil: false });
 }
 
 /* ============================================================
@@ -166,11 +170,15 @@ function scalePass(regl, N) {
   });
 }
 
+// If a single batch of FFT stages takes longer than this, yield before the next batch.
+const TDR_STEP_MS = 500
+
 /* ============================================================
-   Public: GPU FFT (top-level API)
+   Internal GPU FFT — returns a complex texture (R=real, G=imag)
+   with 1 frequency bin per texel. NOT for direct use with sampleColumn.
    ============================================================ */
 
-export function fft1d(regl, realArray, inverse = false) {
+export async function fft1d(regl, realArray, inverse = false) {
   const N = nextPow2(realArray.length);
 
   let texA = makeComplexTexture(regl, realArray, N);
@@ -185,8 +193,9 @@ export function fft1d(regl, realArray, inverse = false) {
   });
   [fboA, fboB] = [fboB, fboA];
 
-  // FFT stages
+  // FFT stages — yield between batches to avoid triggering the Windows TDR watchdog.
   const stages = Math.log2(N);
+  let batchStart = performance.now();
   for (let s = 1; s <= stages; s++) {
     fftStagePass(regl, 1 << s, inverse)({
       input: fboA,
@@ -194,6 +203,10 @@ export function fft1d(regl, realArray, inverse = false) {
       fbo: fboB
     });
     [fboA, fboB] = [fboB, fboA];
+    if (performance.now() - batchStart > TDR_STEP_MS) {
+      await new Promise(r => requestAnimationFrame(r));
+      batchStart = performance.now();
+    }
   }
 
   // scale for inverse
@@ -209,14 +222,14 @@ export function fft1d(regl, realArray, inverse = false) {
 }
 
 /* ============================================================
-   FFT-based convolution
+   FFT-based convolution (internal)
    ============================================================ */
 
-export function fftConvolution(regl, signal, kernel) {
+export async function fftConvolution(regl, signal, kernel) {
   const N = nextPow2(signal.length + kernel.length);
 
-  const sigTex = fft1d(regl, signal, false);
-  const kerTex = fft1d(regl, kernel, false);
+  const sigTex = await fft1d(regl, signal, false);
+  const kerTex = await fft1d(regl, kernel, false);
 
   const outTex = makeEmptyComplexTexture(regl, N);
   const outFBO = makeFBO(regl, outTex);
@@ -251,32 +264,108 @@ export function fftConvolution(regl, signal, kernel) {
   })();
 
   // inverse FFT
-  return fft1d(regl, new Float32Array(N), true);
+  return await fft1d(regl, new Float32Array(N), true);
+}
+
+/* ============================================================
+   extractAndRepack: extract one channel from a complex texture
+   (1 element per texel, R=real/G=imag) into a 4-packed RGBA texture.
+   channelSwizzle: 'r' for real part, 'g' for imaginary part.
+   ============================================================ */
+
+function extractAndRepack(regl, complexTex, channelSwizzle, N) {
+  const nTexels = Math.ceil(N / 4)
+  const w = Math.min(nTexels, regl.limits.maxTextureSize)
+  const h = Math.ceil(nTexels / w)
+  const outputTex = regl.texture({ width: w, height: h, type: 'float', format: 'rgba' })
+  const outputFBO = regl.framebuffer({ color: outputTex, depth: false, stencil: false })
+
+  regl({
+    framebuffer: outputFBO,
+    vert: `#version 300 es
+    in vec2 position;
+    void main() { gl_Position = vec4(position, 0.0, 1.0); }`,
+    frag: `#version 300 es
+    precision highp float;
+    uniform sampler2D complexTex;
+    uniform int totalLength;
+    out vec4 fragColor;
+    void main() {
+      int texelI = int(gl_FragCoord.y) * ${w} + int(gl_FragCoord.x);
+      int base = texelI * 4;
+      float v0 = base + 0 < totalLength ? texelFetch(complexTex, ivec2(base+0, 0), 0).${channelSwizzle} : 0.0;
+      float v1 = base + 1 < totalLength ? texelFetch(complexTex, ivec2(base+1, 0), 0).${channelSwizzle} : 0.0;
+      float v2 = base + 2 < totalLength ? texelFetch(complexTex, ivec2(base+2, 0), 0).${channelSwizzle} : 0.0;
+      float v3 = base + 3 < totalLength ? texelFetch(complexTex, ivec2(base+3, 0), 0).${channelSwizzle} : 0.0;
+      fragColor = vec4(v0, v1, v2, v3);
+    }`,
+    attributes: { position: [[-1,-1],[1,-1],[-1,1],[1,1]] },
+    uniforms: { complexTex, totalLength: N },
+    count: 4,
+    primitive: 'triangle strip'
+  })()
+
+  outputTex._dataLength = N
+  return outputTex
 }
 
-class Fft1dComputation extends TextureComputation {
-  compute(regl, params) {
-    return fft1d(regl, params.input, params.inverse ?? false)
+/* ============================================================
+   FftData — ComputedData producing 'real' and 'imag' columns
+   ============================================================ */
+
+class FftData extends ComputedData {
+  columns() { return ['real', 'imag'] }
+
+  async compute(regl, params, data, getAxisDomain) {
+    const inputCol = data.getData(params.input)
+    if (!(inputCol instanceof ArrayColumn)) {
+      throw new Error(`FftData: input '${params.input}' must be a plain data column`)
+    }
+    const N = nextPow2(inputCol.array.length)
+    const complexTex = await fft1d(regl, inputCol.array, params.inverse ?? false)
+    return {
+      real: extractAndRepack(regl, complexTex, 'r', N),
+      imag: extractAndRepack(regl, complexTex, 'g', N),
+      _meta: {
+        domains: { real: null, imag: null },
+        quantityKinds: { real: null, imag: null }
+      }
+    }
   }
+
   schema(data) {
+    const cols = data ? data.columns() : []
     return {
       type: 'object',
+      title: 'FftData',
       properties: {
-        input: EXPRESSION_REF,
-        inverse: { type: 'boolean' }
+        input: { type: 'string', enum: cols, description: 'Input signal column' },
+        inverse: { type: 'boolean', default: false, description: 'Inverse FFT' }
       },
       required: ['input']
     }
   }
 }
 
+registerComputedData('FftData', new FftData())
+
+/* ============================================================
+   FftConvolutionComputation — TextureComputation (real output)
+   ============================================================ */
+
 class FftConvolutionComputation extends TextureComputation {
-  compute(regl, params) {
-    return fftConvolution(regl, params.signal, params.kernel)
+  getQuantityKind(params, data) { return resolveQuantityKind(params.signal, data) }
+  async compute(regl, params, data, getAxisDomain) {
+    const signal = params.signal instanceof ArrayColumn ? params.signal.array : params.signal
+    const kernel = params.kernel instanceof ArrayColumn ? params.kernel.array : params.kernel
+    const N = nextPow2(signal.length + kernel.length)
+    const complexResult = await fftConvolution(regl, signal, kernel)
+    return extractAndRepack(regl, complexResult, 'r', N)
   }
   schema(data) {
     return {
       type: 'object',
+      title: 'fftConvolution',
       properties: {
         signal: EXPRESSION_REF,
         kernel: EXPRESSION_REF
@@ -286,7 +375,4 @@ class FftConvolutionComputation extends TextureComputation {
   }
 }
 
-// fft1d: output is a complex texture — R = real part, G = imaginary part.
-// Use a downstream computation (e.g. magnitude) to get a single scalar per bin.
-registerTextureComputation('fft1d', new Fft1dComputation())
 registerTextureComputation('fftConvolution', new FftConvolutionComputation())

package/src/compute/filter.js

@@ -1,166 +1,162 @@
-import { registerTextureComputation, TextureComputation, EXPRESSION_REF } from "./ComputationRegistry.js"
-
-function toTexture(regl, input, length) {
-  if (input instanceof Float32Array) {
-    return regl.texture({ data: input, shape: [length, 1], type: 'float', format: 'rgba' });
-  }
-  return input; // already a texture
-}
+import { registerTextureComputation, EXPRESSION_REF, resolveQuantityKind } from "./ComputationRegistry.js"
+import { TextureComputation } from "../data/Computation.js"
+import { ArrayColumn, SAMPLE_COLUMN_GLSL } from "../data/ColumnData.js"
 
 function subtractTextures(regl, texA, texB) {
-  const length = texA.width;
-  const outputTex = regl.texture({ width: length, height: 1, type: 'float', format: 'rgba' });
-  const outputFBO = regl.framebuffer({ color: outputTex });
+  const w = texA.width
+  const h = texA.height
+  const outputTex = regl.texture({ width: w, height: h, type: 'float', format: 'rgba' })
+  const outputFBO = regl.framebuffer({ color: outputTex, depth: false, stencil: false })
 
-  const drawSub = regl({
+  regl({
     framebuffer: outputFBO,
-    vert: `
+    vert: `#version 300 es
       precision highp float;
-      attribute float bin;
-      void main() {
-        float x = (bin + 0.5)/${length}.0*2.0 - 1.0;
-        gl_Position = vec4(x,0.0,0.0,1.0);
-      }
+      in vec2 position;
+      void main() { gl_Position = vec4(position, 0.0, 1.0); }
     `,
-    frag: `
+    frag: `#version 300 es
       precision highp float;
       uniform sampler2D texA;
       uniform sampler2D texB;
       out vec4 fragColor;
       void main() {
-        int idx = int(gl_FragCoord.x-0.5);
-        float a = texelFetch(texA, ivec2(idx,0),0).r;
-        float b = texelFetch(texB, ivec2(idx,0),0).r;
-        fragColor = vec4(a-b,0.0,0.0,1.0);
+        ivec2 coord = ivec2(gl_FragCoord.xy);
+        fragColor = texelFetch(texA, coord, 0) - texelFetch(texB, coord, 0);
       }
     `,
-    attributes: { bin: Array.from({ length }, (_, i) => i) },
+    attributes: { position: [[-1, -1], [1, -1], [-1, 1], [1, 1]] },
     uniforms: { texA, texB },
-    count: length,
-    primitive: 'points'
-  });
+    count: 4,
+    primitive: 'triangle strip'
+  })()
 
-  drawSub();
-  return outputTex;
+  if (texA._dataLength !== undefined) outputTex._dataLength = texA._dataLength
+  return outputTex
 }
 
 /**
  * Generic 1D convolution filter
  * @param {regl} regl - regl context
- * @param {Float32Array | Texture} input - CPU array or GPU texture
- * @param {Float32Array} kernel - 1D kernel
- * @returns {Texture} - filtered output texture
+ * @param {Texture} inputTex - 4-packed GPU texture, _dataLength set
+ * @param {Float32Array} kernel - 1D kernel weights
+ * @returns {Texture} - filtered output texture (4-packed, same dimensions as input)
  */
-function filter1D(regl, input, kernel) {
-  const length = input instanceof Float32Array ? input.length : input.width;
-  const inputTex = toTexture(regl, input, length);
+function filter1D(regl, inputTex, kernel) {
+  const length = inputTex._dataLength ?? inputTex.width * inputTex.height * 4
+  const w = inputTex.width
+  const h = inputTex.height
 
-  const kernelTex = regl.texture({ data: kernel, shape: [kernel.length, 1], type: 'float' });
+  // Kernel texture stays R-channel (internal, not exposed via sampleColumn)
+  const kernelData = new Float32Array(kernel.length * 4)
+  for (let i = 0; i < kernel.length; i++) kernelData[i * 4] = kernel[i]
+  const kernelTex = regl.texture({ data: kernelData, shape: [kernel.length, 1], type: 'float', format: 'rgba' })
+  const outputTex = regl.texture({ width: w, height: h, type: 'float', format: 'rgba' })
+  const outputFBO = regl.framebuffer({ color: outputTex, depth: false, stencil: false })
 
-  const outputTex = regl.texture({ width: length, height: 1, type: 'float', format: 'rgba' });
-  const outputFBO = regl.framebuffer({ color: outputTex });
+  const radius = Math.floor(kernel.length / 2)
 
-  const radius = Math.floor(kernel.length / 2);
-
-  const drawFilter = regl({
+  regl({
     framebuffer: outputFBO,
-    vert: `
+    vert: `#version 300 es
       precision highp float;
-      attribute float bin;
-      void main() {
-        float x = (bin + 0.5)/${length}.0*2.0 - 1.0;
-        gl_Position = vec4(x, 0.0, 0.0, 1.0);
-      }
+      in vec2 position;
+      void main() { gl_Position = vec4(position, 0.0, 1.0); }
     `,
-    frag: `
-      #version 300 es
+    frag: `#version 300 es
       precision highp float;
+      precision highp sampler2D;
       uniform sampler2D inputTex;
       uniform sampler2D kernelTex;
       uniform int radius;
-      uniform int length;
+      uniform int totalLength;
       out vec4 fragColor;
-
+      ${SAMPLE_COLUMN_GLSL}
       void main() {
-        float idx = gl_FragCoord.x - 0.5;
-        float sum = 0.0;
-        for (int i=-16; i<=16; i++) { // max kernel radius 16
-          if (i+16 >= radius*2+1) break;
-          int sampleIdx = int(clamp(idx + float(i), 0.0, float(length-1)));
-          float val = texelFetch(inputTex, ivec2(sampleIdx,0),0).r;
-          float w = texelFetch(kernelTex, ivec2(i+radius,0),0).r;
-          sum += val * w;
+        ivec2 sz = textureSize(inputTex, 0);
+        int texelI = int(gl_FragCoord.y) * sz.x + int(gl_FragCoord.x);
+        int base = texelI * 4;
+        float s0 = 0.0, s1 = 0.0, s2 = 0.0, s3 = 0.0;
+        for (int i = -16; i <= 16; i++) {
+          if (i + 16 >= radius * 2 + 1) break;
+          float kw = texelFetch(kernelTex, ivec2(i + radius, 0), 0).r;
+          s0 += sampleColumn(inputTex, float(clamp(base + 0 + i, 0, totalLength - 1))) * kw;
+          s1 += sampleColumn(inputTex, float(clamp(base + 1 + i, 0, totalLength - 1))) * kw;
+          s2 += sampleColumn(inputTex, float(clamp(base + 2 + i, 0, totalLength - 1))) * kw;
+          s3 += sampleColumn(inputTex, float(clamp(base + 3 + i, 0, totalLength - 1))) * kw;
         }
-        fragColor = vec4(sum,0.0,0.0,1.0);
+        fragColor = vec4(s0, s1, s2, s3);
       }
     `,
-    attributes: {
-      bin: Array.from({ length }, (_, i) => i)
-    },
-    uniforms: {
-      inputTex,
-      kernelTex,
-      radius,
-      length
-    },
-    count: length,
-    primitive: 'points'
-  });
-
-  drawFilter();
-  return outputTex;
+    attributes: { position: [[-1, -1], [1, -1], [-1, 1], [1, 1]] },
+    uniforms: { inputTex, kernelTex, radius, totalLength: length },
+    count: 4,
+    primitive: 'triangle strip'
+  })()
+
+  outputTex._dataLength = length
+  return outputTex
 }
 
 // Gaussian kernel helper
 function gaussianKernel(size, sigma) {
-  const radius = Math.floor(size / 2);
-  const kernel = new Float32Array(size);
-  let sum = 0;
+  const radius = Math.floor(size / 2)
+  const kernel = new Float32Array(size)
+  let sum = 0
   for (let i = -radius; i <= radius; i++) {
-    const v = Math.exp(-0.5 * (i / sigma) ** 2);
-    kernel[i + radius] = v;
-    sum += v;
+    const v = Math.exp(-0.5 * (i / sigma) ** 2)
+    kernel[i + radius] = v
+    sum += v
   }
-  for (let i = 0; i < size; i++) kernel[i] /= sum;
-  return kernel;
+  for (let i = 0; i < size; i++) kernel[i] /= sum
+  return kernel
 }
 
 /**
  * Low-pass filter
+ * @param {regl} regl
+ * @param {Texture} inputTex - 4-packed GPU texture
  */
-function lowPass(regl, input, sigma = 3, kernelSize = null) {
-  const size = kernelSize || Math.ceil(sigma*6)|1; // ensure odd
-  const kernel = gaussianKernel(size, sigma);
-  return filter1D(regl, input, kernel);
+function lowPass(regl, inputTex, sigma = 3, kernelSize = null) {
+  const size = kernelSize || (Math.ceil(sigma * 6) | 1) // ensure odd
+  const kernel = gaussianKernel(size, sigma)
+  return filter1D(regl, inputTex, kernel)
 }
 
 /**
  * High-pass filter: subtract low-pass
+ * @param {regl} regl
+ * @param {Texture} inputTex - 4-packed GPU texture
  */
-function highPass(regl, input, sigma = 3, kernelSize = null) {
-  const low = lowPass(regl, input, sigma, kernelSize);
-  // high = input - low (using a shader)
-  return subtractTextures(regl, input, low);
+function highPass(regl, inputTex, sigma = 3, kernelSize = null) {
+  const low = lowPass(regl, inputTex, sigma, kernelSize)
+  return subtractTextures(regl, inputTex, low)
 }
 
 /**
  * Band-pass filter: difference of low-pass filters
+ * @param {regl} regl
+ * @param {Texture} inputTex - 4-packed GPU texture
  */
-function bandPass(regl, input, sigmaLow, sigmaHigh) {
-  const lowHigh = lowPass(regl, input, sigmaHigh);
-  const lowLow = lowPass(regl, input, sigmaLow);
-  return subtractTextures(regl, lowHigh, lowLow);
+function bandPass(regl, inputTex, sigmaLow, sigmaHigh) {
+  const lowHigh = lowPass(regl, inputTex, sigmaHigh)
+  const lowLow  = lowPass(regl, inputTex, sigmaLow)
+  return subtractTextures(regl, lowHigh, lowLow)
 }
 
 export { filter1D, gaussianKernel, lowPass, highPass, bandPass }
 
 class Filter1DComputation extends TextureComputation {
-  compute(regl, params) {
-    return filter1D(regl, params.input, params.kernel)
+  getQuantityKind(params, data) { return resolveQuantityKind(params.input, data) }
+  compute(regl, inputs, getAxisDomain) {
+    const inputTex = inputs.input.toTexture(regl)
+    const kernelArr = inputs.kernel instanceof ArrayColumn ? inputs.kernel.array : inputs.kernel
+    return filter1D(regl, inputTex, kernelArr)
   }
   schema(data) {
     return {
       type: 'object',
+      title: 'filter1D',
       properties: {
         input: EXPRESSION_REF,
         kernel: EXPRESSION_REF
@@ -171,12 +167,14 @@ class Filter1DComputation extends TextureComputation {
 }
 
 class LowPassComputation extends TextureComputation {
-  compute(regl, params) {
-    return lowPass(regl, params.input, params.sigma, params.kernelSize)
+  getQuantityKind(params, data) { return resolveQuantityKind(params.input, data) }
+  compute(regl, inputs, getAxisDomain) {
+    return lowPass(regl, inputs.input.toTexture(regl), inputs.sigma, inputs.kernelSize)
   }
   schema(data) {
     return {
       type: 'object',
+      title: 'lowPass',
       properties: {
         input: EXPRESSION_REF,
         sigma: { type: 'number' },
@@ -188,12 +186,14 @@ class LowPassComputation extends TextureComputation {
 }
 
 class HighPassComputation extends TextureComputation {
-  compute(regl, params) {
-    return highPass(regl, params.input, params.sigma, params.kernelSize)
+  getQuantityKind(params, data) { return resolveQuantityKind(params.input, data) }
+  compute(regl, inputs, getAxisDomain) {
+    return highPass(regl, inputs.input.toTexture(regl), inputs.sigma, inputs.kernelSize)
   }
   schema(data) {
     return {
       type: 'object',
+      title: 'highPass',
       properties: {
         input: EXPRESSION_REF,
         sigma: { type: 'number' },
@@ -205,12 +205,14 @@ class HighPassComputation extends TextureComputation {
 }
 
 class BandPassComputation extends TextureComputation {
-  compute(regl, params) {
-    return bandPass(regl, params.input, params.sigmaLow, params.sigmaHigh)
+  getQuantityKind(params, data) { return resolveQuantityKind(params.input, data) }
+  compute(regl, inputs, getAxisDomain) {
+    return bandPass(regl, inputs.input.toTexture(regl), inputs.sigmaLow, inputs.sigmaHigh)
   }
   schema(data) {
     return {
       type: 'object',
+      title: 'bandPass',
       properties: {
         input: EXPRESSION_REF,
         sigmaLow: { type: 'number' },