gladly-plot 0.0.5 → 0.0.7

package/src/layers/ScatterShared.js

@@ -1,142 +1,98 @@
 import { LayerType } from "../core/LayerType.js"
-import { AXES } from "../axes/AxisRegistry.js"
-import { Data } from "../core/Data.js"
+import { AXIS_GEOMETRY } from "../axes/AxisRegistry.js"
+import { Data } from "../data/Data.js"
+import { computationSchema, EXPRESSION_REF, EXPRESSION_REF_OPT, resolveQuantityKind } from "../compute/ComputationRegistry.js"
+
+const X_AXES = Object.keys(AXIS_GEOMETRY).filter(a => AXIS_GEOMETRY[a].dir === 'x')
+const Y_AXES = Object.keys(AXIS_GEOMETRY).filter(a => AXIS_GEOMETRY[a].dir === 'y')
+const Z_AXES = Object.keys(AXIS_GEOMETRY).filter(a => AXIS_GEOMETRY[a].dir === 'z')
 
 export class ScatterLayerTypeBase extends LayerType {
   _getAxisConfig(parameters, data) {
     const d = Data.wrap(data)
-    const { xData, yData, vData, vData2, fData, xAxis, yAxis } = parameters
-    const colorAxisQuantityKinds = [d.getQuantityKind(vData) ?? vData]
-    if (vData2) {
-      colorAxisQuantityKinds.push(d.getQuantityKind(vData2) ?? vData2)
-    }
-    const filterAxisQuantityKinds = fData ? [d.getQuantityKind(fData) ?? fData] : []
+    const {
+      xData, yData, zData: zDataRaw,
+      vData: vDataRaw, vData2: vData2Raw, fData: fDataRaw,
+      xAxis = "xaxis_bottom", yAxis = "yaxis_left", zAxis = "none",
+    } = parameters
+    const vDataIn  = (vDataRaw  == null || vDataRaw  === "none") ? null : vDataRaw
+    const vData2In = (vData2Raw == null || vData2Raw === "none") ? null : vData2Raw
+    const fData    = (fDataRaw  == null || fDataRaw  === "none") ? null : fDataRaw
+    const zData    = (zDataRaw  == null || zDataRaw  === "none") ? null : zDataRaw
+    const zAxisResolved = (zAxis == null || zAxis === "none") ? null : zAxis
+    const vData  = vDataIn
+    const vData2 = vData2In
+    const colorAxisQuantityKinds = {}
+    const vQK  = vData  ? resolveQuantityKind(vData,  d) : null
+    const vQK2 = vData2 ? resolveQuantityKind(vData2, d) : null
+    if (vQK)  colorAxisQuantityKinds['']  = vQK
+    if (vQK2) colorAxisQuantityKinds['2'] = vQK2
+    const colorAxis2dQuantityKinds = vData && vData2 ? { '': ['', '2'] } : {}
+    const filterAxisQuantityKinds  = fData ? { '': resolveQuantityKind(fData, d) } : {}
     return {
       xAxis,
-      xAxisQuantityKind: d.getQuantityKind(xData) ?? xData,
+      xAxisQuantityKind: resolveQuantityKind(xData, d) ?? undefined,
       yAxis,
-      yAxisQuantityKind: d.getQuantityKind(yData) ?? yData,
+      yAxisQuantityKind: resolveQuantityKind(yData, d) ?? undefined,
+      zAxis: zData ? (zAxisResolved ?? "zaxis_bottom_left") : null,
+      zAxisQuantityKind: zData ? (resolveQuantityKind(zData, d) ?? undefined) : undefined,
       colorAxisQuantityKinds,
+      colorAxis2dQuantityKinds,
       filterAxisQuantityKinds,
     }
   }
 
-  _commonSchemaProperties(dataProperties) {
+  _commonSchemaProperties(data) {
     return {
-      xData: {
-        type: "string",
-        enum: dataProperties,
-        description: "Property name in data object for x coordinates"
-      },
-      yData: {
-        type: "string",
-        enum: dataProperties,
-        description: "Property name in data object for y coordinates"
-      },
-      vData: {
-        type: "string",
-        enum: ["none"].concat(dataProperties),
-        description: "Primary property name in data object for color values"
-      },
-      vData2: {
-        type: "string",
-        enum: ["none"].concat(dataProperties),
-        description: "Optional secondary property name for 2D color mapping"
-      },
-      fData: {
-        type: "string",
-        enum: ["none"].concat(dataProperties),
-        description: "Optional property name for filter axis values"
-      },
+      xData: EXPRESSION_REF,
+      yData: EXPRESSION_REF,
+      zData: EXPRESSION_REF_OPT,
+      vData: EXPRESSION_REF_OPT,
+      vData2: EXPRESSION_REF_OPT,
+      fData: EXPRESSION_REF_OPT,
       xAxis: {
         type: "string",
-        enum: AXES.filter(a => a.includes("x")),
+        enum: X_AXES,
         default: "xaxis_bottom",
-        description: "Which x-axis to use for this layer"
+        description: "Which x-axis to use for this layer",
       },
       yAxis: {
         type: "string",
-        enum: AXES.filter(a => a.includes("y")),
+        enum: Y_AXES,
         default: "yaxis_left",
-        description: "Which y-axis to use for this layer"
+        description: "Which y-axis to use for this layer",
       },
-      alphaBlend: {
-        type: "boolean",
-        default: false,
-        description: "Map the normalized color value to alpha so low values fade to transparent"
+      zAxis: {
+        type: "string",
+        enum: ["none", ...Z_AXES],
+        default: "none",
+        description: "Which z-axis to use for this layer (enables 3D mode)",
       },
     }
   }
 
-  _resolveColorData(parameters, d) {
-    const { xData, yData, vData: vDataOrig, vData2: vData2Orig, fData: fDataOrig, alphaBlend = false } = parameters
-    const vData = vDataOrig == "none" ? null : vDataOrig
-    const vData2 = vData2Orig == "none" ? null : vData2Orig
-    const fData = fDataOrig == "none" ? null : fDataOrig
-
-    const xQK = d.getQuantityKind(xData) ?? xData
-    const yQK = d.getQuantityKind(yData) ?? yData
-    const vQK = vData ? (d.getQuantityKind(vData) ?? vData) : null
-    const vQK2 = vData2 ? (d.getQuantityKind(vData2) ?? vData2) : null
-    const fQK = fData ? (d.getQuantityKind(fData) ?? fData) : null
-
-    const srcX = d.getData(xData)
-    const srcY = d.getData(yData)
-    const srcV = vData ? d.getData(vData) : null
-    const srcV2 = vData2 ? d.getData(vData2) : null
-    const srcF = fData ? d.getData(fData) : null
-
-    if (!srcX) throw new Error(`Data column '${xData}' not found`)
-    if (!srcY) throw new Error(`Data column '${yData}' not found`)
-    if (vData && !srcV) throw new Error(`Data column '${vData}' not found`)
-    if (vData2 && !srcV2) throw new Error(`Data column '${vData2}' not found`)
-    if (fData && !srcF) throw new Error(`Data column '${fData}' not found`)
-
-    return { xData, yData, vData, vData2, fData, alphaBlend, xQK, yQK, vQK, vQK2, fQK, srcX, srcY, srcV, srcV2, srcF }
-  }
-
-  _buildDomains(d, xData, yData, vData, vData2, xQK, yQK, vQK, vQK2) {
+  _buildDomains(d, xData, yData, zData, vData, vData2, xQK, yQK, zQK, vQK, vQK2) {
     const domains = {}
-
-    const xDomain = d.getDomain(xData)
-    if (xDomain) domains[xQK] = xDomain
-
-    const yDomain = d.getDomain(yData)
-    if (yDomain) domains[yQK] = yDomain
-
-    if (vData) {
+    if (xQK && typeof xData === 'string') {
+      const xDomain = d.getDomain(xData)
+      if (xDomain) domains[xQK] = xDomain
+    }
+    if (yQK && typeof yData === 'string') {
+      const yDomain = d.getDomain(yData)
+      if (yDomain) domains[yQK] = yDomain
+    }
+    if (zData && zQK && typeof zData === 'string') {
+      const zDomain = d.getDomain(zData)
+      if (zDomain) domains[zQK] = zDomain
+    }
+    if (vData && vQK && typeof vData === 'string') {
       const vDomain = d.getDomain(vData)
       if (vDomain) domains[vQK] = vDomain
     }
-
-    if (vData2) {
+    if (vData2 && vQK2 && typeof vData2 === 'string') {
       const vDomain2 = d.getDomain(vData2)
       if (vDomain2) domains[vQK2] = vDomain2
     }
-
     return domains
   }
-
-  _buildNameMap(vData, vQK, vData2, vQK2, fData, fQK) {
-    return {
-      ...(vData ? {
-        [`colorscale_${vQK}`]: 'colorscale',
-        [`color_range_${vQK}`]: 'color_range',
-        [`color_scale_type_${vQK}`]: 'color_scale_type',
-      } : {}),
-      ...(vData2 ? {
-        [`colorscale_${vQK2}`]: 'colorscale2',
-        [`color_range_${vQK2}`]: 'color_range2',
-        [`color_scale_type_${vQK2}`]: 'color_scale_type2',
-      } : {}),
-      ...(fData ? { [`filter_range_${fQK}`]: 'filter_range' } : {}),
-    }
-  }
-
-  _buildBlendConfig(alphaBlend) {
-    return alphaBlend ? {
-      enable: true,
-      func: { srcRGB: 'src alpha', dstRGB: 'one minus src alpha', srcAlpha: 0, dstAlpha: 1 },
-    } : null
-  }
 }

package/src/layers/TileLayer.js

@@ -410,15 +410,15 @@ class TileManager {
 
 // ─── GLSL ─────────────────────────────────────────────────────────────────────
 
-const TILE_VERT = `
+const TILE_VERT = `#version 300 es
   precision mediump float;
-  attribute vec2 position;
-  attribute vec2 uv;
+  in vec2 position;
+  in vec2 uv;
   uniform vec2 xDomain;
   uniform vec2 yDomain;
   uniform float xScaleType;
   uniform float yScaleType;
-  varying vec2 vUv;
+  out vec2 vUv;
 
   float normalize_axis(float v, vec2 domain, float scaleType) {
     float vt = scaleType > 0.5 ? log(v) : v;
@@ -426,24 +426,28 @@ const TILE_VERT = `
     float d1 = scaleType > 0.5 ? log(domain.y) : domain.y;
     return (vt - d0) / (d1 - d0);
   }
+  vec4 plot_pos(vec2 pos) {
+    float nx = normalize_axis(pos.x, xDomain, xScaleType);
+    float ny = normalize_axis(pos.y, yDomain, yScaleType);
+    return vec4(nx * 2.0 - 1.0, ny * 2.0 - 1.0, 0.0, 1.0);
+  }
 
   void main() {
-    float nx = normalize_axis(position.x, xDomain, xScaleType);
-    float ny = normalize_axis(position.y, yDomain, yScaleType);
-    gl_Position = vec4(nx * 2.0 - 1.0, ny * 2.0 - 1.0, 0.0, 1.0);
+    gl_Position = plot_pos(position);
     vUv = uv;
   }
 `
 
-const TILE_FRAG = `
+const TILE_FRAG = `#version 300 es
   precision mediump float;
   uniform sampler2D tileTexture;
   uniform float opacity;
-  varying vec2 vUv;
+  in vec2 vUv;
+  out vec4 fragColor;
 
   void main() {
-    vec4 color = texture2D(tileTexture, vUv);
-    gl_FragColor = vec4(color.rgb, color.a * opacity);
+    vec4 color = texture(tileTexture, vUv);
+    fragColor = vec4(color.rgb, color.a * opacity);
   }
 `
 
@@ -587,12 +591,12 @@ class TileLayerType extends LayerType {
       xAxisQuantityKind: crsToQkX(effectivePlotCrs),
       yAxis,
       yAxisQuantityKind: crsToQkY(effectivePlotCrs),
-      colorAxisQuantityKinds: [],
-      filterAxisQuantityKinds: [],
+      colorAxisQuantityKinds: {},
+      filterAxisQuantityKinds: {},
     }
   }
 
-  createLayer(parameters, _data) {
+  createLayer(regl, parameters, _data) {
     const {
       xAxis = 'xaxis_bottom',
       yAxis = 'yaxis_left',
@@ -609,8 +613,8 @@ class TileLayerType extends LayerType {
       yAxis,
       xAxisQuantityKind: crsToQkX(effectivePlotCrs),
       yAxisQuantityKind: crsToQkY(effectivePlotCrs),
-      colorAxes: [],
-      filterAxes: [],
+      colorAxes: {},
+      filterAxes: {},
       vertexCount: 0,
       instanceCount: null,
       attributes: {},

package/src/math/mat4.js

@@ -0,0 +1,100 @@
+// Column-major 4×4 matrix utilities matching WebGL/GLSL convention.
+// Element at row r, column c is stored at index c*4+r.
+
+export function mat4Identity() {
+  return new Float32Array([
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1,
+  ])
+}
+
+// a * b (left-multiplies a by b).
+export function mat4Multiply(a, b) {
+  const out = new Float32Array(16)
+  for (let col = 0; col < 4; col++) {
+    for (let row = 0; row < 4; row++) {
+      let s = 0
+      for (let k = 0; k < 4; k++) s += a[k * 4 + row] * b[col * 4 + k]
+      out[col * 4 + row] = s
+    }
+  }
+  return out
+}
+
+// Perspective projection. fovY in radians, aspect = width/height.
+export function mat4Perspective(fovY, aspect, near, far) {
+  const f = 1 / Math.tan(fovY / 2)
+  const nf = 1 / (near - far)
+  return new Float32Array([
+    f / aspect, 0,  0,                    0,
+    0,          f,  0,                    0,
+    0,          0,  (far + near) * nf,   -1,
+    0,          0,  2 * far * near * nf,  0,
+  ])
+}
+
+// View matrix looking from eye toward center with the given up vector.
+export function mat4LookAt(eye, center, up) {
+  const f = vec3Normalize([center[0] - eye[0], center[1] - eye[1], center[2] - eye[2]])
+  const r = vec3Normalize(vec3Cross(f, up))
+  const u = vec3Cross(r, f)
+  return new Float32Array([
+     r[0],  u[0], -f[0], 0,
+     r[1],  u[1], -f[1], 0,
+     r[2],  u[2], -f[2], 0,
+    -vec3Dot(r, eye), -vec3Dot(u, eye), vec3Dot(f, eye), 1,
+  ])
+}
+
+// Multiply a 4×4 column-major matrix by a vec4.
+export function mat4MulVec4(m, v) {
+  return [
+    m[0]*v[0] + m[4]*v[1] + m[8] *v[2] + m[12]*v[3],
+    m[1]*v[0] + m[5]*v[1] + m[9] *v[2] + m[13]*v[3],
+    m[2]*v[0] + m[6]*v[1] + m[10]*v[2] + m[14]*v[3],
+    m[3]*v[0] + m[7]*v[1] + m[11]*v[2] + m[15]*v[3],
+  ]
+}
+
+export function vec3Normalize(v) {
+  const len = Math.sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2])
+  return len > 1e-10 ? [v[0]/len, v[1]/len, v[2]/len] : [0, 0, 0]
+}
+
+export function vec3Cross(a, b) {
+  return [
+    a[1]*b[2] - a[2]*b[1],
+    a[2]*b[0] - a[0]*b[2],
+    a[0]*b[1] - a[1]*b[0],
+  ]
+}
+
+export function vec3Dot(a, b) {
+  return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
+}
+
+// Convert spherical coords (azimuth theta around y-axis, elevation phi from equator)
+// to Cartesian.
+export function sphericalToCartesian(theta, phi, r) {
+  return [
+    r * Math.cos(phi) * Math.sin(theta),
+    r * Math.sin(phi),
+    r * Math.cos(phi) * Math.cos(theta),
+  ]
+}
+
+// Project a 3D model-space point to HTML screen coordinates (y from top) using an MVP
+// matrix that maps model space to full-canvas NDC, and the canvas dimensions.
+// Returns [htmlX, htmlY] or null if the point is behind the camera (w ≤ 0).
+export function projectToScreen(point, mvp, canvasWidth, canvasHeight) {
+  const clip = mat4MulVec4(mvp, [point[0], point[1], point[2], 1.0])
+  if (clip[3] <= 0) return null
+  const ndcX = clip[0] / clip[3]
+  const ndcY = clip[1] / clip[3]
+  return [
+    (ndcX + 1) * 0.5 * canvasWidth,
+    (1 - (ndcY + 1) * 0.5) * canvasHeight,
+  ]
+}

package/src/core/Data.js

@@ -1,67 +0,0 @@
-export class Data {
-  constructor(raw) {
-    raw = raw ?? {}
-    // Columnar format: { data: {col: Float32Array}, quantity_kinds?: {...}, domains?: {...} }
-    // Detected by the presence of a top-level `data` property that is a plain object.
-    if (raw.data != null && typeof raw.data === 'object' && !(raw.data instanceof Float32Array)) {
-      this._columnar = true
-      this._data = raw.data
-      this._quantityKinds = raw.quantity_kinds ?? {}
-      this._rawDomains = raw.domains ?? {}
-    } else {
-      this._columnar = false
-      this._raw = raw
-    }
-  }
-
-  static wrap(data) {
-    if (data != null && typeof data.columns === 'function' && typeof data.getData === 'function') {
-      return data
-    }
-    return new Data(data)
-  }
-
-  _entry(col) {
-    if (this._columnar) {
-      const rawDomain = this._rawDomains[col]
-      let domain
-      if (Array.isArray(rawDomain)) {
-        domain = [rawDomain[0], rawDomain[1]]
-      } else if (rawDomain && typeof rawDomain === 'object') {
-        domain = [rawDomain.min, rawDomain.max]
-      }
-      return { data: this._data[col], quantityKind: this._quantityKinds[col], domain }
-    }
-
-    const v = this._raw[col]
-    if (v instanceof Float32Array) {
-      return { data: v, quantityKind: undefined, domain: undefined }
-    }
-    if (v && typeof v === 'object') {
-      let domain
-      if (Array.isArray(v.domain)) {
-        domain = [v.domain[0], v.domain[1]]
-      } else if (v.domain && typeof v.domain === 'object') {
-        domain = [v.domain.min, v.domain.max]
-      }
-      return { data: v.data, quantityKind: v.quantity_kind, domain }
-    }
-    return { data: undefined, quantityKind: undefined, domain: undefined }
-  }
-
-  columns() {
-    return this._columnar ? Object.keys(this._data) : Object.keys(this._raw)
-  }
-
-  getData(col) {
-    return this._entry(col).data
-  }
-
-  getQuantityKind(col) {
-    return this._entry(col).quantityKind
-  }
-
-  getDomain(col) {
-    return this._entry(col).domain
-  }
-}

package/src/layers/HistogramLayer.js

@@ -1,212 +0,0 @@
-import { LayerType } from "../core/LayerType.js"
-import { Data } from "../core/Data.js"
-import { registerLayerType } from "../core/LayerTypeRegistry.js"
-import { AXES } from "../axes/AxisRegistry.js"
-
-// Ensure the 'histogram' and 'filteredHistogram' texture computations are registered.
-import "../compute/hist.js"
-import "../compute/axisFilter.js"
-
-// Each bar is a quad drawn as a triangle strip (4 vertices).
-// Per-instance: x_center (bin centre in data space), a_pickId (bin index).
-// Per-vertex:   a_corner ∈ {0,1,2,3} — selects which corner of the rectangle.
-//   corner 0: bottom-left   corner 1: bottom-right
-//   corner 2: top-left      corner 3: top-right
-// The `count` attribute is resolved via the 'histogram' texture computation so
-// its value equals the bin count sampled at a_pickId.
-
-const HIST_VERT = `
-  precision mediump float;
-
-  attribute float a_corner;
-  attribute float x_center;
-  attribute float count;
-
-  uniform vec2  xDomain;
-  uniform vec2  yDomain;
-  uniform float xScaleType;
-  uniform float yScaleType;
-  uniform float u_binHalfWidth;
-
-  void main() {
-    float side   = mod(a_corner, 2.0);        // 0 = left, 1 = right
-    float top    = floor(a_corner / 2.0);     // 0 = bottom, 1 = top
-
-    float bx = x_center + (side * 2.0 - 1.0) * u_binHalfWidth;
-    float by = top * count;
-
-    float nx = normalize_axis(bx, xDomain, xScaleType);
-    float ny = normalize_axis(by, yDomain, yScaleType);
-    gl_Position = vec4(nx * 2.0 - 1.0, ny * 2.0 - 1.0, 0.0, 1.0);
-  }
-`
-
-const HIST_FRAG = `
-  precision mediump float;
-  uniform vec4 u_color;
-  void main() {
-    gl_FragColor = gladly_apply_color(u_color);
-  }
-`
-
-class HistogramLayerType extends LayerType {
-  constructor() {
-    super({ name: "histogram", vert: HIST_VERT, frag: HIST_FRAG })
-  }
-
-  _getAxisConfig(parameters, data) {
-    const d = Data.wrap(data)
-    const { vData, xAxis = "xaxis_bottom", yAxis = "yaxis_left", filterColumn } = parameters
-    const activeFilter = filterColumn && filterColumn !== "none" ? filterColumn : null
-    const filterQK = activeFilter ? (d.getQuantityKind(activeFilter) ?? activeFilter) : null
-    return {
-      xAxis,
-      xAxisQuantityKind: d.getQuantityKind(vData) ?? vData,
-      yAxis,
-      yAxisQuantityKind: "count",
-      ...(filterQK ? { filterAxisQuantityKinds: [filterQK] } : {}),
-    }
-  }
-
-  schema(data) {
-    const dataProperties = Data.wrap(data).columns()
-    return {
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      type: "object",
-      properties: {
-        vData: {
-          type: "string",
-          enum: dataProperties,
-          description: "Data column to histogram"
-        },
-        filterColumn: {
-          type: "string",
-          enum: ["none", ...dataProperties],
-          description: "Data column used to filter points via its filter axis, or 'none'"
-        },
-        bins: {
-          type: "integer",
-          description: "Number of bins (auto-selected by sqrt rule if omitted)"
-        },
-        color: {
-          type: "array",
-          items: { type: "number" },
-          minItems: 4,
-          maxItems: 4,
-          default: [0.2, 0.5, 0.8, 1.0],
-          description: "Bar colour as [R, G, B, A] in [0, 1]"
-        },
-        xAxis: {
-          type: "string",
-          enum: AXES.filter(a => a.includes("x")),
-          default: "xaxis_bottom"
-        },
-        yAxis: {
-          type: "string",
-          enum: AXES.filter(a => a.includes("y")),
-          default: "yaxis_left"
-        }
-      },
-      required: ["vData", "filterColumn"]
-    }
-  }
-
-  _createLayer(parameters, data) {
-    const d = Data.wrap(data)
-    const {
-      vData,
-      bins: requestedBins = null,
-      color = [0.2, 0.5, 0.8, 1.0],
-      filterColumn = "none",
-    } = parameters
-
-    const srcV = d.getData(vData)
-    if (!srcV) throw new Error(`Data column '${vData}' not found`)
-    const vQK = d.getQuantityKind(vData) ?? vData
-
-    // --- Optional filter column ---
-    const activeFilter = filterColumn && filterColumn !== "none" ? filterColumn : null
-    const filterQK = activeFilter ? (d.getQuantityKind(activeFilter) ?? activeFilter) : null
-    const srcF = activeFilter ? d.getData(activeFilter) : null
-    if (activeFilter && !srcF) throw new Error(`Data column '${activeFilter}' not found`)
-
-    // --- Compute min/max for normalization ---
-    let min = Infinity, max = -Infinity
-    for (let i = 0; i < srcV.length; i++) {
-      if (srcV[i] < min) min = srcV[i]
-      if (srcV[i] > max) max = srcV[i]
-    }
-    const range = max - min || 1
-
-    // --- Choose bin count ---
-    const bins = requestedBins || Math.max(10, Math.min(200, Math.ceil(Math.sqrt(srcV.length))))
-    const binWidth = range / bins
-
-    // --- Normalize data to [0, 1] for the histogram computation ---
-    const normalized = new Float32Array(srcV.length)
-    for (let i = 0; i < srcV.length; i++) {
-      normalized[i] = (srcV[i] - min) / range
-    }
-
-    // --- CPU histogram for domain (y-axis range) estimation ---
-    // Uses unfiltered data so the y-axis scale stays stable while the filter moves.
-    const histCpu = new Float32Array(bins)
-    for (let i = 0; i < srcV.length; i++) {
-      const b = Math.min(Math.floor(normalized[i] * bins), bins - 1)
-      histCpu[b] += 1
-    }
-    const maxCount = Math.max(...histCpu)
-
-    // --- Per-instance: bin centre positions in data space ---
-    const x_center = new Float32Array(bins)
-    for (let i = 0; i < bins; i++) {
-      x_center[i] = min + (i + 0.5) * binWidth
-    }
-
-    // --- Per-vertex: corner indices 0–3 (triangle-strip quad) ---
-    const a_corner = new Float32Array([0, 1, 2, 3])
-
-    // --- Build count attribute expression ---
-    // When a filter column is provided, use filteredHistogram so the computation
-    // re-runs whenever the filter axis domain changes.
-    const countAttr = filterQK
-      ? { filteredHistogram: { input: normalized, filterValues: srcF, filterAxisId: filterQK, bins } }
-      : { histogram: { input: normalized, bins } }
-
-    // --- Compute filter column extent for the filterbar display range ---
-    const filterDomains = {}
-    if (filterQK && srcF) {
-      let fMin = Infinity, fMax = -Infinity
-      for (let i = 0; i < srcF.length; i++) {
-        if (srcF[i] < fMin) fMin = srcF[i]
-        if (srcF[i] > fMax) fMax = srcF[i]
-      }
-      filterDomains[filterQK] = [fMin, fMax]
-    }
-
-    return [{
-      attributes: {
-        a_corner,          // per-vertex (no divisor)
-        x_center,          // per-instance (divisor 1)
-        // GPU histogram via computed attribute; sampled at a_pickId (= bin index)
-        count: countAttr,
-      },
-      attributeDivisors: { x_center: 1 },
-      uniforms: {
-        u_binHalfWidth: binWidth / 2,
-        u_color: color,
-      },
-      vertexCount: 4,
-      instanceCount: bins,
-      primitive: "triangle strip",
-      domains: {
-        [vQK]: [min, max],
-        count:  [0, maxCount],
-        ...filterDomains,
-      },
-    }]
-  }
-}
-
-export const histogramLayerType = new HistogramLayerType()
-registerLayerType("histogram", histogramLayerType)