@uwdata/vgplot 0.4.0 → 0.5.0

package/src/marks/RegressionMark.js

@@ -1,117 +0,0 @@
-import { range } from 'd3';
-import {
-  Query, max, min, castDouble, isNotNull,
-  regrIntercept, regrSlope, regrCount,
-  regrSYY, regrSXX, regrAvgX
-} from '@uwdata/mosaic-sql';
-import { qt } from './util/stats.js';
-import { Mark, channelOption } from './Mark.js';
-import { handleParam } from './util/handle-param.js';
-import { toDataArray } from './util/to-data-array.js';
-
-export class RegressionMark extends Mark {
-  constructor(source, options) {
-    const { ci = 0.95, precision = 4, ...channels } = options;
-    super('line', source, channels);
-    const update = () => {
-      return this.modelFit ? this.confidenceBand().update() : null
-    };
-    handleParam(this, 'ci', ci, update);
-    handleParam(this, 'precision', precision, update);
-  }
-
-  query(filter = []) {
-    const x = this.channelField('x').as;
-    const y = this.channelField('y').as;
-    const groupby = Array.from(new Set(
-      ['stroke', 'z', 'fx', 'fy'].flatMap(c => this.channelField(c)?.as || [])
-    ));
-
-    return Query
-      .from(super.query(filter))
-      .select({
-        intercept: regrIntercept(y, x),
-        slope: regrSlope(y, x),
-        n: regrCount(y, x),
-        ssy: regrSYY(y, x),
-        ssx: regrSXX(y, x),
-        xm: regrAvgX(y, x),
-        x0: castDouble(min(x).where(isNotNull(y))),
-        x1: castDouble(max(x).where(isNotNull(y)))
-      })
-      .select(groupby)
-      .groupby(groupby);
-  }
-
-  queryResult(data) {
-    this.modelFit = toDataArray(data);
-
-    // regression line
-    this.lineData = this.modelFit.flatMap(m => linePoints(m));
-
-    // prepare confidence band
-    return this.confidenceBand();
-  }
-
-  confidenceBand() {
-    // regression ci area
-    const { ci, modelFit, precision, plot } = this;
-    const w = plot.innerWidth();
-    this.areaData = ci ? modelFit.flatMap(m => areaPoints(ci, precision, m, w)) : null;
-    return this;
-  }
-
-  plotSpecs() {
-    const { lineData, areaData, channels, ci } = this;
-    const lopt = { x: 'x', y: 'y' };
-    const aopt = { x: 'x', y1: 'y1', y2: 'y2', fillOpacity: 0.1 };
-
-    for (const c of channels) {
-      switch (c.channel) {
-        case 'x':
-        case 'y':
-        case 'fill':
-          break;
-        case 'stroke':
-          lopt.stroke = aopt.fill = channelOption(c);
-          break;
-        case 'strokeOpacity':
-          lopt.strokeOpacity = channelOption(c);
-          break;
-        case 'fillOpacity':
-          aopt.fillOpacity = channelOption(c);
-          break;
-        default:
-          lopt[c.channel] = aopt[c.channel] = channelOption(c);
-          break;
-      }
-    }
-
-    return [
-      ...(ci ? [{ type: 'areaY', data: areaData, options: aopt }] : []),
-      { type: 'line', data: lineData, options: lopt }
-    ];
-  }
-}
-
-function linePoints(model) {
-  // eslint-disable-next-line no-unused-vars
-  const { x0, x1, xm, intercept, slope, n, ssx, ssy, ...rest } = model;
-  return [
-    { x: x0, y: intercept + x0 * slope, ...rest },
-    { x: x1, y: intercept + x1 * slope, ...rest }
-  ];
-}
-
-function areaPoints(ci, precision, model, width) {
-  const { x0, x1, xm, intercept, slope, n, ssx, ssy, ...rest } = model;
-  const pp = precision * (x1 - x0) / width;
-  const t_sy = qt((1 - ci) / 2, n - 2) * Math.sqrt(ssy / (n - 2));
-  return range(x0, x1 - pp / 2, pp)
-    .concat(x1)
-    .map(x => {
-      const y = intercept + x * slope;
-      const ye = t_sy * Math.sqrt(1 / n + (x - xm) ** 2 / ssx);
-      return { x, y1: y - ye, y2: y + ye, ...rest };
-    });
-}

package/src/marks/util/bin-field.js

@@ -1,17 +0,0 @@
-import { epoch_ms, sql } from '@uwdata/mosaic-sql';
-
-export function binField(mark, channel, expr) {
-  if (!mark.stats) return field;
-  const { field } = mark.channelField(channel);
-  const { type } = mark.stats[field.column];
-  expr = expr ?? field;
-  return type === 'date' ? epoch_ms(expr) : expr;
-}
-
-export function bin1d(x, x0, x1, n, reverse = false, pad = 1) {
-  const d = (n - pad) / (x1 - x0);
-  const f = d !== 1 ? ` * ${d}::DOUBLE` : '';
-  return reverse
-    ? sql`(${+x1} - ${x}::DOUBLE)${f}`
-    : sql`(${x}::DOUBLE - ${+x0})${f}`;
-}

package/src/marks/util/density.js

@@ -1,226 +0,0 @@
-// Deriche's approximation of Gaussian smoothing
-// Adapted from Getreuer's C implementation (BSD license)
-// https://www.ipol.im/pub/art/2013/87/gaussian_20131215.tgz
-// http://dev.ipol.im/~getreuer/code/doc/gaussian_20131215_doc/gaussian__conv__deriche_8c.html
-
-export function dericheConfig(sigma, negative = false) {
-  // compute causal filter coefficients
-  const a = new Float64Array(5);
-  const bc = new Float64Array(4);
-  dericheCausalCoeff(a, bc, sigma);
-
-  // numerator coefficients of the anticausal filter
-  const ba = Float64Array.of(
-    0,
-    bc[1] - a[1] * bc[0],
-    bc[2] - a[2] * bc[0],
-    bc[3] - a[3] * bc[0],
-    -a[4] * bc[0]
-  );
-
-  // impulse response sums
-  const accum_denom = 1.0 + a[1] + a[2] + a[3] + a[4];
-  const sum_causal = (bc[0] + bc[1] + bc[2] + bc[3]) / accum_denom;
-  const sum_anticausal = (ba[1] + ba[2] + ba[3] + ba[4]) / accum_denom;
-
-  // coefficients object
-  return {
-    sigma,
-    negative,
-    a,
-    b_causal: bc,
-    b_anticausal: ba,
-    sum_causal,
-    sum_anticausal
-  };
-}
-
-function dericheCausalCoeff(a_out, b_out, sigma) {
-  const K = 4;
-
-  const alpha = Float64Array.of(
-    0.84, 1.8675,
-    0.84, -1.8675,
-    -0.34015, -0.1299,
-    -0.34015, 0.1299
-  );
-
-  const x1 = Math.exp(-1.783 / sigma);
-  const x2 = Math.exp(-1.723 / sigma);
-  const y1 = 0.6318 / sigma;
-  const y2 = 1.997 / sigma;
-  const beta = Float64Array.of(
-    -x1 * Math.cos( y1), x1 * Math.sin( y1),
-    -x1 * Math.cos(-y1), x1 * Math.sin(-y1),
-    -x2 * Math.cos( y2), x2 * Math.sin( y2),
-    -x2 * Math.cos(-y2), x2 * Math.sin(-y2)
-  );
-
-  const denom = sigma * 2.5066282746310007;
-
-  // initialize b/a = alpha[0] / (1 + beta[0] z^-1)
-  const b = Float64Array.of(alpha[0], alpha[1], 0, 0, 0, 0, 0, 0);
-  const a = Float64Array.of(1, 0, beta[0], beta[1], 0, 0, 0, 0, 0, 0);
-
-  let j, k;
-
-  for (k = 2; k < 8; k += 2) {
-    // add kth term, b/a += alpha[k] / (1 + beta[k] z^-1)
-    b[k]     = beta[k] * b[k - 2] - beta[k + 1] * b[k - 1];
-    b[k + 1] = beta[k] * b[k - 1] + beta[k + 1] * b[k - 2];
-    for (j = k - 2; j > 0; j -= 2) {
-      b[j]     += beta[k] * b[j - 2] - beta[k + 1] * b[j - 1];
-      b[j + 1] += beta[k] * b[j - 1] + beta[k + 1] * b[j - 2];
-    }
-    for (j = 0; j <= k; j += 2) {
-      b[j]     += alpha[k] * a[j]     - alpha[k + 1] * a[j + 1];
-      b[j + 1] += alpha[k] * a[j + 1] + alpha[k + 1] * a[j];
-    }
-
-    a[k + 2] = beta[k] * a[k]     - beta[k + 1] * a[k + 1];
-    a[k + 3] = beta[k] * a[k + 1] + beta[k + 1] * a[k];
-    for (j = k; j > 0; j -= 2) {
-      a[j]     += beta[k] * a[j - 2] - beta[k + 1] * a[j - 1];
-      a[j + 1] += beta[k] * a[j - 1] + beta[k + 1] * a[j - 2];
-    }
-  }
-
-  for (k = 0; k < K; ++k) {
-    j = k << 1;
-    b_out[k] = b[j] / denom;
-    a_out[k + 1] = a[j + 2];
-  }
-}
-
-export function dericheConv2d(cx, cy, grid, [nx, ny]) {
-  // allocate buffers
-  const yc = new Float64Array(Math.max(nx, ny)); // causal
-  const ya = new Float64Array(Math.max(nx, ny)); // anticausal
-  const h = new Float64Array(5);
-  const d = new Float64Array(grid.length);
-
-  // convolve rows
-  for (let row = 0, r0 = 0; row < ny; ++row, r0 += nx) {
-    const dx = d.subarray(r0);
-    dericheConv1d(cx, grid.subarray(r0), nx, 1, yc, ya, h, dx);
-  }
-
-  // convolve columns
-  for (let c0 = 0; c0 < nx; ++c0) {
-    const dy = d.subarray(c0);
-    dericheConv1d(cy, dy, ny, nx, yc, ya, h, dy);
-  }
-
-  return d;
-}
-
-export function dericheConv1d(
-  c, src, N,
-  stride = 1,
-  y_causal = new Float64Array(N),
-  y_anticausal = new Float64Array(N),
-  h = new Float64Array(5),
-  d = y_causal,
-  init = dericheInitZeroPad
-) {
-  const stride_2 = stride * 2;
-  const stride_3 = stride * 3;
-  const stride_4 = stride * 4;
-  const stride_N = stride * N;
-  let i, n;
-
-  // initialize causal filter on the left boundary
-  init(
-    y_causal, src, N, stride,
-    c.b_causal, 3, c.a, 4, c.sum_causal, h, c.sigma
-  );
-
-  // filter the interior samples using a 4th order filter. Implements:
-  // for n = K, ..., N - 1,
-  //   y^+(n) = \sum_{k=0}^{K-1} b^+_k src(n - k)
-  //          - \sum_{k=1}^K a_k y^+(n - k)
-  // variable i tracks the offset to the nth sample of src, it is
-  // updated together with n such that i = stride * n.
-  for (n = 4, i = stride_4; n < N; ++n, i += stride) {
-    y_causal[n] = c.b_causal[0] * src[i]
-      + c.b_causal[1] * src[i - stride]
-      + c.b_causal[2] * src[i - stride_2]
-      + c.b_causal[3] * src[i - stride_3]
-      - c.a[1] * y_causal[n - 1]
-      - c.a[2] * y_causal[n - 2]
-      - c.a[3] * y_causal[n - 3]
-      - c.a[4] * y_causal[n - 4];
-  }
-
-  // initialize the anticausal filter on the right boundary
-  init(
-    y_anticausal, src, N, -stride,
-    c.b_anticausal, 4, c.a, 4, c.sum_anticausal, h, c.sigma
-  );
-
-  // similar to the causal filter above, the following implements:
-  // for n = K, ..., N - 1,
-  //   y^-(n) = \sum_{k=1}^K b^-_k src(N - n - 1 - k)
-  //          - \sum_{k=1}^K a_k y^-(n - k)
-  // variable i is updated such that i = stride * (N - n - 1).
-  for (n = 4, i = stride_N - stride * 5; n < N; ++n, i -= stride) {
-    y_anticausal[n] = c.b_anticausal[1] * src[i + stride]
-      + c.b_anticausal[2] * src[i + stride_2]
-      + c.b_anticausal[3] * src[i + stride_3]
-      + c.b_anticausal[4] * src[i + stride_4]
-      - c.a[1] * y_anticausal[n - 1]
-      - c.a[2] * y_anticausal[n - 2]
-      - c.a[3] * y_anticausal[n - 3]
-      - c.a[4] * y_anticausal[n - 4];
-  }
-
-  // sum the causal and anticausal responses to obtain the final result
-  if (c.negative) {
-    // do not threshold if the input grid includes negatively weighted values
-    for (n = 0, i = 0; n < N; ++n, i += stride) {
-      d[i] = y_causal[n] + y_anticausal[N - n - 1];
-    }
-  } else {
-    // threshold to prevent small negative values due to floating point error
-    for (n = 0, i = 0; n < N; ++n, i += stride) {
-      d[i] = Math.max(0, y_causal[n] + y_anticausal[N - n - 1]);
-    }
-  }
-
-  return d;
-}
-
-export function dericheInitZeroPad(dest, src, N, stride, b, p, a, q, sum, h) {
-  const stride_N = Math.abs(stride) * N;
-  const off = stride < 0 ? stride_N + stride : 0;
-  let i, n, m;
-
-  // compute the first q taps of the impulse response, h_0, ..., h_{q-1}
-  for (n = 0; n < q; ++n) {
-    h[n] = (n <= p) ? b[n] : 0;
-    for (m = 1; m <= q && m <= n; ++m) {
-      h[n] -= a[m] * h[n - m];
-    }
-  }
-
-  // compute dest_m = sum_{n=1}^m h_{m-n} src_n, m = 0, ..., q-1
-  // note: q == 4
-  for (m = 0; m < q; ++m) {
-    for (dest[m] = 0, n = 1; n <= m; ++n) {
-      i = off + stride * n;
-      if (i >= 0 && i < stride_N) {
-        dest[m] += h[m - n] * src[i];
-      }
-    }
-  }
-
-  // dest_m = dest_m + h_{n+m} src_{-n}
-  const cur = src[off];
-  if (cur > 0) {
-    for (m = 0; m < q; ++m) {
-      dest[m] += h[m] * cur;
-    }
-  }
-
-  return;
-}

package/src/marks/util/extent.js

@@ -1,56 +0,0 @@
-import { scaleLinear } from 'd3';
-import { Fixed, Transient } from '../../symbols.js';
-
-export const xext = { x: ['min', 'max'] };
-export const yext = { y: ['min', 'max'] };
-export const xyext = { ...xext, ...yext };
-
-export function plotExtent(mark, filter, channel, domainAttr, niceAttr) {
-  const { plot, stats } = mark;
-  const domain = plot.getAttribute(domainAttr);
-  const nice = plot.getAttribute(niceAttr);
-
-  if (Array.isArray(domain) && !domain[Transient]) {
-    return domain;
-  } else {
-    const { field } = mark.channelField(channel);
-    const { column } = field;
-    const { min, max } = stats[column];
-    const dom = filteredExtent(filter, column) || (nice
-      ? scaleLinear().domain([min, max]).nice().domain()
-      : [min, max]);
-    if (domain !== Fixed) dom[Transient] = true;
-    plot.setAttribute(domainAttr, dom, { silent: true });
-    return dom;
-  }
-}
-
-export function extentX(mark, filter) {
-  return plotExtent(mark, filter, 'x', 'xDomain', 'xNice');
-}
-
-export function extentY(mark, filter) {
-  return plotExtent(mark, filter, 'y', 'yDomain', 'yNice');
-}
-
-export function filteredExtent(filter, column) {
-  if (!filter) return;
-
-  let lo;
-  let hi;
-  const visitor = (type, clause) => {
-    if (type === 'BETWEEN' && clause.field.column === column) {
-      const { range } = clause;
-      if (range && (lo == null || range[0] < lo)) lo = range[0];
-      if (range && (hi == null || range[1] > hi)) hi = range[1];
-    }
-  };
-
-  if (Array.isArray(filter)) {
-    filter.forEach(p => p.visit?.(visitor));
-  } else if (filter.visit) {
-    filter.visit(visitor);
-  }
-
-  return lo != null && hi != null && lo !== hi ? [lo, hi] : undefined;
-}

package/src/marks/util/grid.js

@@ -1,57 +0,0 @@
-import { isArrowTable } from './is-arrow-table.js';
-
-export function grid1d(n, values) {
-  return valuesToGrid(new Float64Array(n), values);
-}
-
-export function grid2d(m, n, values, groupby = []) {
-  return groupby.length
-    ? Object.values(groupedValuesToGrids(m * n, values, groupby))
-    : [{ grid: valuesToGrid(new Float64Array(m * n), values) }];
-}
-
-function valuesToGrid(grid, values) {
-  if (isArrowTable(values)) {
-    // optimize access for Arrow tables
-    const numRows = values.numRows;
-    if (numRows === 0) return grid;
-    const index = values.getChild('index').toArray();
-    const value = values.getChild('value').toArray();
-    for (let row = 0; row < numRows; ++row) {
-      grid[index[row]] = value[row];
-    }
-  } else {
-    // fallback to iterable data
-    for (const row of values) {
-      grid[row.index] = row.value;
-    }
-  }
-  return grid;
-}
-
-function groupedValuesToGrids(size, values, groupby) {
-  const grids = {};
-  const getGrid = key => {
-    const cell = grids[key] || (grids[key] = { key, grid: new Float64Array(size) });
-    return cell.grid;
-  };
-  if (isArrowTable(values)) {
-    // optimize access for Arrow tables
-    const numRows = values.numRows;
-    if (numRows === 0) return grids;
-    const index = values.getChild('index').toArray();
-    const value = values.getChild('value').toArray();
-    const groups = groupby.map(name => values.getChild(name));
-    for (let row = 0; row < numRows; ++row) {
-      const key = groups.map(vec => vec.get(row));
-      getGrid(key)[index[row]] = value[row];
-    }
-  } else {
-    // fallback to iterable data
-    for (const row of values) {
-      const key = groupby.map(col => row[col]);
-      getGrid(key)[row.index] = row.value;
-    }
-  }
-  return grids;
-}

package/src/marks/util/handle-param.js

@@ -1,14 +0,0 @@
-import { isParam } from '@uwdata/mosaic-core';
-
-export function handleParam(client, key, param, update) {
-  if (isParam(param)) {
-    update = update || (() => client.requestUpdate());
-    param.addEventListener('value', value => {
-      client[key] = value;
-      return update();
-    });
-    client[key] = param.value;
-  } else {
-    client[key] = param;
-  }
-}

package/src/marks/util/is-arrow-table.js

@@ -1,3 +0,0 @@
-export function isArrowTable(values) {
-  return typeof values?.getChild === 'function';
-}

package/src/marks/util/is-color.js

@@ -1,18 +0,0 @@
-import { color } from 'd3';
-
-// Mostly relies on d3-color, with a few extra color keywords. Currently this
-// strictly requires that the value be a string; we might want to apply string
-// coercion here, though note that d3-color instances would need to support
-// valueOf to work correctly with InternMap.
-// https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint
-export function isColor(value) {
-  if (typeof value !== "string") return false;
-  value = value.toLowerCase().trim();
-  return (
-    value === "none" ||
-    value === "currentcolor" ||
-    (value.startsWith("url(") && value.endsWith(")")) || // <funciri>, e.g. pattern or gradient
-    (value.startsWith("var(") && value.endsWith(")")) || // CSS variable
-    color(value) !== null
-  );
-}

package/src/marks/util/is-constant-option.js

@@ -1,40 +0,0 @@
-const constantOptions = new Set([
-  'order',
-  'sort',
-  'label',
-  'anchor',
-  'curve',
-  'tension',
-  'marker',
-  'markerStart',
-  'markerMid',
-  'markerEnd',
-  'textAnchor',
-  'lineAnchor',
-  'lineHeight',
-  'textOverflow',
-  'monospace',
-  'fontFamily',
-  'fontSize',
-  'fontStyle',
-  'fontVariant',
-  'fontWeight',
-  'frameAnchor',
-  'strokeLinejoin',
-  'strokeLinecap',
-  'strokeMiterlimit',
-  'strokeDasharray',
-  'strokeDashoffset',
-  'mixBlendMode',
-  'shapeRendering',
-  'imageRendering',
-  'preserveAspectRatio',
-  'interpolate',
-  'crossOrigin',
-  'paintOrder',
-  'pointerEvents'
-]);
-
-export function isConstantOption(value) {
-  return constantOptions.has(value);
-}

package/src/marks/util/is-symbol.js

@@ -1,20 +0,0 @@
-const symbols = new Set([
-  'asterisk',
-  'circle',
-  'cross',
-  'diamond',
-  'diamond2',
-  'hexagon',
-  'plus',
-  'square',
-  'square2',
-  'star',
-  'times',
-  'triangle',
-  'triangle2',
-  'wye'
-]);
-
-export function isSymbol(value) {
-  return symbols.has(`${value}`.toLowerCase());
-}

package/src/marks/util/raster.js

@@ -1,44 +0,0 @@
-import { rgb } from 'd3';
-
-export function raster(grid, data, w, h, scale, scheme) {
-  const n = (scheme.length >> 2) - 1;
-  for (let j = 0, k = 0; j < h; ++j) {
-    for (let i = 0, row = (h - j - 1) * w; i < w; ++i, k += 4) {
-      const c = (n * scale(grid[i + row])) << 2;
-      data[k + 0] = scheme[c + 0];
-      data[k + 1] = scheme[c + 1];
-      data[k + 2] = scheme[c + 2];
-      data[k + 3] = scheme[c + 3];
-    }
-  }
-}
-
-export function palette(size, interp) {
-  const p = new Uint8ClampedArray(4 * size);
-  const n = size - 1;
-  for (let i = 0; i <= n; ++i) {
-    const v = interp(i / n);
-    const { r, g, b, opacity = 1 } = typeof v === 'string' ? rgb(v) : v;
-    const k = i << 2;
-    p[k + 0] = r;
-    p[k + 1] = g;
-    p[k + 2] = b;
-    p[k + 3] = (255 * opacity) | 0;
-  }
-  return p;
-}
-
-export function createCanvas(w, h) {
-  if (typeof document !== 'undefined') {
-    const c = document.createElement('canvas');
-    c.setAttribute('width', w);
-    c.setAttribute('height', h);
-    return c;
-  }
-  throw new Error('Can not create a canvas instance.');
-}
-
-export function opacityMap(color = 'black') {
-  const { r, g, b } = rgb(color);
-  return opacity => ({ r, g, b, opacity });
-}