gladly-plot 0.0.3 → 0.0.5

package/src/colorscales/BivariateColorscales.js

@@ -0,0 +1,205 @@
+import { register2DColorscale } from './ColorscaleRegistry.js'
+
+
+//////////////////////////////
+// 1. Bilinear 4-corner colormap
+//////////////////////////////
+register2DColorscale("bilinear4corner", `
+vec4 colorscale_2d_bilinear4corner(vec2 t) {
+    vec3 c00 = vec3(0.0, 0.0, 1.0);
+    vec3 c10 = vec3(1.0, 0.0, 0.0);
+    vec3 c01 = vec3(0.0, 1.0, 0.0);
+    vec3 c11 = vec3(1.0, 1.0, 0.0);
+    vec3 rgb = (1.0 - t.x)*(1.0 - t.y)*c00 +
+               t.x*(1.0 - t.y)*c10 +
+               (1.0 - t.x)*t.y*c01 +
+               t.x*t.y*c11;
+    return vec4(rgb,1.0);
+}
+`);
+
+register2DColorscale("Gred", `
+vec4 colorscale_2d_Gred(vec2 t) {
+    vec3 c00 = vec3(0.0, 0.0, 0.0);
+    vec3 c10 = vec3(1.0, 0.0, 0.0);
+    vec3 c01 = vec3(0.0, 1.0, 0.0);
+    vec3 c11 = vec3(1.0, 1.0, 1.0);
+    vec3 rgb = (1.0 - t.x)*(1.0 - t.y)*c00 +
+               t.x*(1.0 - t.y)*c10 +
+               (1.0 - t.x)*t.y*c01 +
+               t.x*t.y*c11;
+    return vec4(rgb,1.0);
+}
+`);
+
+register2DColorscale("Reen", `
+vec4 colorscale_2d_Reen(vec2 t) {
+    vec3 c00 = vec3(1.0, 0.0, 0.0);
+    vec3 c10 = vec3(0.0, 0.0, 0.0);
+    vec3 c01 = vec3(1.0, 1.0, 1.0);
+    vec3 c11 = vec3(0.0, 1.0, 0.0);
+    vec3 rgb = (1.0 - t.x)*(1.0 - t.y)*c00 +
+               t.x*(1.0 - t.y)*c10 +
+               (1.0 - t.x)*t.y*c01 +
+               t.x*t.y*c11;
+    return vec4(rgb,1.0);
+}
+`);
+
+
+//////////////////////////////
+// 2. HSV Phase-Magnitude Map
+//////////////////////////////
+register2DColorscale("hsv_phase_magnitude", `
+vec4 colorscale_2d_hsv_phase_magnitude(vec2 t) {
+    float angle = atan(t.y - 0.5, t.x - 0.5);
+    float r = length(t - vec2(0.5));
+    float H = (angle + 3.1415926)/(2.0*3.1415926);
+    float S = 1.0;
+    float V = clamp(r*1.4142136,0.0,1.0);
+    float c = V*S;
+    float h = H*6.0;
+    float x = c*(1.0 - abs(mod(h,2.0)-1.0));
+    vec3 rgb;
+    if(h<1.0) rgb = vec3(c,x,0.0);
+    else if(h<2.0) rgb = vec3(x,c,0.0);
+    else if(h<3.0) rgb = vec3(0.0,c,x);
+    else if(h<4.0) rgb = vec3(0.0,x,c);
+    else if(h<5.0) rgb = vec3(x,0.0,c);
+    else rgb = vec3(c,0.0,x);
+    float m = V - c;
+    rgb += vec3(m);
+    return vec4(rgb,1.0);
+}
+`);
+
+//////////////////////////////
+// 3. Diverging × Diverging Map
+//////////////////////////////
+register2DColorscale("diverging_diverging", `
+vec4 colorscale_2d_diverging_diverging(vec2 t) {
+    vec3 blue = vec3(0.230,0.299,0.754);
+    vec3 white = vec3(1.0);
+    vec3 red = vec3(0.706,0.016,0.150);
+    vec3 rgbX = (t.x<0.5) ? mix(blue,white,t.x*2.0) : mix(white,red,(t.x-0.5)*2.0);
+    vec3 rgbY = (t.y<0.5) ? mix(blue,white,t.y*2.0) : mix(white,red,(t.y-0.5)*2.0);
+    vec3 rgb = 0.5*(rgbX+rgbY);
+    return vec4(rgb,1.0);
+}
+`);
+
+//////////////////////////////
+// 4. Lightness × Hue Map
+//////////////////////////////
+register2DColorscale("lightness_hue", `
+vec4 colorscale_2d_lightness_hue(vec2 t) {
+    float H = t.x;
+    float L = t.y;
+    float C = 1.0 - abs(2.0*L-1.0);
+    float X = C*(1.0 - abs(mod(H*6.0,2.0)-1.0));
+    vec3 rgb;
+    if(H<1.0/6.0) rgb = vec3(C,X,0.0);
+    else if(H<2.0/6.0) rgb = vec3(X,C,0.0);
+    else if(H<3.0/6.0) rgb = vec3(0.0,C,X);
+    else if(H<4.0/6.0) rgb = vec3(0.0,X,C);
+    else if(H<5.0/6.0) rgb = vec3(X,0.0,C);
+    else rgb = vec3(C,0.0,X);
+    float m = L - 0.5*C;
+    rgb += vec3(m);
+    return vec4(rgb,1.0);
+}
+`);
+
+//////////////////////////////
+// 5. Brewer 3x3 Bivariate Grid (no vec3 c[3][3])
+//////////////////////////////
+register2DColorscale("brewer_3x3", `
+vec4 colorscale_2d_brewer_3x3(vec2 t) {
+    float fx = clamp(t.x*2.0,0.0,2.0);
+    float fy = clamp(t.y*2.0,0.0,2.0);
+    int ix = int(fx);
+    int iy = int(fy);
+    vec3 rgb;
+    if(ix==0 && iy==0) rgb = vec3(215.0,25.0,28.0)/255.0;
+    else if(ix==1 && iy==0) rgb = vec3(253.0,174.0,97.0)/255.0;
+    else if(ix==2 && iy==0) rgb = vec3(255.0,255.0,191.0)/255.0;
+    else if(ix==0 && iy==1) rgb = vec3(224.0,130.0,20.0)/255.0;
+    else if(ix==1 && iy==1) rgb = vec3(255.0,255.0,179.0)/255.0;
+    else if(ix==2 && iy==1) rgb = vec3(171.0,221.0,164.0)/255.0;
+    else if(ix==0 && iy==2) rgb = vec3(26.0,150.0,65.0)/255.0;
+    else if(ix==1 && iy==2) rgb = vec3(166.0,217.0,106.0)/255.0;
+    else rgb = vec3(102.0,194.0,165.0)/255.0;
+    return vec4(rgb,1.0);
+}
+`);
+
+//////////////////////////////
+// 6. Moreland 5x5 Perceptual Grid (flattened)
+//////////////////////////////
+register2DColorscale("moreland_5x5", `
+vec4 colorscale_2d_moreland_5x5(vec2 t) {
+    float fx = clamp(t.x*4.0,0.0,4.0);
+    float fy = clamp(t.y*4.0,0.0,4.0);
+    int ix = int(fx);
+    int iy = int(fy);
+    vec3 rgb;
+    if(ix==0 && iy==0) rgb = vec3(0.230,0.299,0.754);
+    else if(ix==1 && iy==0) rgb = vec3(0.375,0.544,0.837);
+    else if(ix==2 && iy==0) rgb = vec3(0.625,0.732,0.941);
+    else if(ix==3 && iy==0) rgb = vec3(0.843,0.867,0.996);
+    else if(ix==4 && iy==0) rgb = vec3(0.980,0.957,0.996);
+    else if(ix==0 && iy==1) rgb = vec3(0.266,0.353,0.819);
+    else if(ix==1 && iy==1) rgb = vec3(0.420,0.585,0.876);
+    else if(ix==2 && iy==1) rgb = vec3(0.666,0.762,0.961);
+    else if(ix==3 && iy==1) rgb = vec3(0.876,0.888,0.996);
+    else if(ix==4 && iy==1) rgb = vec3(0.992,0.969,0.996);
+    else if(ix==0 && iy==2) rgb = vec3(0.305,0.407,0.875);
+    else if(ix==1 && iy==2) rgb = vec3(0.466,0.625,0.911);
+    else if(ix==2 && iy==2) rgb = vec3(0.710,0.791,0.976);
+    else if(ix==3 && iy==2) rgb = vec3(0.905,0.908,0.996);
+    else if(ix==4 && iy==2) rgb = vec3(0.996,0.980,0.996);
+    else if(ix==0 && iy==3) rgb = vec3(0.349,0.460,0.926);
+    else if(ix==1 && iy==3) rgb = vec3(0.514,0.664,0.944);
+    else if(ix==2 && iy==3) rgb = vec3(0.753,0.817,0.988);
+    else if(ix==3 && iy==3) rgb = vec3(0.933,0.926,0.996);
+    else if(ix==4 && iy==3) rgb = vec3(0.996,0.988,0.996);
+    else if(ix==0 && iy==4) rgb = vec3(0.403,0.509,0.965);
+    else if(ix==1 && iy==4) rgb = vec3(0.563,0.700,0.972);
+    else if(ix==2 && iy==4) rgb = vec3(0.796,0.843,0.996);
+    else if(ix==3 && iy==4) rgb = vec3(0.960,0.944,0.996);
+    else rgb = vec3(1.000,1.000,1.000);
+    return vec4(rgb,1.0);
+}
+`);
+
+//////////////////////////////
+// 7. Boy's Surface / Orientation Map
+//////////////////////////////
+register2DColorscale("boys_surface", `
+vec4 colorscale_2d_boys_surface(vec2 t) {
+    float u = t.x*2.0-1.0;
+    float v = t.y*2.0-1.0;
+    float x = u*(1.0-v*v/2.0);
+    float y = v*(1.0-u*u/2.0);
+    float z = (u*u-v*v)/2.0;
+    vec3 rgb = normalize(vec3(abs(x),abs(y),abs(z)));
+    return vec4(rgb,1.0);
+}
+`);
+
+//////////////////////////////
+// 8. Diverging × Sequential Map
+//////////////////////////////
+register2DColorscale("diverging_sequential", `
+vec4 colorscale_2d_diverging_sequential(vec2 t) {
+    vec3 blue = vec3(0.230,0.299,0.754);
+    vec3 white = vec3(1.0);
+    vec3 red = vec3(0.706,0.016,0.150);
+    vec3 seqStart = vec3(1.0,1.0,0.8);
+    vec3 seqEnd = vec3(0.2,0.8,0.2);
+    vec3 rgbX = (t.x<0.5)? mix(blue,white,t.x*2.0) : mix(white,red,(t.x-0.5)*2.0);
+    vec3 rgbY = mix(seqStart,seqEnd,t.y);
+    vec3 rgb = 0.5*(rgbX+rgbY);
+    return vec4(rgb,1.0);
+}
+`);

package/src/colorscales/ColorscaleRegistry.js

@@ -0,0 +1,124 @@
+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)).
+  parts.push('vec4 map_color_s_2d(int cs_a, vec2 range_a, float v_a, float type_a,')
+  parts.push('                    int cs_b, vec2 range_b, float v_b, float type_b) {')
+  parts.push('  if (cs_a < 0 && cs_a == cs_b) {')
+  parts.push('    float ta = gladly_normalize_color(range_a, v_a, type_a);')
+  parts.push('    float tb = gladly_normalize_color(range_b, v_b, type_b);')
+  parts.push('    return gladly_apply_color(map_color_2d(-(cs_a + 1), vec2(ta, tb)));')
+  parts.push('  }')
+  parts.push('  return gladly_apply_color(')
+  parts.push('    (gladly_map_color_raw(cs_a, range_a, v_a, type_a) +')
+  parts.push('     gladly_map_color_raw(cs_b, range_b, v_b, type_b)) / 2.0')
+  parts.push('  );')
+  parts.push('}')
+
+  return parts.join('\n')
+}

package/src/compute/ComputationRegistry.js

@@ -0,0 +1,237 @@
+const textureComputations = new Map()
+const glslComputations = 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' }
+
+export function registerTextureComputation(name, computation) {
+  textureComputations.set(name, computation)
+}
+
+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' }
+}
+
+// Duck-type check for regl textures.
+export function isTexture(value) {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof value.width === 'number' &&
+    typeof value.subimage === 'function'
+  )
+}
+
+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]
+}
+
+// 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
+
+  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]
+      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)
+      }
+      if (glslComputations.has(compName)) {
+        throw new Error(
+          `GLSL computation '${compName}' cannot be used as a texture computation parameter`
+        )
+      }
+    }
+
+    // Plain params dict: resolve each value recursively.
+    const resolved = {}
+    for (const [k, v] of Object.entries(expr)) {
+      resolved[k] = resolveToRawValue(regl, v, `${path}_${k}`, getAxisDomain)
+    }
+    return resolved
+  }
+
+  throw new Error(`Cannot resolve to raw value: ${JSON.stringify(expr)}`)
+}
+
+// Resolve expr to a GLSL expression string.
+// Side effects: populates context.bufferAttrs, textureUniforms, scalarUniforms, globalDecls, axisUpdaters.
+function resolveToGlslExpr(regl, expr, path, context, plot) {
+  if (expr instanceof Float32Array) {
+    const attrName = `a_cgen_${path}`
+    context.bufferAttrs[attrName] = expr
+    context.globalDecls.push(`attribute float ${attrName};`)
+    return attrName
+  }
+
+  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`
+  }
+
+  if (typeof expr === 'number') {
+    const uniformName = `u_cgen_${path}`
+    context.scalarUniforms[uniformName] = expr
+    context.globalDecls.push(`uniform float ${uniformName};`)
+    return uniformName
+  }
+
+  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 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)
+      }
+    }
+  }
+
+  throw new Error(`Cannot resolve to GLSL expression: ${JSON.stringify(expr)}`)
+}
+
+// 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 }
+  }
+
+  const context = {
+    bufferAttrs: {},
+    textureUniforms: {},
+    scalarUniforms: {},
+    globalDecls: [],
+    axisUpdaters: []
+  }
+  const glslExpr = resolveToGlslExpr(regl, expr, attrShaderName, context, plot)
+  return { kind: 'computed', glslExpr, context }
+}

package/src/compute/axisFilter.js

@@ -0,0 +1,47 @@
+import { registerTextureComputation, TextureComputation, EXPRESSION_REF } from "./ComputationRegistry.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)
+//   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
+    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]
+      if (filterMin !== null && fv < filterMin) continue
+      if (filterMax !== null && fv > filterMax) continue
+      filtered.push(input[i])
+    }
+
+    return makeHistogram(regl, new Float32Array(filtered), { bins })
+  }
+  schema(data) {
+    return {
+      type: 'object',
+      properties: {
+        input: EXPRESSION_REF,
+        filterValues: EXPRESSION_REF,
+        filterAxisId: { type: 'string' },
+        bins: { type: 'number' }
+      },
+      required: ['input', 'filterValues', 'filterAxisId']
+    }
+  }
+}
+
+registerTextureComputation('filteredHistogram', new FilteredHistogramComputation())