gladly-plot 0.0.4 → 0.0.6

package/src/colorscales/ColorscaleRegistry.js

@@ -0,0 +1,144 @@
+const colorscales = new Map()
+const colorscales2d = new Map()
+
+export function registerColorscale(name, glslFn) {
+  colorscales.set(name, glslFn)
+}
+
+export function register2DColorscale(name, glslFn) {
+  colorscales2d.set(name, glslFn)
+}
+
+export function getRegisteredColorscales() {
+  return colorscales
+}
+
+export function getRegistered2DColorscales() {
+  return colorscales2d
+}
+
+export function getColorscaleIndex(name) {
+  let idx = 0
+  for (const key of colorscales.keys()) {
+    if (key === name) return idx
+    idx++
+  }
+  // 2D colorscales use negative indices: -(idx + 1)
+  let idx2d = 0
+  for (const key of colorscales2d.keys()) {
+    if (key === name) return -(idx2d + 1)
+    idx2d++
+  }
+  return 0
+}
+
+export function get2DColorscaleIndex(name) {
+  let idx = 0
+  for (const key of colorscales2d.keys()) {
+    if (key === name) return -(idx + 1)
+    idx++
+  }
+  return null
+}
+
+export function buildColorGlsl() {
+  if (colorscales.size === 0 && colorscales2d.size === 0) return ''
+
+  const parts = []
+
+  // 1D colorscale functions
+  for (const glslFn of colorscales.values()) {
+    parts.push(glslFn)
+  }
+
+  // 2D colorscale functions (fn signature: vec4 colorscale_2d_<name>(vec2 t))
+  for (const glslFn of colorscales2d.values()) {
+    parts.push(glslFn)
+  }
+
+  // map_color — 1D dispatch, operates in already-transformed (possibly log) space
+  parts.push('vec4 map_color(int cs, vec2 range, float value) {')
+  parts.push('  float t = clamp((value - range.x) / (range.y - range.x), 0.0, 1.0);')
+  let idx = 0
+  for (const name of colorscales.keys()) {
+    parts.push(`  if (cs == ${idx}) return colorscale_${name}(t);`)
+    idx++
+  }
+  parts.push('  return vec4(0.5, 0.5, 0.5, 1.0);')
+  parts.push('}')
+
+  // map_color_2d — 2D dispatch, takes normalized vec2 t in [0,1]x[0,1]
+  parts.push('vec4 map_color_2d(int cs, vec2 t) {')
+  let idx2d = 0
+  for (const name of colorscales2d.keys()) {
+    parts.push(`  if (cs == ${idx2d}) return colorscale_2d_${name}(t);`)
+    idx2d++
+  }
+  parts.push('  return vec4(0.5, 0.5, 0.5, 1.0);')
+  parts.push('}')
+
+  // map_color_s — 1D with scale type, alpha blending, and picking
+  parts.push('vec4 map_color_s(int cs, vec2 range, float v, float scaleType, float useAlpha) {')
+  parts.push('  float vt = scaleType > 0.5 ? log(v) : v;')
+  parts.push('  float r0 = scaleType > 0.5 ? log(range.x) : range.x;')
+  parts.push('  float r1 = scaleType > 0.5 ? log(range.y) : range.y;')
+  parts.push('  float t = clamp((vt - r0) / (r1 - r0), 0.0, 1.0);')
+  parts.push('  vec4 color = map_color(cs, vec2(r0, r1), vt);')
+  parts.push('  if (useAlpha > 0.5) color.a = t;')
+  parts.push('  return gladly_apply_color(color);')
+  parts.push('}')
+
+  // gladly_map_color_raw — like map_color_s but without picking/apply, used internally by map_color_s_2d
+  parts.push('vec4 gladly_map_color_raw(int cs, vec2 range, float v, float scaleType) {')
+  parts.push('  float vt = scaleType > 0.5 ? log(v) : v;')
+  parts.push('  float r0 = scaleType > 0.5 ? log(range.x) : range.x;')
+  parts.push('  float r1 = scaleType > 0.5 ? log(range.y) : range.y;')
+  parts.push('  return map_color(cs, vec2(r0, r1), vt);')
+  parts.push('}')
+
+  // gladly_normalize_color — normalize a data value to [0,1] for 2D colorscale lookup
+  parts.push('float gladly_normalize_color(vec2 range, float v, float scaleType) {')
+  parts.push('  float vt = scaleType > 0.5 ? log(v) : v;')
+  parts.push('  float r0 = scaleType > 0.5 ? log(range.x) : range.x;')
+  parts.push('  float r1 = scaleType > 0.5 ? log(range.y) : range.y;')
+  parts.push('  return clamp((vt - r0) / (r1 - r0), 0.0, 1.0);')
+  parts.push('}')
+
+  // map_color_s_2d — blend two 1D colorscales, or dispatch to a true 2D colorscale.
+  // A true 2D colorscale is selected when cs_a < 0 && cs_a == cs_b (both axes share the
+  // same 2D colorscale, identified by the negative index -(idx+1)).
+  // useAlpha_a / useAlpha_b: if > 0.5, the normalised value for that axis modulates alpha.
+  parts.push('vec4 map_color_s_2d(int cs_a, vec2 range_a, float v_a, float type_a, float useAlpha_a,')
+  parts.push('                    int cs_b, vec2 range_b, float v_b, float type_b, float useAlpha_b) {')
+
+  parts.push('  bool a_nan = isnan(v_a);')
+  parts.push('  bool b_nan = isnan(v_b);')
+  parts.push('  vec4 c;')
+
+  parts.push('  if (cs_a < 0 && cs_a == cs_b) {')
+  parts.push('    float ta = a_nan ? 0.0 : gladly_normalize_color(range_a, v_a, type_a);')
+  parts.push('    float tb = b_nan ? 0.0 : gladly_normalize_color(range_b, v_b, type_b);')
+  parts.push('    c = map_color_2d(-(cs_a + 1), vec2(ta, tb));')
+  parts.push('  } else if (cs_a >= 0) {')
+  parts.push('    if (!a_nan)      c = gladly_map_color_raw(cs_a, range_a, v_a, type_a);')
+  parts.push('    else if (!b_nan) c = gladly_map_color_raw(cs_b, range_b, v_b, type_b);')
+  parts.push('    else             c = vec4(0.0);')
+  parts.push('  } else {')
+  parts.push('    // fallback (cs_a < 0 but not equal to cs_b)')
+  parts.push('    if (!a_nan && !b_nan) {')
+  parts.push('      vec4 ca = gladly_map_color_raw(cs_a, range_a, v_a, type_a);')
+  parts.push('      vec4 cb = gladly_map_color_raw(cs_b, range_b, v_b, type_b);')
+  parts.push('      c = (ca + cb) / 2.0;')
+  parts.push('    } else if (!a_nan) c = gladly_map_color_raw(cs_a, range_a, v_a, type_a);')
+  parts.push('    else if (!b_nan)   c = gladly_map_color_raw(cs_b, range_b, v_b, type_b);')
+  parts.push('    else               c = vec4(0.0);')
+  parts.push('  }')
+
+  parts.push('  if (!a_nan && useAlpha_a > 0.5) c.a  = gladly_normalize_color(range_a, v_a, type_a);')
+  parts.push('  if (!b_nan && useAlpha_b > 0.5) c.a *= gladly_normalize_color(range_b, v_b, type_b);')
+
+  parts.push('  return gladly_apply_color(c);')
+  parts.push('}')
+  
+  return parts.join('\n')
+}

package/src/compute/ComputationRegistry.js

@@ -0,0 +1,179 @@
+import { ColumnData } from '../data/ColumnData.js'
+
+const textureComputations = new Map()
+const glslComputations = new Map()
+const computedDataRegistry = new Map()
+
+// ─── Registration ─────────────────────────────────────────────────────────────
+export function registerTextureComputation(name, computation) {
+  textureComputations.set(name, computation)
+}
+
+export function registerGlslComputation(name, computation) {
+  glslComputations.set(name, computation)
+}
+
+export function registerComputedData(name, instance) {
+  computedDataRegistry.set(name, instance)
+}
+
+export function getComputedData(name) {
+  return computedDataRegistry.get(name)
+}
+
+export function getRegisteredComputedData() {
+  return computedDataRegistry
+}
+
+// ─── 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)
+    if (keys.length === 1) {
+      const compName = keys[0]
+      const params = expr[compName]
+
+      if (textureComputations.has(compName)) {
+        const comp = textureComputations.get(compName)
+        const resolvedInputs = await resolveParams(params, data, regl, plot)
+        return await comp.createColumn(regl, resolvedInputs, plot)
+      }
+
+      if (glslComputations.has(compName)) {
+        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)}`)
+}
+
+// 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(params)) {
+      resolved[k] = await resolveParams(v, data, regl, plot)
+    }
+    return resolved
+  }
+
+  return params
+}
+
+// ─── 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) {
+    return { kind: 'buffer', value: expr }
+  }
+
+  const data = plot ? plot.currentData : null
+  const col = (expr instanceof ColumnData)
+    ? expr
+    : await resolveExprToColumn(expr, data, regl, plot)
+
+  const safePath = attrShaderName.replace(/[^a-zA-Z0-9_]/g, '_')
+  const { glslExpr, textures } = col.resolve(safePath, regl)
+  return { kind: 'computed', glslExpr, textures, col }
+}
+
+// ─── 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 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' }
+
+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 }
+}
+
+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: [
+      ...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
+      }))
+    ]
+  }
+
+  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

@@ -0,0 +1,59 @@
+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        — 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, 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 < inputArr.length; i++) {
+      const fv = filterArr[i]
+      if (filterMin !== null && fv < filterMin) continue
+      if (filterMax !== null && fv > filterMax) continue
+      filtered.push(inputArr[i])
+    }
+
+    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,
+        filterAxisId: { type: 'string' },
+        bins: { type: 'number' }
+      },
+      required: ['input', 'filterValues', 'filterAxisId']
+    }
+  }
+}
+
+registerTextureComputation('filteredHistogram', new FilteredHistogramComputation())

package/src/compute/conv.js

@@ -0,0 +1,286 @@
+import { fftConvolution } from "./fft.js"
+import { registerTextureComputation, EXPRESSION_REF, resolveQuantityKind } from "./ComputationRegistry.js"
+import { TextureComputation } from "../data/Computation.js"
+
+/*
+  ============================================================
+  Utilities
+  ============================================================
+*/
+
+const MAX_KERNEL_LOOP = 1024;
+
+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,
+    width,
+    height: 1,
+    format: "rgba",
+    type: "float",
+    wrap: "clamp",
+    min: "nearest",
+    mag: "nearest"
+  });
+}
+
+// Internal: creates an R-channel FBO of given width
+function makeFBO(regl, width) {
+  return regl.framebuffer({
+    color: regl.texture({
+      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)
+  ============================================================
+*/
+
+function singlePassConvolution(regl) {
+  return regl({
+    frag: `#version 300 es
+    precision highp float;
+    uniform sampler2D signal, kernel;
+    uniform int N, K;
+    out vec4 outColor;
+
+    void main() {
+      int x = int(gl_FragCoord.x);
+      float sum = 0.0;
+
+      for (int i = 0; i < ${MAX_KERNEL_LOOP}; i++) {
+        if (i >= K) break;
+        int xi = x - i;
+        if (xi < 0 || xi >= N) continue;
+
+        float s = texelFetch(signal, ivec2(xi, 0), 0).r;
+        float k = texelFetch(kernel, ivec2(i, 0), 0).r;
+        sum += s * k;
+      }
+
+      outColor = vec4(sum, 0, 0, 1);
+    }`,
+    vert: `#version 300 es
+    in vec2 position;
+    void main() {
+      gl_Position = vec4(position, 0, 1);
+    }`,
+    attributes: {
+      position: [[-1,-1],[1,-1],[-1,1],[1,1]]
+    },
+    uniforms: {
+      signal: regl.prop("signal"),
+      kernel: regl.prop("kernel"),
+      N: regl.prop("N"),
+      K: regl.prop("K")
+    },
+    framebuffer: regl.prop("fbo"),
+    count: 4,
+    primitive: "triangle strip"
+  });
+}
+
+/*
+  ============================================================
+  2) Two-pass chunked convolution (arbitrary kernel size)
+  ============================================================
+*/
+
+function chunkedConvolution(regl) {
+  const partialPass = regl({
+    frag: `#version 300 es
+    precision highp float;
+    uniform sampler2D signal, kernel2D;
+    uniform int N, chunkOffset;
+    out vec4 outColor;
+
+    void main() {
+      int x = int(gl_FragCoord.x);
+      float sum = 0.0;
+
+      for (int i = 0; i < ${MAX_KERNEL_LOOP}; i++) {
+        int kIndex = chunkOffset + i;
+        int xi = x - kIndex;
+        if (xi < 0 || xi >= N) continue;
+
+        float s = texelFetch(signal, ivec2(xi, 0), 0).r;
+        float k = texelFetch(kernel2D, ivec2(i, 0), 0).r;
+        sum += s * k;
+      }
+
+      outColor = vec4(sum, 0, 0, 1);
+    }`,
+    vert: `#version 300 es
+    in vec2 position;
+    void main() {
+      gl_Position = vec4(position, 0, 1);
+    }`,
+    attributes: {
+      position: [[-1,-1],[1,-1],[-1,1],[1,1]]
+    },
+    uniforms: {
+      signal: regl.prop("signal"),
+      kernel2D: regl.prop("kernel"),
+      N: regl.prop("N"),
+      chunkOffset: regl.prop("offset")
+    },
+    framebuffer: regl.prop("fbo"),
+    blend: {
+      enable: true,
+      func: { src: "one", dst: "one" }
+    },
+    count: 4,
+    primitive: "triangle strip"
+  });
+
+  return function run({ signalTex, kernel, N }) {
+    const chunks = Math.ceil(kernel.length / MAX_KERNEL_LOOP);
+    const fbo = makeFBO(regl, N);
+
+    regl.clear({ framebuffer: fbo, color: [0,0,0,0] });
+
+    for (let c = 0; c < chunks; c++) {
+      const slice = kernel.slice(
+        c * MAX_KERNEL_LOOP,
+        (c + 1) * MAX_KERNEL_LOOP
+      );
+
+      const kernelTex = make1DTexture(regl, slice, MAX_KERNEL_LOOP);
+
+      partialPass({
+        signal: signalTex,
+        kernel: kernelTex,
+        N,
+        offset: c * MAX_KERNEL_LOOP,
+        fbo
+      });
+    }
+
+    return fbo.color[0];
+  };
+}
+
+/*
+  ============================================================
+  Adaptive wrapper
+  ============================================================
+*/
+
+export default function adaptiveConvolution(regl, signalArray, kernelArray) {
+  const single = singlePassConvolution(regl);
+  const chunked = chunkedConvolution(regl);
+
+  const N = signalArray.length;
+  const K = kernelArray.length;
+
+  const signalTex = make1DTexture(regl, signalArray, N);
+
+  let result;
+
+  // Case 1: single pass
+  if (K <= MAX_KERNEL_LOOP) {
+    const kernelTex = make1DTexture(regl, kernelArray, K);
+    const fbo = makeFBO(regl, N);
+
+    single({
+      signal: signalTex,
+      kernel: kernelTex,
+      N,
+      K,
+      fbo
+    });
+
+    result = fbo.color[0];
+  }
+
+  // Case 2: chunked
+  else if (K <= 8192) {
+    result = chunked({
+      signalTex,
+      kernel: kernelArray,
+      N
+    });
+  }
+
+  // Case 3: FFT
+  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 {
+  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
+      },
+      required: ['signal', 'kernel']
+    }
+  }
+}
+
+registerTextureComputation('convolution', new ConvolutionComputation())