gladly-plot 0.0.5 → 0.0.7

package/src/compute/ComputationRegistry.js

@@ -1,21 +1,10 @@
+import { ColumnData } from '../data/ColumnData.js'
+
 const textureComputations = new Map()
 const glslComputations = new Map()
+const computedDataRegistry = new Map()
 
-export class Computation {
-  schema(data) { throw new Error('Not implemented') }
-}
-
-export class TextureComputation extends Computation {
-  compute(regl, params, getAxisDomain) { throw new Error('Not implemented') }
-}
-
-export class GlslComputation extends Computation {
-  glsl(resolvedParams) { throw new Error('Not implemented') }
-}
-
-// Use in computation schema() methods for params that can be a Float32Array or sub-expression
-export const EXPRESSION_REF = { '$ref': '#/$defs/expression' }
-
+// ─── Registration ─────────────────────────────────────────────────────────────
 export function registerTextureComputation(name, computation) {
   textureComputations.set(name, computation)
 }
@@ -24,214 +13,167 @@ export function registerGlslComputation(name, computation) {
   glslComputations.set(name, computation)
 }
 
-export function computationSchema(data) {
-  const cols = data ? data.columns() : []
-  const defs = {}
-
-  for (const [name, comp] of textureComputations) {
-    defs[`params_${name}`] = comp.schema(data)
-  }
-
-  for (const [name, comp] of glslComputations) {
-    defs[`params_${name}`] = comp.schema(data)
-  }
-
-  defs.expression = {
-    anyOf: [
-      { type: 'string', enum: cols },
-      ...[...textureComputations, ...glslComputations].map(([name]) => ({
-        type: 'object',
-        properties: { [name]: { '$ref': `#/$defs/params_${name}` } },
-        required: [name],
-        additionalProperties: false
-      }))
-    ]
-  }
-
-  return { '$defs': defs, '$ref': '#/$defs/expression' }
+export function registerComputedData(name, instance) {
+  computedDataRegistry.set(name, instance)
 }
 
-// Duck-type check for regl textures.
-export function isTexture(value) {
-  return (
-    value !== null &&
-    typeof value === 'object' &&
-    typeof value.width === 'number' &&
-    typeof value.subimage === 'function'
-  )
+export function getComputedData(name) {
+  return computedDataRegistry.get(name)
 }
 
-function domainsEqual(a, b) {
-  if (a === b) return true
-  if (a == null || b == null) return a === b
-  return a[0] === b[0] && a[1] === b[1]
+export function getRegisteredComputedData() {
+  return computedDataRegistry
 }
 
-// Resolve expr to a raw JS value (Float32Array / texture / number).
-// Used for texture computation params — GLSL expressions are not permitted here.
-function resolveToRawValue(regl, expr, path, getAxisDomain) {
-  if (expr instanceof Float32Array) return expr
-  if (isTexture(expr)) return expr
-  if (typeof expr === 'number') return expr
-  if (typeof expr === 'string') return expr
+// ─── resolveExprToColumn ─────────────────────────────────────────────────────
+// Turns any expression (string col name, { compName: params }, ColumnData) into ColumnData.
+export async function resolveExprToColumn(expr, data, regl, plot) {
+  if (expr instanceof ColumnData) return expr
+
+  if (typeof expr === 'string') {
+    const col = data?.getData(expr)
+    if (!col) throw new Error(`Column '${expr}' not found in data`)
+    return col
+  }
 
   if (typeof expr === 'object' && expr !== null) {
     const keys = Object.keys(expr)
-
-    // Single-key object: check if it names a registered computation.
     if (keys.length === 1) {
       const compName = keys[0]
+      const params = expr[compName]
+
       if (textureComputations.has(compName)) {
         const comp = textureComputations.get(compName)
-        const params = expr[compName]
-        const resolvedParams = resolveToRawValue(regl, params, path, getAxisDomain)
-        return comp.compute(regl, resolvedParams, getAxisDomain)
+        const resolvedInputs = await resolveParams(params, data, regl, plot)
+        return await comp.createColumn(regl, resolvedInputs, plot)
       }
+
       if (glslComputations.has(compName)) {
-        throw new Error(
-          `GLSL computation '${compName}' cannot be used as a texture computation parameter`
-        )
+        const comp = glslComputations.get(compName)
+        const resolvedInputs = await resolveParams(params, data, regl, plot)
+        return comp.createColumn(resolvedInputs)
       }
     }
+  }
+
+  throw new Error(`Cannot resolve expression to column: ${JSON.stringify(expr)}`)
+}
 
-    // Plain params dict: resolve each value recursively.
+// Resolve a params dict recursively: column refs -> ColumnData, scalars pass through.
+async function resolveParams(params, data, regl, plot) {
+  if (params === null || params === undefined) return params
+  if (typeof params === 'number' || typeof params === 'boolean') return params
+  if (params instanceof ColumnData) return params
+  if (params instanceof Float32Array) return params
+
+  if (typeof params === 'string') {
+    const col = data?.getData(params)
+    return col ?? params  // fall back to string value if not a known column
+  }
+
+  if (typeof params === 'object') {
+    const keys = Object.keys(params)
+    if (keys.length === 1 &&
+        (textureComputations.has(keys[0]) || glslComputations.has(keys[0]))) {
+      return await resolveExprToColumn(params, data, regl, plot)
+    }
     const resolved = {}
-    for (const [k, v] of Object.entries(expr)) {
-      resolved[k] = resolveToRawValue(regl, v, `${path}_${k}`, getAxisDomain)
+    for (const [k, v] of Object.entries(params)) {
+      resolved[k] = await resolveParams(v, data, regl, plot)
     }
     return resolved
   }
 
-  throw new Error(`Cannot resolve to raw value: ${JSON.stringify(expr)}`)
+  return params
 }
 
-// Resolve expr to a GLSL expression string.
-// Side effects: populates context.bufferAttrs, textureUniforms, scalarUniforms, globalDecls, axisUpdaters.
-function resolveToGlslExpr(regl, expr, path, context, plot) {
+// ─── resolveAttributeExpr ────────────────────────────────────────────────────
+// Entry point from LayerType.createDrawCommand. Returns:
+//   { kind: 'buffer', value: Float32Array }                 — fixed geometry
+//   { kind: 'computed', glslExpr, textures, col }           — data column
+export async function resolveAttributeExpr(regl, expr, attrShaderName, plot) {
   if (expr instanceof Float32Array) {
-    const attrName = `a_cgen_${path}`
-    context.bufferAttrs[attrName] = expr
-    context.globalDecls.push(`attribute float ${attrName};`)
-    return attrName
+    return { kind: 'buffer', value: expr }
   }
 
-  if (isTexture(expr)) {
-    const uniformName = `u_cgen_${path}`
-    const widthName = `u_cgen_${path}_width`
-    context.textureUniforms[uniformName] = expr
-    context.scalarUniforms[widthName] = expr.width
-    context.globalDecls.push(`uniform sampler2D ${uniformName};`)
-    context.globalDecls.push(`uniform float ${widthName};`)
-    return `texture2D(${uniformName}, vec2((a_pickId + 0.5) / ${widthName}, 0.5)).r`
-  }
+  const data = plot ? plot.currentData : null
+  const col = (expr instanceof ColumnData)
+    ? expr
+    : await resolveExprToColumn(expr, data, regl, plot)
 
-  if (typeof expr === 'number') {
-    const uniformName = `u_cgen_${path}`
-    context.scalarUniforms[uniformName] = expr
-    context.globalDecls.push(`uniform float ${uniformName};`)
-    return uniformName
-  }
+  const safePath = attrShaderName.replace(/[^a-zA-Z0-9_]/g, '_')
+  const { glslExpr, textures } = col.resolve(safePath, regl)
+  return { kind: 'computed', glslExpr, textures, col }
+}
 
-  if (typeof expr === 'object' && expr !== null) {
+// ─── resolveQuantityKind ─────────────────────────────────────────────────────
+export function resolveQuantityKind(expr, data) {
+  if (expr instanceof ColumnData) return expr.quantityKind
+  if (typeof expr === 'string') {
+    return (data ? data.getQuantityKind(expr) : null) ?? expr
+  }
+  if (expr && typeof expr === 'object') {
     const keys = Object.keys(expr)
-
     if (keys.length === 1) {
       const compName = keys[0]
-      const params = expr[compName]
-
-      if (textureComputations.has(compName)) {
-        const comp = textureComputations.get(compName)
-        const uniformName = `u_cgen_${path}`
-        const widthName = `u_cgen_${path}_width`
-
-        // Live reference updated when axis domains change.
-        const liveRef = {
-          texture: null,
-          accessedAxes: new Set(),
-          cachedDomains: {}
-        }
-
-        const makeTrackingGetter = (ref, currentPlot) => (axisId) => {
-          ref.accessedAxes.add(axisId)
-          return currentPlot ? currentPlot.getAxisDomain(axisId) : null
-        }
-
-        // Initial computation with axis tracking.
-        const initGetter = makeTrackingGetter(liveRef, plot)
-        const resolvedParams = resolveToRawValue(regl, params, path, initGetter)
-        liveRef.texture = comp.compute(regl, resolvedParams, initGetter)
-
-        // Cache the domains accessed during initial computation.
-        for (const axisId of liveRef.accessedAxes) {
-          liveRef.cachedDomains[axisId] = plot ? plot.getAxisDomain(axisId) : null
-        }
-
-        // Use a function so regl reads the current texture each frame.
-        context.textureUniforms[uniformName] = () => liveRef.texture
-        // Texture width is constant across recomputes (same bins count).
-        context.scalarUniforms[widthName] = liveRef.texture.width
-        context.globalDecls.push(`uniform sampler2D ${uniformName};`)
-        context.globalDecls.push(`uniform float ${widthName};`)
-
-        context.axisUpdaters.push({
-          refreshIfNeeded(currentPlot) {
-            if (liveRef.accessedAxes.size === 0) return
-
-            let needsRecompute = false
-            for (const axisId of liveRef.accessedAxes) {
-              if (!domainsEqual(currentPlot.getAxisDomain(axisId), liveRef.cachedDomains[axisId])) {
-                needsRecompute = true
-                break
-              }
-            }
-            if (!needsRecompute) return
-
-            // Recompute with fresh axis tracking so new dependencies are captured.
-            const newRef = { accessedAxes: new Set(), cachedDomains: {} }
-            const newGetter = makeTrackingGetter(newRef, currentPlot)
-            const newParams = resolveToRawValue(regl, params, path, newGetter)
-            newRef.texture = comp.compute(regl, newParams, newGetter)
-            for (const axisId of newRef.accessedAxes) {
-              newRef.cachedDomains[axisId] = currentPlot.getAxisDomain(axisId)
-            }
-
-            // Update live ref in-place so the dynamic uniform picks up the new texture.
-            liveRef.texture = newRef.texture
-            liveRef.accessedAxes = newRef.accessedAxes
-            liveRef.cachedDomains = newRef.cachedDomains
-          }
-        })
-
-        return `texture2D(${uniformName}, vec2((a_pickId + 0.5) / ${widthName}, 0.5)).r`
-      }
-
-      if (glslComputations.has(compName)) {
-        const comp = glslComputations.get(compName)
-        const resolvedGlslParams = {}
-        for (const [k, v] of Object.entries(params)) {
-          resolvedGlslParams[k] = resolveToGlslExpr(regl, v, `${path}_${k}`, context, plot)
-        }
-        return comp.glsl(resolvedGlslParams)
-      }
+      const comp = textureComputations.get(compName) ?? glslComputations.get(compName)
+      if (comp) return comp.getQuantityKind(expr[compName], data)
     }
   }
+  return null
+}
+
+// ─── Schema builders ──────────────────────────────────────────────────────────
+export const EXPRESSION_REF     = { '$ref': '#/$defs/expression' }
+export const EXPRESSION_REF_OPT = { '$ref': '#/$defs/expression_opt' }
 
-  throw new Error(`Cannot resolve to GLSL expression: ${JSON.stringify(expr)}`)
+export function buildTransformSchema(data) {
+  const defs = {}
+  for (const [name, comp] of computedDataRegistry) {
+    defs[`params_computeddata_${name}`] = comp.schema(data)
+  }
+  defs.transform_expression = {
+    anyOf: [...computedDataRegistry].map(([name]) => ({
+      type: 'object',
+      title: name,
+      properties: { [name]: { '$ref': `#/$defs/params_computeddata_${name}` } },
+      required: [name],
+      additionalProperties: false
+    }))
+  }
+  return { '$defs': defs }
 }
 
-// Top-level resolver: decides whether expr is a plain buffer or a computed attribute.
-export function resolveAttributeExpr(regl, expr, attrShaderName, plot) {
-  if (expr instanceof Float32Array) {
-    return { kind: 'buffer', value: expr }
+export function computationSchema(data) {
+  const cols = data ? data.columns() : []
+  const defs = {}
+
+  for (const [name, comp] of textureComputations) {
+    defs[`params_${name}`] = comp.schema(data)
+  }
+  for (const [name, comp] of glslComputations) {
+    defs[`params_${name}`] = comp.schema(data)
   }
 
-  const context = {
-    bufferAttrs: {},
-    textureUniforms: {},
-    scalarUniforms: {},
-    globalDecls: [],
-    axisUpdaters: []
+  defs.expression = {
+    anyOf: [
+      ...cols.map(col => ({ type: 'string', const: col, enum: [col], title: col, readOnly: true })),
+      ...[...textureComputations, ...glslComputations].map(([name]) => ({
+        type: 'object',
+        title: name,
+        properties: { [name]: { '$ref': `#/$defs/params_${name}` } },
+        required: [name],
+        additionalProperties: false
+      }))
+    ]
   }
-  const glslExpr = resolveToGlslExpr(regl, expr, attrShaderName, context, plot)
-  return { kind: 'computed', glslExpr, context }
+
+  defs.expression_opt = {
+    anyOf: [
+      { type: 'string', const: 'none', enum: ['none'], title: 'none', readOnly: true },
+      ...defs.expression.anyOf
+    ]
+  }
+
+  return { '$defs': defs, '$ref': '#/$defs/expression' }
 }

package/src/compute/axisFilter.js

@@ -1,38 +1,50 @@
-import { registerTextureComputation, TextureComputation, EXPRESSION_REF } from "./ComputationRegistry.js"
+import { registerTextureComputation, EXPRESSION_REF } from "./ComputationRegistry.js"
+import { TextureComputation } from "../data/Computation.js"
+import { ArrayColumn, uploadToTexture } from "../data/ColumnData.js"
 import makeHistogram from "./hist.js"
 
 // Texture computation that filters the input data by a filter axis range and
 // then builds a histogram texture from the surviving values.
 //
 // params:
-//   input        — Float32Array of values normalised to [0, 1] (for histogram bins)
-//   filterValues — Float32Array of raw filter-column values (same length as input)
+//   input        — ColumnData of values normalised to [0, 1] (for histogram bins); must be ArrayColumn
+//   filterValues — ColumnData of raw filter-column values (same length as input); must be ArrayColumn
 //   filterAxisId — string: axis ID / quantity kind whose domain drives the filter
 //   bins         — optional number of histogram bins
 //
 // getAxisDomain(filterAxisId) returns [min|null, max|null] where null means
 // unbounded.  The computation is re-run automatically whenever the domain changes.
 class FilteredHistogramComputation extends TextureComputation {
-  compute(regl, params, getAxisDomain) {
-    const { input, filterValues, filterAxisId, bins } = params
+  compute(regl, inputs, getAxisDomain) {
+    const inputCol = inputs.input
+    const filterCol = inputs.filterValues
+    if (!(inputCol instanceof ArrayColumn)) throw new Error('filteredHistogram: input must be ArrayColumn')
+    if (!(filterCol instanceof ArrayColumn)) throw new Error('filteredHistogram: filterValues must be ArrayColumn')
+
+    const inputArr = inputCol.array
+    const filterArr = filterCol.array
+    const { filterAxisId, bins } = inputs
     const domain = getAxisDomain(filterAxisId)   // [min|null, max|null] or null
     const filterMin = domain?.[0] ?? null
     const filterMax = domain?.[1] ?? null
 
     // Build a compact array of the normalised values that pass the filter.
     const filtered = []
-    for (let i = 0; i < input.length; i++) {
-      const fv = filterValues[i]
+    for (let i = 0; i < inputArr.length; i++) {
+      const fv = filterArr[i]
       if (filterMin !== null && fv < filterMin) continue
       if (filterMax !== null && fv > filterMax) continue
-      filtered.push(input[i])
+      filtered.push(inputArr[i])
     }
 
-    return makeHistogram(regl, new Float32Array(filtered), { bins })
+    const filteredTex = uploadToTexture(regl, new Float32Array(filtered))
+    return makeHistogram(regl, filteredTex, { bins })
   }
+
   schema(data) {
     return {
       type: 'object',
+      title: 'filteredHistogram',
       properties: {
         input: EXPRESSION_REF,
         filterValues: EXPRESSION_REF,

package/src/compute/conv.js

@@ -1,5 +1,6 @@
 import { fftConvolution } from "./fft.js"
-import { registerTextureComputation, TextureComputation, EXPRESSION_REF } from "./ComputationRegistry.js"
+import { registerTextureComputation, EXPRESSION_REF, resolveQuantityKind } from "./ComputationRegistry.js"
+import { TextureComputation } from "../data/Computation.js"
 
 /*
   ============================================================
@@ -13,6 +14,7 @@ function nextPow2(n) {
   return 1 << Math.ceil(Math.log2(n));
 }
 
+// Internal: builds a 1-value-per-texel R-channel texture (not exposed via sampleColumn)
 function make1DTexture(regl, data, width) {
   return regl.texture({
     data,
@@ -26,6 +28,7 @@ function make1DTexture(regl, data, width) {
   });
 }
 
+// Internal: creates an R-channel FBO of given width
 function makeFBO(regl, width) {
   return regl.framebuffer({
     color: regl.texture({
@@ -33,10 +36,52 @@ function makeFBO(regl, width) {
       height: 1,
       format: "rgba",
       type: "float"
-    })
+    }),
+    depth: false,
+    stencil: false,
   });
 }
 
+// Repack a 1-value-per-texel R-channel texture into a 4-packed RGBA texture.
+// The source texture has elements at (i % srcW, i / srcW).r
+// The output has elements packed 4 per texel, _dataLength set.
+function repackToQuadTexture(regl, sourceTex, 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 sourceTex;
+    uniform int totalLength;
+    out vec4 fragColor;
+    void main() {
+      ivec2 srcSz = textureSize(sourceTex, 0);
+      int texelI = int(gl_FragCoord.y) * ${w} + int(gl_FragCoord.x);
+      int base = texelI * 4;
+      float v0 = base + 0 < totalLength ? texelFetch(sourceTex, ivec2((base+0) % srcSz.x, (base+0) / srcSz.x), 0).r : 0.0;
+      float v1 = base + 1 < totalLength ? texelFetch(sourceTex, ivec2((base+1) % srcSz.x, (base+1) / srcSz.x), 0).r : 0.0;
+      float v2 = base + 2 < totalLength ? texelFetch(sourceTex, ivec2((base+2) % srcSz.x, (base+2) / srcSz.x), 0).r : 0.0;
+      float v3 = base + 3 < totalLength ? texelFetch(sourceTex, ivec2((base+3) % srcSz.x, (base+3) / srcSz.x), 0).r : 0.0;
+      fragColor = vec4(v0, v1, v2, v3);
+    }`,
+    attributes: { position: [[-1,-1],[1,-1],[-1,1],[1,1]] },
+    uniforms: { sourceTex, totalLength: N },
+    count: 4,
+    primitive: 'triangle strip'
+  })()
+
+  outputTex._dataLength = N
+  return outputTex
+}
+
 /*
   ============================================================
   1) Single-pass convolution (kernel ≤ 1024)
@@ -182,6 +227,8 @@ export default function adaptiveConvolution(regl, signalArray, kernelArray) {
 
   const signalTex = make1DTexture(regl, signalArray, N);
 
+  let result;
+
   // Case 1: single pass
   if (K <= MAX_KERNEL_LOOP) {
     const kernelTex = make1DTexture(regl, kernelArray, K);
@@ -195,12 +242,12 @@ export default function adaptiveConvolution(regl, signalArray, kernelArray) {
       fbo
     });
 
-    return fbo.color[0];
+    result = fbo.color[0];
   }
 
   // Case 2: chunked
-  if (K <= 8192) {
-    return chunked({
+  else if (K <= 8192) {
+    result = chunked({
       signalTex,
       kernel: kernelArray,
       N
@@ -208,16 +255,25 @@ export default function adaptiveConvolution(regl, signalArray, kernelArray) {
   }
 
   // Case 3: FFT
-  return fftConvolution(regl, signalArray, kernelArray);
+  else {
+    result = fftConvolution(regl, signalArray, kernelArray);
+  }
+
+  // Repack internal R-channel result into 4-packed output for sampleColumn
+  return repackToQuadTexture(regl, result, N);
 }
 
 class ConvolutionComputation extends TextureComputation {
-  compute(regl, params) {
-    return adaptiveConvolution(regl, params.signal, params.kernel)
+  getQuantityKind(params, data) { return resolveQuantityKind(params.signal, data) }
+  compute(regl, params, data, getAxisDomain) {
+    const signal = typeof params.signal === 'string' ? data.getData(params.signal) : params.signal
+    const kernel = typeof params.kernel === 'string' ? data.getData(params.kernel) : params.kernel
+    return adaptiveConvolution(regl, signal, kernel)
   }
   schema(data) {
     return {
       type: 'object',
+      title: 'convolution',
       properties: {
         signal: EXPRESSION_REF,
         kernel: EXPRESSION_REF

package/src/compute/elementwise.js

@@ -0,0 +1,72 @@
+import { registerComputedData, EXPRESSION_REF, resolveExprToColumn } from "./ComputationRegistry.js"
+import { ComputedData } from "../data/Computation.js"
+
+const TDR_STEP_MS = 500
+
+class ElementwiseData extends ComputedData {
+  columns(params) {
+    if (!params?.columns) return []
+    return params.columns.map(c => c.dst)
+  }
+
+  async compute(regl, params, data, getAxisDomain) {
+    const plotProxy = { currentData: data, getAxisDomain }
+
+    let N = params.dataLength ?? null
+    if (N == null) {
+      for (const { src } of params.columns) {
+        const col = await resolveExprToColumn(src, data, regl, plotProxy)
+        if (col?.length !== null) { N = col.length; break }
+      }
+    }
+    if (N == null) throw new Error('ElementwiseData: cannot determine data length; set dataLength param')
+
+    const result = {}
+    const quantityKinds = {}
+    let stepStart = performance.now()
+
+    for (const { dst, src, quantityKind } of params.columns) {
+      const col = await resolveExprToColumn(src, data, regl, plotProxy)
+      const tex = col.toTexture(regl)
+      tex._dataLength = N
+      result[dst] = tex
+      if (quantityKind) quantityKinds[dst] = quantityKind
+
+      if (performance.now() - stepStart > TDR_STEP_MS) {
+        await new Promise(r => requestAnimationFrame(r))
+        stepStart = performance.now()
+      }
+    }
+
+    if (Object.keys(quantityKinds).length > 0) result._meta = { quantityKinds }
+    return result
+  }
+
+  schema(data) {
+    return {
+      type: 'object',
+      title: 'ElementwiseData',
+      properties: {
+        dataLength: {
+          type: 'integer',
+          description: 'Override output length (optional, auto-detected from column refs)'
+        },
+        columns: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              dst:          { type: 'string', description: 'Output column name' },
+              src:          EXPRESSION_REF,
+              quantityKind: { type: 'string', description: 'Quantity kind for axis matching (optional)' }
+            },
+            required: ['dst', 'src']
+          }
+        }
+      },
+      required: ['columns']
+    }
+  }
+}
+
+registerComputedData('ElementwiseData', new ElementwiseData())