Computed Attributes

createLayer(parameters, data) {
  const normalized = /* Float32Array of values in [0, 1] */
  const bins = 50

  return [{
    attributes: {
      x_center: /* Float32Array */,              // plain array — unchanged
      count: { histogram: { input: normalized, bins } },  // computed attribute
    },
    // ...
  }]
}

import { TextureComputation, registerTextureComputation } from 'gladly-plot'
import makeHistogram from './hist.js'

class FilteredHistogramComputation extends TextureComputation {
  compute(regl, params, getAxisDomain) {
    const { input, filterValues, filterAxisId, bins } = params
    const domain = getAxisDomain(filterAxisId)  // registers the axis as a dependency
    const filterMin = domain?.[0] ?? null
    const filterMax = domain?.[1] ?? null

    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) { /* ... */ }
}

registerTextureComputation('filteredHistogram', new FilteredHistogramComputation())

registerTextureComputation(name, computation)

import { TextureComputation, EXPRESSION_REF, registerTextureComputation } from 'gladly-plot'

class WeightedAverageComputation extends TextureComputation {
  compute(regl, params) {
    const { values, weights, bins } = params  // both Float32Arrays
    const outData = new Float32Array(bins * 4)  // RGBA, R channel used

    for (let b = 0; b < bins; b++) {
      let sumW = 0, sumWV = 0
      for (let i = 0; i < values.length; i++) {
        const bIndex = Math.floor(values[i] * bins)
        if (Math.min(bIndex, bins - 1) !== b) continue
        sumW  += weights[i]
        sumWV += weights[i] * values[i]
      }
      outData[b * 4] = sumW > 0 ? sumWV / sumW : 0  // R channel
    }

    return regl.texture({
      data: outData,
      width: bins,
      height: 1,
      type: 'float',
      format: 'rgba'
    })
  }

  schema(data) {
    return {
      type: 'object',
      properties: {
        values:  EXPRESSION_REF,
        weights: EXPRESSION_REF,
        bins:    { type: 'number' }
      },
      required: ['values', 'weights', 'bins']
    }
  }
}

registerTextureComputation('weightedAverage', new WeightedAverageComputation())

attributes: {
  count: { weightedAverage: { values: normalized, weights: importanceArr, bins } }
}

registerGlslComputation(name, computation)

import { GlslComputation, EXPRESSION_REF, registerGlslComputation } from 'gladly-plot'

class NormalizedDiffComputation extends GlslComputation {
  glsl({ a, b }) {
    return `((${a}) - (${b})) / ((${a}) + (${b}) + 1e-6)`
  }
  schema(data) {
    return {
      type: 'object',
      properties: {
        a: EXPRESSION_REF,
        b: EXPRESSION_REF
      },
      required: ['a', 'b']
    }
  }
}

registerGlslComputation('normalizedDiff', new NormalizedDiffComputation())

attributes: {
  ndvi: {
    normalizedDiff: {
      a: data.nir,   // Float32Array — resolved to an attribute GLSL name
      b: data.red,   // Float32Array — resolved to another attribute GLSL name
    }
  }
}

import { EXPRESSION_REF } from 'gladly-plot'

schema(data) {
  return {
    type: 'object',
    properties: {
      input: EXPRESSION_REF,   // accepts Float32Array or { computationName: params }
      bins:  { type: 'number' }
    },
    required: ['input']
  }
}

import { computationSchema } from 'gladly-plot'
const schema = computationSchema(data)

import { computationSchema } from 'gladly-plot'

const schema = computationSchema(myData)
// Pass schema to a JSON Schema form library or validator

import { isTexture } from 'gladly-plot'
isTexture(value)  // => boolean

class MyComputation extends TextureComputation {
  compute(regl, params) {
    const input = isTexture(params.input)
      ? params.input                      // use the texture directly
      : uploadToTexture(regl, params.input) // upload the Float32Array
    // ...
  }
}

{ histogram: { input: Float32Array, bins?: number } }

{
  filteredHistogram: {
    input:        Float32Array,  // values normalized to [0, 1]
    filterValues: Float32Array,  // raw filter-column values (same length as input)
    filterAxisId: string,        // quantity kind / axis ID to watch
    bins?:        number,
  }
}

{ kde: { input: Float32Array | Texture, bins?: number, bandwidth?: number } }

{ filter1D: { input: Float32Array | Texture, kernel: Float32Array } }

{ lowPass: { input: Float32Array | Texture, sigma?: number, kernelSize?: number } }

{ highPass: { input: Float32Array | Texture, sigma?: number, kernelSize?: number } }

{ bandPass: { input: Float32Array | Texture, sigmaLow: number, sigmaHigh: number } }

{ fft1d: { input: Float32Array, inverse?: boolean } }

import { GlslComputation, EXPRESSION_REF, registerGlslComputation } from 'gladly-plot'

class MagnitudeComputation extends GlslComputation {
  glsl({ re, im }) {
    return `sqrt((${re})*(${re}) + (${im})*(${im}))`
  }
  schema(data) {
    return {
      type: 'object',
      properties: { re: EXPRESSION_REF, im: EXPRESSION_REF },
      required: ['re', 'im']
    }
  }
}
registerGlslComputation('magnitude', new MagnitudeComputation())

// In createLayer:
attributes: {
  amplitude: {
    magnitude: {
      re: { fft1d: { input: signal } },           // R channel → 'attribute float a_cgen_...'
      im: /* need separate texture for G channel */ // not directly supported — see note below
    }
  }
}

{ fftConvolution: { signal: Float32Array, kernel: Float32Array } }

{ convolution: { signal: Float32Array, kernel: Float32Array } }

// Normalize source data to [0, 1] for histogram bins
const normalized = new Float32Array(srcV.length)
for (let i = 0; i < srcV.length; i++) {
  normalized[i] = (srcV[i] - min) / range
}

// Build count attribute:
// - No filter: plain histogram texture
// - With filter: filteredHistogram, recomputes when filter axis domain changes
const countAttr = filterQK
  ? { filteredHistogram: { input: normalized, filterValues: srcF, filterAxisId: filterQK, bins } }
  : { histogram: { input: normalized, bins } }

return [{
  attributes: {
    a_corner,          // per-vertex Float32Array (quad corners 0–3)
    x_center,          // per-instance Float32Array (bin centre positions)
    count: countAttr,  // computed attribute — histogram or filtered histogram
  },
  attributeDivisors: { x_center: 1 },
  vertexCount:  4,
  instanceCount: bins,
  primitive: "triangle strip",
  // ...
}]