@uwdata/vgplot 0.4.0 → 0.5.0

package/src/marks/DenseLineMark.js

@@ -1,146 +0,0 @@
-import { Query, and, count, isNull, isBetween, sql, sum } from '@uwdata/mosaic-sql';
-import { binField, bin1d } from './util/bin-field.js';
-import { extentX, extentY } from './util/extent.js';
-import { handleParam } from './util/handle-param.js';
-import { RasterMark } from './RasterMark.js';
-
-export class DenseLineMark extends RasterMark {
-  constructor(source, options) {
-    const { normalize = true, ...rest } = options;
-    super(source, { bandwidth: 0, ...rest });
-    handleParam(this, 'normalize', normalize);
-  }
-
-  query(filter = []) {
-    const { plot, channels, normalize, source } = this;
-    const [x0, x1] = extentX(this, filter);
-    const [y0, y1] = extentY(this, filter);
-    const [nx, ny] = this.bins = this.binDimensions(this);
-    const bx = binField(this, 'x');
-    const by = binField(this, 'y');
-    const rx = !!plot.getAttribute('xReverse');
-    const ry = !!plot.getAttribute('yReverse');
-    const x = bin1d(bx, x0, x1, nx, rx, this.binPad);
-    const y = bin1d(by, y0, y1, ny, ry, this.binPad);
-
-    const q = Query
-      .from(source.table)
-      .where(stripXY(this, filter));
-
-    const groupby = this.groupby = [];
-    const z = [];
-    for (const c of channels) {
-      if (Object.hasOwn(c, 'field')) {
-        const { channel, field } = c;
-        if (channel === 'z') {
-          q.select({ [channel]: field });
-          z.push('z');
-        } else if (channel !== 'x' && channel !== 'y') {
-          q.select({ [channel]: field });
-          groupby.push(channel);
-        }
-      }
-    }
-
-    return lineDensity(q, x, y, z, nx, ny, groupby, normalize);
-  }
-}
-
-// strip x, y fields from filter predicate
-// to prevent improper clipping of line segments
-// TODO: improve, perhaps with supporting query utilities
-function stripXY(mark, filter) {
-  if (Array.isArray(filter) && !filter.length) return filter;
-
-  const xc = mark.channelField('x').field.column;
-  const yc = mark.channelField('y').field.column;
-  const test = p => p.op !== 'BETWEEN'
-    || p.field.column !== xc && p.field.column !== yc;
-  const filterAnd = p => p.op === 'AND'
-    ? and(p.children.filter(c => test(c)))
-    : p;
-
-  return Array.isArray(filter)
-    ? filter.filter(p => test(p)).map(p => filterAnd(p))
-    : filterAnd(filter);
-}
-
-function lineDensity(
-  q, x, y, z, xn, yn,
-  groupby = [], normalize = true
-) {
-  // select x, y points binned to the grid
-  q.select({
-    x: sql`FLOOR(${x})::INTEGER`,
-    y: sql`FLOOR(${y})::INTEGER`
-  });
-
-  // select line segment end point pairs
-  const groups = groupby.concat(z);
-  const pairPart = groups.length ? `PARTITION BY ${groups.join(', ')} ` : '';
-  const pairs = Query
-    .from(q)
-    .select(groups, {
-      x0: 'x',
-      y0: 'y',
-      dx: sql`(lead(x) OVER sw - x)`,
-      dy: sql`(lead(y) OVER sw - y)`
-    })
-    .window({ sw: sql`${pairPart}ORDER BY x ASC` })
-    .qualify(and(
-      sql`(x0 < ${xn} OR x0 + dx < ${xn})`,
-      sql`(y0 < ${yn} OR y0 + dy < ${yn})`,
-      sql`(x0 > 0 OR x0 + dx > 0)`,
-      sql`(y0 > 0 OR y0 + dy > 0)`
-    ));
-
-  // indices to join against for rasterization
-  // generate the maximum number of indices needed
-  const num = Query
-    .select({ x: sql`GREATEST(MAX(ABS(dx)), MAX(ABS(dy)))` })
-    .from('pairs');
-  const indices = Query.select({ i: sql`UNNEST(range((${num})))::INTEGER` });
-
-  // rasterize line segments
-  const raster = Query.unionAll(
-    Query
-      .select(groups, {
-        x: sql`x0 + i`,
-        y: sql`y0 + ROUND(i * dy / dx::FLOAT)::INTEGER`
-      })
-      .from('pairs', 'indices')
-      .where(sql`ABS(dy) <= ABS(dx) AND i < ABS(dx)`),
-    Query
-      .select(groups, {
-        x: sql`x0 + ROUND(SIGN(dy) * i * dx / dy::FLOAT)::INTEGER`,
-        y: sql`y0 + SIGN(dy) * i`
-      })
-      .from('pairs', 'indices')
-      .where(sql`ABS(dy) > ABS(dx) AND i < ABS(dy)`),
-    Query
-      .select(groups, { x: 'x0', y: 'y0' })
-      .from('pairs')
-      .where(isNull('dx'))
-  );
-
-  // filter raster, normalize columns for each series
-  const pointPart = ['x'].concat(groups).join(', ');
-  const points = Query
-    .from('raster')
-    .select(groups, 'x', 'y',
-      normalize
-        ? { w: sql`1.0 / COUNT(*) OVER (PARTITION BY ${pointPart})` }
-        : null
-    )
-    .where(and(isBetween('x', [0, xn]), isBetween('y', [0, yn])));
-
-  // sum normalized, rasterized series into output grids
-  return Query
-    .with({ pairs, indices, raster, points })
-    .from('points')
-    .select(groupby, {
-      index: sql`x + y * ${xn}::INTEGER`,
-      value: normalize ? sum('w') : count()
-    })
-    .groupby('index', groupby);
-}

package/src/marks/Density1DMark.js

@@ -1,104 +0,0 @@
-import { Query, gt, isBetween, sql, sum } from '@uwdata/mosaic-sql';
-import { Transient } from '../symbols.js';
-import { binField, bin1d } from './util/bin-field.js';
-import { dericheConfig, dericheConv1d } from './util/density.js';
-import { extentX, extentY, xext, yext } from './util/extent.js';
-import { grid1d } from './util/grid.js';
-import { handleParam } from './util/handle-param.js';
-import { Mark, channelOption, markQuery } from './Mark.js';
-
-export class Density1DMark extends Mark {
-  constructor(type, source, options) {
-    const { bins = 1024, bandwidth = 20, ...channels } = options;
-    const dim = type.endsWith('X') ? 'y' : 'x';
-
-    super(type, source, channels, dim === 'x' ? xext : yext);
-    this.dim = dim;
-
-    handleParam(this, 'bins', bins);
-    handleParam(this, 'bandwidth', bandwidth, () => {
-      return this.grid ? this.convolve().update() : null
-    });
-  }
-
-  get filterIndexable() {
-    const name = this.dim === 'x' ? 'xDomain' : 'yDomain';
-    const dom = this.plot.getAttribute(name);
-    return dom && !dom[Transient];
-  }
-
-  query(filter = []) {
-    if (this.hasOwnData()) throw new Error('Density1DMark requires a data source');
-    const { bins, channels, dim, source: { table } } = this;
-    const [lo, hi] = this.extent = (dim === 'x' ? extentX : extentY)(this, filter);
-    const bx = binField(this, dim);
-    return binLinear1d(
-      markQuery(channels, table, [dim])
-        .where(filter.concat(isBetween(bx, [lo, hi]))),
-      bin1d(bx, lo, hi, bins),
-      this.channelField('weight') ? 'weight' : null
-    );
-  }
-
-  queryResult(data) {
-    this.grid = grid1d(this.bins, data);
-    return this.convolve();
-  }
-
-  convolve() {
-    const { bins, bandwidth, dim, grid, plot, extent: [lo, hi] } = this;
-
-    // perform smoothing
-    const neg = grid.some(v => v < 0);
-    const size = dim === 'x' ? plot.innerWidth() : plot.innerHeight();
-    const config = dericheConfig(bandwidth * (bins - 1) / size, neg);
-    const result = dericheConv1d(config, grid, bins);
-
-    // map smoothed grid values to sample data points
-    const points = this.data = [];
-    const v = dim === 'x' ? 'y' : 'x';
-    const b = this.channelField(dim).as;
-    const b0 = +lo;
-    const delta = (hi - b0) / (bins - 1);
-    const scale = 1 / delta;
-    for (let i = 0; i < bins; ++i) {
-      points.push({
-        [b]: b0 + i * delta,
-        [v]: result[i] * scale
-      });
-    }
-
-    return this;
-  }
-
-  plotSpecs() {
-    const { type, data, channels, dim } = this;
-    const options = dim === 'x' ? { y: 'y' } : { x: 'x' };
-    for (const c of channels) {
-      options[c.channel] = channelOption(c);
-    }
-    return [{ type, data, options }];
-  }
-}
-
-function binLinear1d(q, p, value) {
-  const w = value ? `* ${value}` : '';
-
-  const u = q.clone().select({
-    p,
-    i: sql`FLOOR(p)::INTEGER`,
-    w: sql`(FLOOR(p) + 1 - p)${w}`
-  });
-
-  const v = q.clone().select({
-    p,
-    i: sql`FLOOR(p)::INTEGER + 1`,
-    w: sql`(p - FLOOR(p))${w}`
-  });
-
-  return Query
-    .from(Query.unionAll(u, v))
-    .select({ index: 'i', value: sum('w') })
-    .groupby('index')
-    .having(gt('value', 0));
-}

package/src/marks/Density2DMark.js

@@ -1,69 +0,0 @@
-import { handleParam } from './util/handle-param.js';
-import { Grid2DMark } from './Grid2DMark.js';
-import { channelOption } from './Mark.js';
-
-export class Density2DMark extends Grid2DMark {
-  constructor(source, options) {
-    const { type = 'dot', binsX, binsY, ...channels } = options;
-    channels.binPad = channels.binPad ?? 0;
-    super(type, source, channels);
-    handleParam(this, 'binsX', binsX);
-    handleParam(this, 'binsY', binsY);
-  }
-
-  convolve() {
-    super.convolve();
-    const { bins, binPad, extentX, extentY } = this;
-    const [nx, ny] = bins;
-    const [x0, x1] = extentX;
-    const [y0, y1] = extentY;
-    const deltaX = (x1 - x0) / (nx - binPad);
-    const deltaY = (y1 - y0) / (ny - binPad);
-    const offset = binPad ? 0 : 0.5;
-    this.data = points(this.kde, bins, x0, y0, deltaX, deltaY, offset);
-    return this;
-  }
-
-  binDimensions() {
-    const { plot, binWidth, binsX, binsY } = this;
-    return [
-      binsX ?? Math.round(plot.innerWidth() / binWidth),
-      binsY ?? Math.round(plot.innerHeight() / binWidth)
-    ];
-  }
-
-  plotSpecs() {
-    const { type, channels, densityMap, data } = this;
-    const options = {};
-    for (const c of channels) {
-      const { channel } = c;
-      options[channel] = (channel === 'x' || channel === 'y')
-        ? channel // use generated x/y data fields
-        : channelOption(c);
-    }
-    for (const channel in densityMap) {
-      if (densityMap[channel]) {
-        options[channel] = 'density';
-      }
-    }
-    return [{ type, data, options }];
-  }
-}
-
-function points(kde, bins, x0, y0, deltaX, deltaY, offset) {
-  const scale = 1 / (deltaX * deltaY);
-  const [nx, ny] = bins;
-  const data = [];
-  for (const grid of kde) {
-    for (let k = 0, j = 0; j < ny; ++j) {
-      for (let i = 0; i < nx; ++i, ++k) {
-        data.push({
-          x: x0 + (i + offset) * deltaX,
-          y: y0 + (j + offset) * deltaY,
-          density: grid[k] * scale
-        });
-      }
-    }
-  }
-  return data;
-}

package/src/marks/Grid2DMark.js

@@ -1,191 +0,0 @@
-import { Query, count, gt, isBetween, lt, lte, sql, sum } from '@uwdata/mosaic-sql';
-import { Transient } from '../symbols.js';
-import { binField } from './util/bin-field.js';
-import { dericheConfig, dericheConv2d } from './util/density.js';
-import { extentX, extentY, xyext } from './util/extent.js';
-import { grid2d } from './util/grid.js';
-import { handleParam } from './util/handle-param.js';
-import { Mark } from './Mark.js';
-
-export class Grid2DMark extends Mark {
-  constructor(type, source, options) {
-    const {
-      bandwidth = 20,
-      binType = 'linear',
-      binWidth = 2,
-      binPad = 1,
-      ...channels
-    } = options;
-
-    const densityMap = createDensityMap(channels);
-    super(type, source, channels, xyext);
-    this.densityMap = densityMap;
-
-    handleParam(this, 'bandwidth', bandwidth, () => {
-      return this.grids ? this.convolve().update() : null;
-    });
-    handleParam(this, 'binWidth', binWidth);
-    handleParam(this, 'binType', binType);
-    handleParam(this, 'binPad', binPad);
-  }
-
-  setPlot(plot, index) {
-    const update = () => { if (this.stats) this.requestUpdate(); };
-    plot.addAttributeListener('domainX', update);
-    plot.addAttributeListener('domainY', update);
-    return super.setPlot(plot, index);
-  }
-
-  get filterIndexable() {
-    const xdom = this.plot.getAttribute('xDomain');
-    const ydom = this.plot.getAttribute('yDomain');
-    return xdom && ydom && !xdom[Transient] && !ydom[Transient];
-  }
-
-  query(filter = []) {
-    const { plot, binType, binPad, channels, densityMap, source } = this;
-    const [x0, x1] = this.extentX = extentX(this, filter);
-    const [y0, y1] = this.extentY = extentY(this, filter);
-    const [nx, ny] = this.bins = this.binDimensions(this);
-    const bx = binField(this, 'x');
-    const by = binField(this, 'y');
-    const rx = !!plot.getAttribute('xReverse');
-    const ry = !!plot.getAttribute('yReverse');
-    const x = bin1d(bx, x0, x1, nx, rx, this.binPad);
-    const y = bin1d(by, y0, y1, ny, ry, this.binPad);
-
-    // with padded bins, include the entire domain extent
-    // if the bins are flush, exclude the extent max
-    const bounds = binPad
-      ? [isBetween(bx, [x0, x1]), isBetween(by, [y0, y1])]
-      : [lte(x0, bx), lt(bx, x1), lte(y0, by), lt(by, y1)];
-
-    const q = Query
-      .from(source.table)
-      .where(filter.concat(bounds));
-
-    const groupby = this.groupby = [];
-    let agg = count();
-    for (const c of channels) {
-      if (Object.hasOwn(c, 'field')) {
-        const { as, channel, field } = c;
-        if (field.aggregate) {
-          agg = field;
-          densityMap[channel] = true;
-        } else if (channel === 'weight') {
-          agg = sum(field);
-        } else if (channel !== 'x' && channel !== 'y') {
-          q.select({ [as]: field });
-          groupby.push(as);
-        }
-      }
-    }
-
-    return binType === 'linear'
-      ? binLinear2d(q, x, y, agg, nx, groupby)
-      : bin2d(q, x, y, agg, nx, groupby);
-  }
-
-  binDimensions() {
-    const { plot, binWidth } = this;
-    return [
-      Math.round(plot.innerWidth() / binWidth),
-      Math.round(plot.innerHeight() / binWidth)
-    ];
-  }
-
-  queryResult(data) {
-    const [nx, ny] = this.bins;
-    this.grids = grid2d(nx, ny, data, this.groupby);
-    return this.convolve();
-  }
-
-  convolve() {
-    const { bandwidth, bins, grids, plot } = this;
-
-    if (bandwidth <= 0) {
-      this.kde = this.grids.map(({ key, grid }) => {
-        return (grid.key = key, grid);
-      });
-    } else {
-      const w = plot.innerWidth();
-      const h = plot.innerHeight();
-      const [nx, ny] = bins;
-      const neg = grids.some(({ grid }) => grid.some(v => v < 0));
-      const configX = dericheConfig(bandwidth * (nx - 1) / w, neg);
-      const configY = dericheConfig(bandwidth * (ny - 1) / h, neg);
-      this.kde = this.grids.map(({ key, grid }) => {
-        const k = dericheConv2d(configX, configY, grid, bins);
-        return (k.key = key, k);
-      });
-    }
-    return this;
-  }
-
-  plotSpecs() {
-    throw new Error('Unimplemented. Use a Grid2D mark subclass.');
-  }
-}
-
-function createDensityMap(channels) {
-  const densityMap = {};
-  for (const key in channels) {
-    if (channels[key] === 'density') {
-      delete channels[key];
-      densityMap[key] = true;
-    }
-  }
-  return densityMap;
-}
-
-function bin1d(x, x0, x1, n, reverse, pad) {
-  const d = (n - pad) / (x1 - x0);
-  const f = d !== 1 ? ` * ${d}::DOUBLE` : '';
-  return reverse
-    ? sql`(${x1} - ${x}::DOUBLE)${f}`
-    : sql`(${x}::DOUBLE - ${x0})${f}`;
-}
-
-function bin2d(q, xp, yp, value, xn, groupby) {
-  return q
-    .select({
-      index: sql`FLOOR(${xp})::INTEGER + FLOOR(${yp})::INTEGER * ${xn}`,
-      value
-    })
-    .groupby('index', groupby);
-}
-
-function binLinear2d(q, xp, yp, value, xn, groupby) {
-  const w = value.column ? `* ${value.column}` : '';
-  const subq = (i, w) => q.clone().select({ xp, yp, i, w });
-
-  // grid[xu + yu * xn] += (xv - xp) * (yv - yp) * wi;
-  const a = subq(
-    sql`FLOOR(xp)::INTEGER + FLOOR(yp)::INTEGER * ${xn}`,
-    sql`(FLOOR(xp)::INTEGER + 1 - xp) * (FLOOR(yp)::INTEGER + 1 - yp)${w}`
-  );
-
-  // grid[xu + yv * xn] += (xv - xp) * (yp - yu) * wi;
-  const b = subq(
-    sql`FLOOR(xp)::INTEGER + (FLOOR(yp)::INTEGER + 1) * ${xn}`,
-    sql`(FLOOR(xp)::INTEGER + 1 - xp) * (yp - FLOOR(yp)::INTEGER)${w}`
-  );
-
-  // grid[xv + yu * xn] += (xp - xu) * (yv - yp) * wi;
-  const c = subq(
-    sql`FLOOR(xp)::INTEGER + 1 + FLOOR(yp)::INTEGER * ${xn}`,
-    sql`(xp - FLOOR(xp)::INTEGER) * (FLOOR(yp)::INTEGER + 1 - yp)${w}`
-  );
-
-  // grid[xv + yv * xn] += (xp - xu) * (yp - yu) * wi;
-  const d = subq(
-    sql`FLOOR(xp)::INTEGER + 1 + (FLOOR(yp)::INTEGER + 1) * ${xn}`,
-    sql`(xp - FLOOR(xp)::INTEGER) * (yp - FLOOR(yp)::INTEGER)${w}`
-  );
-
-  return Query
-    .from(Query.unionAll(a, b, c, d))
-    .select({ index: 'i', value: sum('w') }, groupby)
-    .groupby('index', groupby)
-    .having(gt('value', 0));
-}

package/src/marks/HexbinMark.js

@@ -1,88 +0,0 @@
-import { Query, isNotNull, sql } from '@uwdata/mosaic-sql';
-import { Transient } from '../symbols.js';
-import { extentX, extentY, xyext } from './util/extent.js';
-import { Mark } from './Mark.js';
-
-export class HexbinMark extends Mark {
-  constructor(source, options) {
-    const { type = 'hexagon', binWidth = 20, ...channels } = options;
-    super(type, source, { r: binWidth / 2, clip: true, ...channels }, xyext);
-    this.binWidth = binWidth;
-  }
-
-  get filterIndexable() {
-    const xdom = this.plot.getAttribute('xDomain');
-    const ydom = this.plot.getAttribute('yDomain');
-    return xdom && ydom && !xdom[Transient] && !ydom[Transient];
-  }
-
-  query(filter = []) {
-    if (this.hasOwnData()) return null;
-    const { plot, binWidth, channels, source } = this;
-
-    // get x / y extents, may update plot domainX / domainY
-    const [x1, x2] = extentX(this, filter);
-    const [y1, y2] = extentY(this, filter);
-
-    // Adjust screen-space coordinates by top/left
-    // margins as this is what Observable Plot does.
-    // TODO use zero margins when faceted?
-    const ox = 0.5 - plot.getAttribute('marginLeft');
-    const oy = 0 - plot.getAttribute('marginTop');
-    const dx = `${binWidth}::DOUBLE`;
-    const dy = `${binWidth * (1.5 / Math.sqrt(3))}::DOUBLE`;
-    const xr = `${plot.innerWidth() / (x2 - x1)}::DOUBLE`;
-    const yr = `${plot.innerHeight() / (y2 - y1)}::DOUBLE`;
-
-    // Extract channel information, update top-level query
-    // and extract dependent columns for aggregates
-    let x, y;
-    const aggr = new Set;
-    const cols = {};
-    for (const c of channels) {
-      if (c.channel === 'orderby') {
-        q.orderby(c.value); // TODO revisit once groupby is added
-      } else if (c.channel === 'x') {
-        x = c;
-      } else if (c.channel === 'y') {
-        y = c;
-      } else if (Object.hasOwn(c, 'field')) {
-        cols[c.as] = c.field;
-        if (c.field.aggregate) {
-          c.field.columns.forEach(col => aggr.add(col));
-        }
-      }
-    }
-
-    // Top-level query; we add a hex binning subquery below
-    // Maps binned screen space coordinates back to data
-    // values to ensure we get correct data-driven scales
-    const q = Query.select({
-      [x.as]: sql`${x1}::DOUBLE + ((x + 0.5 * (y & 1)) * ${dx} + ${ox})::DOUBLE / ${xr}`,
-      [y.as]: sql`${y2}::DOUBLE - (y * ${dy} + ${oy})::DOUBLE / ${yr}`,
-      ...cols
-    }).groupby('x', 'y');
-
-    // Map x/y channels to screen space
-    const xx = `${xr} * (${x.field} - ${x1}::DOUBLE)`;
-    const yy = `${yr} * (${y2}::DOUBLE - ${y.field})`;
-
-    // Perform hex binning of x/y coordinates
-    // TODO add groupby dims
-    const hex = Query
-      .select({
-        py: sql`(${yy} - ${oy}) / ${dy}`,
-        pj: sql`ROUND(py)::INTEGER`,
-        px: sql`(${xx} - ${ox}) / ${dx} - 0.5 * (pj & 1)`,
-        pi: sql`ROUND(px)::INTEGER`,
-        tt: sql`ABS(py-pj) * 3 > 1 AND (px-pi)**2 + (py-pj)**2 > (px - pi - 0.5 * CASE WHEN px < pi THEN -1 ELSE 1 END)**2 + (py - pj - CASE WHEN py < pj THEN -1 ELSE 1 END)**2`,
-        x: sql`CASE WHEN tt THEN (pi + (CASE WHEN px < pi THEN -0.5 ELSE 0.5 END) + (CASE WHEN pj & 1 <> 0 THEN 0.5 ELSE -0.5 END))::INTEGER ELSE pi END`,
-        y: sql`CASE WHEN tt THEN (pj + CASE WHEN py < pj THEN -1 ELSE 1 END)::INTEGER ELSE pj END`
-      })
-      .select(Array.from(aggr))
-      .from(source.table)
-      .where(isNotNull(x.field), isNotNull(y.field), filter)
-
-    return q.from(hex);
-  }
-}