@veritone-ce/design-system 2.9.0-next.2 → 2.9.0-next.3

package/dist/cjs/bundled_modules/vega-geo/build/vega-geo.js

@@ -0,0 +1,1333 @@
+'use strict';
+
+var vegaDataflow = require('../../vega-dataflow/build/vega-dataflow.js');
+var vegaUtil = require('../../vega-util/build/vega-util.js');
+var vegaStatistics = require('../../vega-statistics/build/vega-statistics.js');
+var vegaProjection = require('../../vega-projection/build/vega-projection.js');
+var vegaCanvas_browser = require('../../vega-canvas/build/vega-canvas.browser.js');
+var graticule = require('../../d3-geo/src/graticule.js');
+var max = require('../../d3-array/src/max.js');
+var color = require('../../d3-color/src/color.js');
+var ticks = require('../../d3-array/src/ticks.js');
+var range = require('../../d3-array/src/range.js');
+var sum = require('../../d3-array/src/sum.js');
+
+function noop() {}
+const cases = [[], [[[1.0, 1.5], [0.5, 1.0]]], [[[1.5, 1.0], [1.0, 1.5]]], [[[1.5, 1.0], [0.5, 1.0]]], [[[1.0, 0.5], [1.5, 1.0]]], [[[1.0, 1.5], [0.5, 1.0]], [[1.0, 0.5], [1.5, 1.0]]], [[[1.0, 0.5], [1.0, 1.5]]], [[[1.0, 0.5], [0.5, 1.0]]], [[[0.5, 1.0], [1.0, 0.5]]], [[[1.0, 1.5], [1.0, 0.5]]], [[[0.5, 1.0], [1.0, 0.5]], [[1.5, 1.0], [1.0, 1.5]]], [[[1.5, 1.0], [1.0, 0.5]]], [[[0.5, 1.0], [1.5, 1.0]]], [[[1.0, 1.5], [1.5, 1.0]]], [[[0.5, 1.0], [1.0, 1.5]]], []];
+
+// Implementation adapted from d3/d3-contour. Thanks!
+function contours () {
+  var dx = 1,
+    dy = 1,
+    smooth = smoothLinear;
+  function contours(values, tz) {
+    return tz.map(value => contour(values, value));
+  }
+
+  // Accumulate, smooth contour rings, assign holes to exterior rings.
+  // Based on https://github.com/mbostock/shapefile/blob/v0.6.2/shp/polygon.js
+  function contour(values, value) {
+    var polygons = [],
+      holes = [];
+    isorings(values, value, ring => {
+      smooth(ring, values, value);
+      if (area(ring) > 0) polygons.push([ring]);else holes.push(ring);
+    });
+    holes.forEach(hole => {
+      for (var i = 0, n = polygons.length, polygon; i < n; ++i) {
+        if (contains((polygon = polygons[i])[0], hole) !== -1) {
+          polygon.push(hole);
+          return;
+        }
+      }
+    });
+    return {
+      type: 'MultiPolygon',
+      value: value,
+      coordinates: polygons
+    };
+  }
+
+  // Marching squares with isolines stitched into rings.
+  // Based on https://github.com/topojson/topojson-client/blob/v3.0.0/src/stitch.js
+  function isorings(values, value, callback) {
+    var fragmentByStart = [],
+      fragmentByEnd = [],
+      x,
+      y,
+      t0,
+      t1,
+      t2,
+      t3;
+
+    // Special case for the first row (y = -1, t2 = t3 = 0).
+    x = y = -1;
+    t1 = values[0] >= value;
+    cases[t1 << 1].forEach(stitch);
+    while (++x < dx - 1) {
+      t0 = t1, t1 = values[x + 1] >= value;
+      cases[t0 | t1 << 1].forEach(stitch);
+    }
+    cases[t1 << 0].forEach(stitch);
+
+    // General case for the intermediate rows.
+    while (++y < dy - 1) {
+      x = -1;
+      t1 = values[y * dx + dx] >= value;
+      t2 = values[y * dx] >= value;
+      cases[t1 << 1 | t2 << 2].forEach(stitch);
+      while (++x < dx - 1) {
+        t0 = t1, t1 = values[y * dx + dx + x + 1] >= value;
+        t3 = t2, t2 = values[y * dx + x + 1] >= value;
+        cases[t0 | t1 << 1 | t2 << 2 | t3 << 3].forEach(stitch);
+      }
+      cases[t1 | t2 << 3].forEach(stitch);
+    }
+
+    // Special case for the last row (y = dy - 1, t0 = t1 = 0).
+    x = -1;
+    t2 = values[y * dx] >= value;
+    cases[t2 << 2].forEach(stitch);
+    while (++x < dx - 1) {
+      t3 = t2, t2 = values[y * dx + x + 1] >= value;
+      cases[t2 << 2 | t3 << 3].forEach(stitch);
+    }
+    cases[t2 << 3].forEach(stitch);
+    function stitch(line) {
+      var start = [line[0][0] + x, line[0][1] + y],
+        end = [line[1][0] + x, line[1][1] + y],
+        startIndex = index(start),
+        endIndex = index(end),
+        f,
+        g;
+      if (f = fragmentByEnd[startIndex]) {
+        if (g = fragmentByStart[endIndex]) {
+          delete fragmentByEnd[f.end];
+          delete fragmentByStart[g.start];
+          if (f === g) {
+            f.ring.push(end);
+            callback(f.ring);
+          } else {
+            fragmentByStart[f.start] = fragmentByEnd[g.end] = {
+              start: f.start,
+              end: g.end,
+              ring: f.ring.concat(g.ring)
+            };
+          }
+        } else {
+          delete fragmentByEnd[f.end];
+          f.ring.push(end);
+          fragmentByEnd[f.end = endIndex] = f;
+        }
+      } else if (f = fragmentByStart[endIndex]) {
+        if (g = fragmentByEnd[startIndex]) {
+          delete fragmentByStart[f.start];
+          delete fragmentByEnd[g.end];
+          if (f === g) {
+            f.ring.push(end);
+            callback(f.ring);
+          } else {
+            fragmentByStart[g.start] = fragmentByEnd[f.end] = {
+              start: g.start,
+              end: f.end,
+              ring: g.ring.concat(f.ring)
+            };
+          }
+        } else {
+          delete fragmentByStart[f.start];
+          f.ring.unshift(start);
+          fragmentByStart[f.start = startIndex] = f;
+        }
+      } else {
+        fragmentByStart[startIndex] = fragmentByEnd[endIndex] = {
+          start: startIndex,
+          end: endIndex,
+          ring: [start, end]
+        };
+      }
+    }
+  }
+  function index(point) {
+    return point[0] * 2 + point[1] * (dx + 1) * 4;
+  }
+  function smoothLinear(ring, values, value) {
+    ring.forEach(point => {
+      var x = point[0],
+        y = point[1],
+        xt = x | 0,
+        yt = y | 0,
+        v0,
+        v1 = values[yt * dx + xt];
+      if (x > 0 && x < dx && xt === x) {
+        v0 = values[yt * dx + xt - 1];
+        point[0] = x + (value - v0) / (v1 - v0) - 0.5;
+      }
+      if (y > 0 && y < dy && yt === y) {
+        v0 = values[(yt - 1) * dx + xt];
+        point[1] = y + (value - v0) / (v1 - v0) - 0.5;
+      }
+    });
+  }
+  contours.contour = contour;
+  contours.size = function (_) {
+    if (!arguments.length) return [dx, dy];
+    var _0 = Math.floor(_[0]),
+      _1 = Math.floor(_[1]);
+    if (!(_0 >= 0 && _1 >= 0)) vegaUtil.error('invalid size');
+    return dx = _0, dy = _1, contours;
+  };
+  contours.smooth = function (_) {
+    return arguments.length ? (smooth = _ ? smoothLinear : noop, contours) : smooth === smoothLinear;
+  };
+  return contours;
+}
+function area(ring) {
+  var i = 0,
+    n = ring.length,
+    area = ring[n - 1][1] * ring[0][0] - ring[n - 1][0] * ring[0][1];
+  while (++i < n) area += ring[i - 1][1] * ring[i][0] - ring[i - 1][0] * ring[i][1];
+  return area;
+}
+function contains(ring, hole) {
+  var i = -1,
+    n = hole.length,
+    c;
+  while (++i < n) if (c = ringContains(ring, hole[i])) return c;
+  return 0;
+}
+function ringContains(ring, point) {
+  var x = point[0],
+    y = point[1],
+    contains = -1;
+  for (var i = 0, n = ring.length, j = n - 1; i < n; j = i++) {
+    var pi = ring[i],
+      xi = pi[0],
+      yi = pi[1],
+      pj = ring[j],
+      xj = pj[0],
+      yj = pj[1];
+    if (segmentContains(pi, pj, point)) return 0;
+    if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) contains = -contains;
+  }
+  return contains;
+}
+function segmentContains(a, b, c) {
+  var i;
+  return collinear(a, b, c) && within(a[i = +(a[0] === b[0])], c[i], b[i]);
+}
+function collinear(a, b, c) {
+  return (b[0] - a[0]) * (c[1] - a[1]) === (c[0] - a[0]) * (b[1] - a[1]);
+}
+function within(p, q, r) {
+  return p <= q && q <= r || r <= q && q <= p;
+}
+
+function quantize (k, nice, zero) {
+  return function (values) {
+    var ex = vegaUtil.extent(values),
+      start = zero ? Math.min(ex[0], 0) : ex[0],
+      stop = ex[1],
+      span = stop - start,
+      step = nice ? ticks.tickStep(start, stop, k) : span / (k + 1);
+    return range.default(start + step, stop, step);
+  };
+}
+
+/**
+ * Generate isocontours (level sets) based on input raster grid data.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {function(object): *} [params.field] - The field with raster grid
+ *   data. If unspecified, the tuple itself is interpreted as a raster grid.
+ * @param {Array<number>} [params.thresholds] - Contour threshold array. If
+ *   specified, the levels, nice, resolve, and zero parameters are ignored.
+ * @param {number} [params.levels] - The desired number of contour levels.
+ * @param {boolean} [params.nice] - Boolean flag indicating if the contour
+ *   threshold values should be automatically aligned to "nice"
+ *   human-friendly values. Setting this flag may cause the number of
+ *   thresholds to deviate from the specified levels.
+ * @param {string} [params.resolve] - The method for resolving thresholds
+ *   across multiple input grids. If 'independent' (the default), threshold
+ *   calculation will be performed separately for each grid. If 'shared', a
+ *   single set of threshold values will be used for all input grids.
+ * @param {boolean} [params.zero] - Boolean flag indicating if the contour
+ *   threshold values should include zero.
+ * @param {boolean} [params.smooth] - Boolean flag indicating if the contour
+ *   polygons should be smoothed using linear interpolation. The default is
+ *   true. The parameter is ignored when using density estimation.
+ * @param {boolean} [params.scale] - Optional numerical value by which to
+ *   scale the output isocontour coordinates. This parameter can be useful
+ *   to scale the contours to match a desired output resolution.
+ * @param {string} [params.as='contour'] - The output field in which to store
+ *   the generated isocontour data (default 'contour').
+ */
+function Isocontour(params) {
+  vegaDataflow.Transform.call(this, null, params);
+}
+Isocontour.Definition = {
+  'type': 'Isocontour',
+  'metadata': {
+    'generates': true
+  },
+  'params': [{
+    'name': 'field',
+    'type': 'field'
+  }, {
+    'name': 'thresholds',
+    'type': 'number',
+    'array': true
+  }, {
+    'name': 'levels',
+    'type': 'number'
+  }, {
+    'name': 'nice',
+    'type': 'boolean',
+    'default': false
+  }, {
+    'name': 'resolve',
+    'type': 'enum',
+    'values': ['shared', 'independent'],
+    'default': 'independent'
+  }, {
+    'name': 'zero',
+    'type': 'boolean',
+    'default': true
+  }, {
+    'name': 'smooth',
+    'type': 'boolean',
+    'default': true
+  }, {
+    'name': 'scale',
+    'type': 'number',
+    'expr': true
+  }, {
+    'name': 'translate',
+    'type': 'number',
+    'array': true,
+    'expr': true
+  }, {
+    'name': 'as',
+    'type': 'string',
+    'null': true,
+    'default': 'contour'
+  }]
+};
+vegaUtil.inherits(Isocontour, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    if (this.value && !pulse.changed() && !_.modified()) {
+      return pulse.StopPropagation;
+    }
+    var out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS),
+      source = pulse.materialize(pulse.SOURCE).source,
+      field = _.field || vegaUtil.identity,
+      contour = contours().smooth(_.smooth !== false),
+      tz = _.thresholds || levels(source, field, _),
+      as = _.as === null ? null : _.as || 'contour',
+      values = [];
+    source.forEach(t => {
+      const grid = field(t);
+
+      // generate contour paths in GeoJSON format
+      const paths = contour.size([grid.width, grid.height])(grid.values, vegaUtil.isArray(tz) ? tz : tz(grid.values));
+
+      // adjust contour path coordinates as needed
+      transformPaths(paths, grid, t, _);
+
+      // ingest; copy source data properties to output
+      paths.forEach(p => {
+        values.push(vegaDataflow.rederive(t, vegaDataflow.ingest(as != null ? {
+          [as]: p
+        } : p)));
+      });
+    });
+    if (this.value) out.rem = this.value;
+    this.value = out.source = out.add = values;
+    return out;
+  }
+});
+function levels(values, f, _) {
+  const q = quantize(_.levels || 10, _.nice, _.zero !== false);
+  return _.resolve !== 'shared' ? q : q(values.map(t => max.default(f(t).values)));
+}
+function transformPaths(paths, grid, datum, _) {
+  let s = _.scale || grid.scale,
+    t = _.translate || grid.translate;
+  if (vegaUtil.isFunction(s)) s = s(datum, _);
+  if (vegaUtil.isFunction(t)) t = t(datum, _);
+  if ((s === 1 || s == null) && !t) return;
+  const sx = (vegaUtil.isNumber(s) ? s : s[0]) || 1,
+    sy = (vegaUtil.isNumber(s) ? s : s[1]) || 1,
+    tx = t && t[0] || 0,
+    ty = t && t[1] || 0;
+  paths.forEach(transform(grid, sx, sy, tx, ty));
+}
+function transform(grid, sx, sy, tx, ty) {
+  const x1 = grid.x1 || 0,
+    y1 = grid.y1 || 0,
+    flip = sx * sy < 0;
+  function transformPolygon(coordinates) {
+    coordinates.forEach(transformRing);
+  }
+  function transformRing(coordinates) {
+    if (flip) coordinates.reverse(); // maintain winding order
+    coordinates.forEach(transformPoint);
+  }
+  function transformPoint(coordinates) {
+    coordinates[0] = (coordinates[0] - x1) * sx + tx;
+    coordinates[1] = (coordinates[1] - y1) * sy + ty;
+  }
+  return function (geometry) {
+    geometry.coordinates.forEach(transformPolygon);
+    return geometry;
+  };
+}
+
+function radius(bw, data, f) {
+  const v = bw >= 0 ? bw : vegaStatistics.bandwidthNRD(data, f);
+  return Math.round((Math.sqrt(4 * v * v + 1) - 1) / 2);
+}
+function number(_) {
+  return vegaUtil.isFunction(_) ? _ : vegaUtil.constant(+_);
+}
+
+// Implementation adapted from d3/d3-contour. Thanks!
+function density2D () {
+  var x = d => d[0],
+    y = d => d[1],
+    weight = vegaUtil.one,
+    bandwidth = [-1, -1],
+    dx = 960,
+    dy = 500,
+    k = 2; // log2(cellSize)
+
+  function density(data, counts) {
+    const rx = radius(bandwidth[0], data, x) >> k,
+      // blur x-radius
+      ry = radius(bandwidth[1], data, y) >> k,
+      // blur y-radius
+      ox = rx ? rx + 2 : 0,
+      // x-offset padding for blur
+      oy = ry ? ry + 2 : 0,
+      // y-offset padding for blur
+      n = 2 * ox + (dx >> k),
+      // grid width
+      m = 2 * oy + (dy >> k),
+      // grid height
+      values0 = new Float32Array(n * m),
+      values1 = new Float32Array(n * m);
+    let values = values0;
+    data.forEach(d => {
+      const xi = ox + (+x(d) >> k),
+        yi = oy + (+y(d) >> k);
+      if (xi >= 0 && xi < n && yi >= 0 && yi < m) {
+        values0[xi + yi * n] += +weight(d);
+      }
+    });
+    if (rx > 0 && ry > 0) {
+      blurX(n, m, values0, values1, rx);
+      blurY(n, m, values1, values0, ry);
+      blurX(n, m, values0, values1, rx);
+      blurY(n, m, values1, values0, ry);
+      blurX(n, m, values0, values1, rx);
+      blurY(n, m, values1, values0, ry);
+    } else if (rx > 0) {
+      blurX(n, m, values0, values1, rx);
+      blurX(n, m, values1, values0, rx);
+      blurX(n, m, values0, values1, rx);
+      values = values1;
+    } else if (ry > 0) {
+      blurY(n, m, values0, values1, ry);
+      blurY(n, m, values1, values0, ry);
+      blurY(n, m, values0, values1, ry);
+      values = values1;
+    }
+
+    // scale density estimates
+    // density in points per square pixel or probability density
+    const s = counts ? Math.pow(2, -2 * k) : 1 / sum.default(values);
+    for (let i = 0, sz = n * m; i < sz; ++i) values[i] *= s;
+    return {
+      values: values,
+      scale: 1 << k,
+      width: n,
+      height: m,
+      x1: ox,
+      y1: oy,
+      x2: ox + (dx >> k),
+      y2: oy + (dy >> k)
+    };
+  }
+  density.x = function (_) {
+    return arguments.length ? (x = number(_), density) : x;
+  };
+  density.y = function (_) {
+    return arguments.length ? (y = number(_), density) : y;
+  };
+  density.weight = function (_) {
+    return arguments.length ? (weight = number(_), density) : weight;
+  };
+  density.size = function (_) {
+    if (!arguments.length) return [dx, dy];
+    var _0 = +_[0],
+      _1 = +_[1];
+    if (!(_0 >= 0 && _1 >= 0)) vegaUtil.error('invalid size');
+    return dx = _0, dy = _1, density;
+  };
+  density.cellSize = function (_) {
+    if (!arguments.length) return 1 << k;
+    if (!((_ = +_) >= 1)) vegaUtil.error('invalid cell size');
+    k = Math.floor(Math.log(_) / Math.LN2);
+    return density;
+  };
+  density.bandwidth = function (_) {
+    if (!arguments.length) return bandwidth;
+    _ = vegaUtil.array(_);
+    if (_.length === 1) _ = [+_[0], +_[0]];
+    if (_.length !== 2) vegaUtil.error('invalid bandwidth');
+    return bandwidth = _, density;
+  };
+  return density;
+}
+function blurX(n, m, source, target, r) {
+  const w = (r << 1) + 1;
+  for (let j = 0; j < m; ++j) {
+    for (let i = 0, sr = 0; i < n + r; ++i) {
+      if (i < n) {
+        sr += source[i + j * n];
+      }
+      if (i >= r) {
+        if (i >= w) {
+          sr -= source[i - w + j * n];
+        }
+        target[i - r + j * n] = sr / Math.min(i + 1, n - 1 + w - i, w);
+      }
+    }
+  }
+}
+function blurY(n, m, source, target, r) {
+  const w = (r << 1) + 1;
+  for (let i = 0; i < n; ++i) {
+    for (let j = 0, sr = 0; j < m + r; ++j) {
+      if (j < m) {
+        sr += source[i + j * n];
+      }
+      if (j >= r) {
+        if (j >= w) {
+          sr -= source[i + (j - w) * n];
+        }
+        target[i + (j - r) * n] = sr / Math.min(j + 1, m - 1 + w - j, w);
+      }
+    }
+  }
+}
+
+/**
+ * Perform 2D kernel-density estimation of point data.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {Array<number>} params.size - The [width, height] extent (in
+ *   units of input pixels) over which to perform density estimation.
+ * @param {function(object): number} params.x - The x-coordinate accessor.
+ * @param {function(object): number} params.y - The y-coordinate accessor.
+ * @param {function(object): number} [params.weight] - The weight accessor.
+ * @param {Array<function(object): *>} [params.groupby] - An array of accessors
+ *   to groupby.
+ * @param {number} [params.cellSize] - Contour density calculation cell size.
+ *   This parameter determines the level of spatial approximation. For example,
+ *   the default value of 4 maps to 2x reductions in both x- and y- dimensions.
+ *   A value of 1 will result in an output raster grid whose dimensions exactly
+ *   matches the size parameter.
+ * @param {Array<number>} [params.bandwidth] - The KDE kernel bandwidths,
+ *   in pixels. The input can be a two-element array specifying separate
+ *   x and y bandwidths, or a single-element array specifying both. If the
+ *   bandwidth is unspecified or less than zero, the bandwidth will be
+ *   automatically determined.
+ * @param {boolean} [params.counts=false] - A boolean flag indicating if the
+ *   output values should be probability estimates (false, default) or
+ *   smoothed counts (true).
+ * @param {string} [params.as='grid'] - The output field in which to store
+ *   the generated raster grid (default 'grid').
+ */
+function KDE2D(params) {
+  vegaDataflow.Transform.call(this, null, params);
+}
+KDE2D.Definition = {
+  'type': 'KDE2D',
+  'metadata': {
+    'generates': true
+  },
+  'params': [{
+    'name': 'size',
+    'type': 'number',
+    'array': true,
+    'length': 2,
+    'required': true
+  }, {
+    'name': 'x',
+    'type': 'field',
+    'required': true
+  }, {
+    'name': 'y',
+    'type': 'field',
+    'required': true
+  }, {
+    'name': 'weight',
+    'type': 'field'
+  }, {
+    'name': 'groupby',
+    'type': 'field',
+    'array': true
+  }, {
+    'name': 'cellSize',
+    'type': 'number'
+  }, {
+    'name': 'bandwidth',
+    'type': 'number',
+    'array': true,
+    'length': 2
+  }, {
+    'name': 'counts',
+    'type': 'boolean',
+    'default': false
+  }, {
+    'name': 'as',
+    'type': 'string',
+    'default': 'grid'
+  }]
+};
+const PARAMS = ['x', 'y', 'weight', 'size', 'cellSize', 'bandwidth'];
+function params(obj, _) {
+  PARAMS.forEach(param => _[param] != null ? obj[param](_[param]) : 0);
+  return obj;
+}
+vegaUtil.inherits(KDE2D, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    if (this.value && !pulse.changed() && !_.modified()) return pulse.StopPropagation;
+    var out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS),
+      source = pulse.materialize(pulse.SOURCE).source,
+      groups = partition(source, _.groupby),
+      names = (_.groupby || []).map(vegaUtil.accessorName),
+      kde = params(density2D(), _),
+      as = _.as || 'grid',
+      values = [];
+    function set(t, vals) {
+      for (let i = 0; i < names.length; ++i) t[names[i]] = vals[i];
+      return t;
+    }
+
+    // generate density raster grids
+    values = groups.map(g => vegaDataflow.ingest(set({
+      [as]: kde(g, _.counts)
+    }, g.dims)));
+    if (this.value) out.rem = this.value;
+    this.value = out.source = out.add = values;
+    return out;
+  }
+});
+function partition(data, groupby) {
+  var groups = [],
+    get = f => f(t),
+    map,
+    i,
+    n,
+    t,
+    k,
+    g;
+
+  // partition data points into groups
+  if (groupby == null) {
+    groups.push(data);
+  } else {
+    for (map = {}, i = 0, n = data.length; i < n; ++i) {
+      t = data[i];
+      k = groupby.map(get);
+      g = map[k];
+      if (!g) {
+        map[k] = g = [];
+        g.dims = k;
+        groups.push(g);
+      }
+      g.push(t);
+    }
+  }
+  return groups;
+}
+
+/**
+ * Generate contours based on kernel-density estimation of point data.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {Array<number>} params.size - The dimensions [width, height] over which to compute contours.
+ *  If the values parameter is provided, this must be the dimensions of the input data.
+ *  If density estimation is performed, this is the output view dimensions in pixels.
+ * @param {Array<number>} [params.values] - An array of numeric values representing an
+ *  width x height grid of values over which to compute contours. If unspecified, this
+ *  transform will instead attempt to compute contours for the kernel density estimate
+ *  using values drawn from data tuples in the input pulse.
+ * @param {function(object): number} [params.x] - The pixel x-coordinate accessor for density estimation.
+ * @param {function(object): number} [params.y] - The pixel y-coordinate accessor for density estimation.
+ * @param {function(object): number} [params.weight] - The data point weight accessor for density estimation.
+ * @param {number} [params.cellSize] - Contour density calculation cell size.
+ * @param {number} [params.bandwidth] - Kernel density estimation bandwidth.
+ * @param {Array<number>} [params.thresholds] - Contour threshold array. If
+ *   this parameter is set, the count and nice parameters will be ignored.
+ * @param {number} [params.count] - The desired number of contours.
+ * @param {boolean} [params.nice] - Boolean flag indicating if the contour
+ *   threshold values should be automatically aligned to "nice"
+ *   human-friendly values. Setting this flag may cause the number of
+ *   thresholds to deviate from the specified count.
+ * @param {boolean} [params.smooth] - Boolean flag indicating if the contour
+ *   polygons should be smoothed using linear interpolation. The default is
+ *   true. The parameter is ignored when using density estimation.
+ */
+function Contour(params) {
+  vegaDataflow.Transform.call(this, null, params);
+}
+Contour.Definition = {
+  'type': 'Contour',
+  'metadata': {
+    'generates': true
+  },
+  'params': [{
+    'name': 'size',
+    'type': 'number',
+    'array': true,
+    'length': 2,
+    'required': true
+  }, {
+    'name': 'values',
+    'type': 'number',
+    'array': true
+  }, {
+    'name': 'x',
+    'type': 'field'
+  }, {
+    'name': 'y',
+    'type': 'field'
+  }, {
+    'name': 'weight',
+    'type': 'field'
+  }, {
+    'name': 'cellSize',
+    'type': 'number'
+  }, {
+    'name': 'bandwidth',
+    'type': 'number'
+  }, {
+    'name': 'count',
+    'type': 'number'
+  }, {
+    'name': 'nice',
+    'type': 'boolean',
+    'default': false
+  }, {
+    'name': 'thresholds',
+    'type': 'number',
+    'array': true
+  }, {
+    'name': 'smooth',
+    'type': 'boolean',
+    'default': true
+  }]
+};
+vegaUtil.inherits(Contour, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    if (this.value && !pulse.changed() && !_.modified()) {
+      return pulse.StopPropagation;
+    }
+    var out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS),
+      contour = contours().smooth(_.smooth !== false),
+      values = _.values,
+      thresh = _.thresholds || quantize(_.count || 10, _.nice, !!values),
+      size = _.size,
+      grid,
+      post;
+    if (!values) {
+      values = pulse.materialize(pulse.SOURCE).source;
+      grid = params(density2D(), _)(values, true);
+      post = transform(grid, grid.scale || 1, grid.scale || 1, 0, 0);
+      size = [grid.width, grid.height];
+      values = grid.values;
+    }
+    thresh = vegaUtil.isArray(thresh) ? thresh : thresh(values);
+    values = contour.size(size)(values, thresh);
+    if (post) values.forEach(post);
+    if (this.value) out.rem = this.value;
+    this.value = out.source = out.add = (values || []).map(vegaDataflow.ingest);
+    return out;
+  }
+});
+
+const Feature = 'Feature';
+const FeatureCollection = 'FeatureCollection';
+const MultiPoint = 'MultiPoint';
+
+/**
+ * Consolidate an array of [longitude, latitude] points or GeoJSON features
+ * into a combined GeoJSON object. This transform is particularly useful for
+ * combining geo data for a Projection's fit argument. The resulting GeoJSON
+ * data is available as this transform's value. Input pulses are unchanged.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {Array<function(object): *>} [params.fields] - A two-element array
+ *   of field accessors for the longitude and latitude values.
+ * @param {function(object): *} params.geojson - A field accessor for
+ *   retrieving GeoJSON feature data.
+ */
+function GeoJSON(params) {
+  vegaDataflow.Transform.call(this, null, params);
+}
+GeoJSON.Definition = {
+  'type': 'GeoJSON',
+  'metadata': {},
+  'params': [{
+    'name': 'fields',
+    'type': 'field',
+    'array': true,
+    'length': 2
+  }, {
+    'name': 'geojson',
+    'type': 'field'
+  }]
+};
+vegaUtil.inherits(GeoJSON, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    var features = this._features,
+      points = this._points,
+      fields = _.fields,
+      lon = fields && fields[0],
+      lat = fields && fields[1],
+      geojson = _.geojson || !fields && vegaUtil.identity,
+      flag = pulse.ADD,
+      mod;
+    mod = _.modified() || pulse.changed(pulse.REM) || pulse.modified(vegaUtil.accessorFields(geojson)) || lon && pulse.modified(vegaUtil.accessorFields(lon)) || lat && pulse.modified(vegaUtil.accessorFields(lat));
+    if (!this.value || mod) {
+      flag = pulse.SOURCE;
+      this._features = features = [];
+      this._points = points = [];
+    }
+    if (geojson) {
+      pulse.visit(flag, t => features.push(geojson(t)));
+    }
+    if (lon && lat) {
+      pulse.visit(flag, t => {
+        var x = lon(t),
+          y = lat(t);
+        if (x != null && y != null && (x = +x) === x && (y = +y) === y) {
+          points.push([x, y]);
+        }
+      });
+      features = features.concat({
+        type: Feature,
+        geometry: {
+          type: MultiPoint,
+          coordinates: points
+        }
+      });
+    }
+    this.value = {
+      type: FeatureCollection,
+      features: features
+    };
+  }
+});
+
+/**
+ * Map GeoJSON data to an SVG path string.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {function(number, number): *} params.projection - The cartographic
+ *   projection to apply.
+ * @param {function(object): *} [params.field] - The field with GeoJSON data,
+ *   or null if the tuple itself is a GeoJSON feature.
+ * @param {string} [params.as='path'] - The output field in which to store
+ *   the generated path data (default 'path').
+ */
+function GeoPath(params) {
+  vegaDataflow.Transform.call(this, null, params);
+}
+GeoPath.Definition = {
+  'type': 'GeoPath',
+  'metadata': {
+    'modifies': true
+  },
+  'params': [{
+    'name': 'projection',
+    'type': 'projection'
+  }, {
+    'name': 'field',
+    'type': 'field'
+  }, {
+    'name': 'pointRadius',
+    'type': 'number',
+    'expr': true
+  }, {
+    'name': 'as',
+    'type': 'string',
+    'default': 'path'
+  }]
+};
+vegaUtil.inherits(GeoPath, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    var out = pulse.fork(pulse.ALL),
+      path = this.value,
+      field = _.field || vegaUtil.identity,
+      as = _.as || 'path',
+      flag = out.SOURCE;
+    if (!path || _.modified()) {
+      // parameters updated, reset and reflow
+      this.value = path = vegaProjection.getProjectionPath(_.projection);
+      out.materialize().reflow();
+    } else {
+      flag = field === vegaUtil.identity || pulse.modified(field.fields) ? out.ADD_MOD : out.ADD;
+    }
+    const prev = initPath(path, _.pointRadius);
+    out.visit(flag, t => t[as] = path(field(t)));
+    path.pointRadius(prev);
+    return out.modifies(as);
+  }
+});
+function initPath(path, pointRadius) {
+  const prev = path.pointRadius();
+  path.context(null);
+  if (pointRadius != null) {
+    path.pointRadius(pointRadius);
+  }
+  return prev;
+}
+
+/**
+ * Geo-code a longitude/latitude point to an x/y coordinate.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {function(number, number): *} params.projection - The cartographic
+ *   projection to apply.
+ * @param {Array<function(object): *>} params.fields - A two-element array of
+ *   field accessors for the longitude and latitude values.
+ * @param {Array<string>} [params.as] - A two-element array of field names
+ *   under which to store the result. Defaults to ['x','y'].
+ */
+function GeoPoint(params) {
+  vegaDataflow.Transform.call(this, null, params);
+}
+GeoPoint.Definition = {
+  'type': 'GeoPoint',
+  'metadata': {
+    'modifies': true
+  },
+  'params': [{
+    'name': 'projection',
+    'type': 'projection',
+    'required': true
+  }, {
+    'name': 'fields',
+    'type': 'field',
+    'array': true,
+    'required': true,
+    'length': 2
+  }, {
+    'name': 'as',
+    'type': 'string',
+    'array': true,
+    'length': 2,
+    'default': ['x', 'y']
+  }]
+};
+vegaUtil.inherits(GeoPoint, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    var proj = _.projection,
+      lon = _.fields[0],
+      lat = _.fields[1],
+      as = _.as || ['x', 'y'],
+      x = as[0],
+      y = as[1],
+      mod;
+    function set(t) {
+      const xy = proj([lon(t), lat(t)]);
+      if (xy) {
+        t[x] = xy[0];
+        t[y] = xy[1];
+      } else {
+        t[x] = undefined;
+        t[y] = undefined;
+      }
+    }
+    if (_.modified()) {
+      // parameters updated, reflow
+      pulse = pulse.materialize().reflow(true).visit(pulse.SOURCE, set);
+    } else {
+      mod = pulse.modified(lon.fields) || pulse.modified(lat.fields);
+      pulse.visit(mod ? pulse.ADD_MOD : pulse.ADD, set);
+    }
+    return pulse.modifies(as);
+  }
+});
+
+/**
+ * Annotate items with a geopath shape generator.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {function(number, number): *} params.projection - The cartographic
+ *   projection to apply.
+ * @param {function(object): *} [params.field] - The field with GeoJSON data,
+ *   or null if the tuple itself is a GeoJSON feature.
+ * @param {string} [params.as='shape'] - The output field in which to store
+ *   the generated path data (default 'shape').
+ */
+function GeoShape(params) {
+  vegaDataflow.Transform.call(this, null, params);
+}
+GeoShape.Definition = {
+  'type': 'GeoShape',
+  'metadata': {
+    'modifies': true,
+    'nomod': true
+  },
+  'params': [{
+    'name': 'projection',
+    'type': 'projection'
+  }, {
+    'name': 'field',
+    'type': 'field',
+    'default': 'datum'
+  }, {
+    'name': 'pointRadius',
+    'type': 'number',
+    'expr': true
+  }, {
+    'name': 'as',
+    'type': 'string',
+    'default': 'shape'
+  }]
+};
+vegaUtil.inherits(GeoShape, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    var out = pulse.fork(pulse.ALL),
+      shape = this.value,
+      as = _.as || 'shape',
+      flag = out.ADD;
+    if (!shape || _.modified()) {
+      // parameters updated, reset and reflow
+      this.value = shape = shapeGenerator(vegaProjection.getProjectionPath(_.projection), _.field || vegaUtil.field('datum'), _.pointRadius);
+      out.materialize().reflow();
+      flag = out.SOURCE;
+    }
+    out.visit(flag, t => t[as] = shape);
+    return out.modifies(as);
+  }
+});
+function shapeGenerator(path, field, pointRadius) {
+  const shape = pointRadius == null ? _ => path(field(_)) : _ => {
+    var prev = path.pointRadius(),
+      value = path.pointRadius(pointRadius)(field(_));
+    path.pointRadius(prev);
+    return value;
+  };
+  shape.context = _ => {
+    path.context(_);
+    return shape;
+  };
+  return shape;
+}
+
+/**
+ * GeoJSON feature generator for creating graticules.
+ * @constructor
+ */
+function Graticule(params) {
+  vegaDataflow.Transform.call(this, [], params);
+  this.generator = graticule.default();
+}
+Graticule.Definition = {
+  'type': 'Graticule',
+  'metadata': {
+    'changes': true,
+    'generates': true
+  },
+  'params': [{
+    'name': 'extent',
+    'type': 'array',
+    'array': true,
+    'length': 2,
+    'content': {
+      'type': 'number',
+      'array': true,
+      'length': 2
+    }
+  }, {
+    'name': 'extentMajor',
+    'type': 'array',
+    'array': true,
+    'length': 2,
+    'content': {
+      'type': 'number',
+      'array': true,
+      'length': 2
+    }
+  }, {
+    'name': 'extentMinor',
+    'type': 'array',
+    'array': true,
+    'length': 2,
+    'content': {
+      'type': 'number',
+      'array': true,
+      'length': 2
+    }
+  }, {
+    'name': 'step',
+    'type': 'number',
+    'array': true,
+    'length': 2
+  }, {
+    'name': 'stepMajor',
+    'type': 'number',
+    'array': true,
+    'length': 2,
+    'default': [90, 360]
+  }, {
+    'name': 'stepMinor',
+    'type': 'number',
+    'array': true,
+    'length': 2,
+    'default': [10, 10]
+  }, {
+    'name': 'precision',
+    'type': 'number',
+    'default': 2.5
+  }]
+};
+vegaUtil.inherits(Graticule, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    var src = this.value,
+      gen = this.generator,
+      t;
+    if (!src.length || _.modified()) {
+      for (const prop in _) {
+        if (vegaUtil.isFunction(gen[prop])) {
+          gen[prop](_[prop]);
+        }
+      }
+    }
+    t = gen();
+    if (src.length) {
+      pulse.mod.push(vegaDataflow.replace(src[0], t));
+    } else {
+      pulse.add.push(vegaDataflow.ingest(t));
+    }
+    src[0] = t;
+    return pulse;
+  }
+});
+
+/**
+ * Render a heatmap image for input raster grid data.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {function(object): *} [params.field] - The field with raster grid
+ *   data. If unspecified, the tuple itself is interpreted as a raster grid.
+ * @param {string} [params.color] - A constant color value or function for
+ *   individual pixel color. If a function, it will be invoked with an input
+ *   object that includes $x, $y, $value, and $max fields for the grid.
+ * @param {number} [params.opacity] - A constant opacity value or function for
+ *   individual pixel opacity. If a function, it will be invoked with an input
+ *   object that includes $x, $y, $value, and $max fields for the grid.
+ * @param {string} [params.resolve] - The method for resolving maximum values
+ *   across multiple input grids. If 'independent' (the default), maximum
+ *   calculation will be performed separately for each grid. If 'shared',
+ *   a single global maximum will be used for all input grids.
+ * @param {string} [params.as='image'] - The output field in which to store
+ *   the generated bitmap canvas images (default 'image').
+ */
+function Heatmap(params) {
+  vegaDataflow.Transform.call(this, null, params);
+}
+Heatmap.Definition = {
+  'type': 'heatmap',
+  'metadata': {
+    'modifies': true
+  },
+  'params': [{
+    'name': 'field',
+    'type': 'field'
+  }, {
+    'name': 'color',
+    'type': 'string',
+    'expr': true
+  }, {
+    'name': 'opacity',
+    'type': 'number',
+    'expr': true
+  }, {
+    'name': 'resolve',
+    'type': 'enum',
+    'values': ['shared', 'independent'],
+    'default': 'independent'
+  }, {
+    'name': 'as',
+    'type': 'string',
+    'default': 'image'
+  }]
+};
+vegaUtil.inherits(Heatmap, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    if (!pulse.changed() && !_.modified()) {
+      return pulse.StopPropagation;
+    }
+    var source = pulse.materialize(pulse.SOURCE).source,
+      shared = _.resolve === 'shared',
+      field = _.field || vegaUtil.identity,
+      opacity = opacity_(_.opacity, _),
+      color = color_(_.color, _),
+      as = _.as || 'image',
+      obj = {
+        $x: 0,
+        $y: 0,
+        $value: 0,
+        $max: shared ? max.default(source.map(t => max.default(field(t).values))) : 0
+      };
+    source.forEach(t => {
+      const v = field(t);
+
+      // build proxy data object
+      const o = vegaUtil.extend({}, t, obj);
+      // set maximum value if not globally shared
+      if (!shared) o.$max = max.default(v.values || []);
+
+      // generate canvas image
+      // optimize color/opacity if not pixel-dependent
+      t[as] = toCanvas(v, o, color.dep ? color : vegaUtil.constant(color(o)), opacity.dep ? opacity : vegaUtil.constant(opacity(o)));
+    });
+    return pulse.reflow(true).modifies(as);
+  }
+});
+
+// get image color function
+function color_(color$1, _) {
+  let f;
+  if (vegaUtil.isFunction(color$1)) {
+    f = obj => color.rgb(color$1(obj, _));
+    f.dep = dependency(color$1);
+  } else {
+    // default to mid-grey
+    f = vegaUtil.constant(color.rgb(color$1 || '#888'));
+  }
+  return f;
+}
+
+// get image opacity function
+function opacity_(opacity, _) {
+  let f;
+  if (vegaUtil.isFunction(opacity)) {
+    f = obj => opacity(obj, _);
+    f.dep = dependency(opacity);
+  } else if (opacity) {
+    f = vegaUtil.constant(opacity);
+  } else {
+    // default to [0, max] opacity gradient
+    f = obj => obj.$value / obj.$max || 0;
+    f.dep = true;
+  }
+  return f;
+}
+
+// check if function depends on individual pixel data
+function dependency(f) {
+  if (!vegaUtil.isFunction(f)) return false;
+  const set = vegaUtil.toSet(vegaUtil.accessorFields(f));
+  return set.$x || set.$y || set.$value || set.$max;
+}
+
+// render raster grid to canvas
+function toCanvas(grid, obj, color, opacity) {
+  const n = grid.width,
+    m = grid.height,
+    x1 = grid.x1 || 0,
+    y1 = grid.y1 || 0,
+    x2 = grid.x2 || n,
+    y2 = grid.y2 || m,
+    val = grid.values,
+    value = val ? i => val[i] : vegaUtil.zero,
+    can = vegaCanvas_browser.canvas(x2 - x1, y2 - y1),
+    ctx = can.getContext('2d'),
+    img = ctx.getImageData(0, 0, x2 - x1, y2 - y1),
+    pix = img.data;
+  for (let j = y1, k = 0; j < y2; ++j) {
+    obj.$y = j - y1;
+    for (let i = x1, r = j * n; i < x2; ++i, k += 4) {
+      obj.$x = i - x1;
+      obj.$value = value(i + r);
+      const v = color(obj);
+      pix[k + 0] = v.r;
+      pix[k + 1] = v.g;
+      pix[k + 2] = v.b;
+      pix[k + 3] = ~~(255 * opacity(obj));
+    }
+  }
+  ctx.putImageData(img, 0, 0);
+  return can;
+}
+
+/**
+ * Maintains a cartographic projection.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ */
+function Projection(params) {
+  vegaDataflow.Transform.call(this, null, params);
+  this.modified(true); // always treat as modified
+}
+vegaUtil.inherits(Projection, vegaDataflow.Transform, {
+  transform(_, pulse) {
+    let proj = this.value;
+    if (!proj || _.modified('type')) {
+      this.value = proj = create(_.type);
+      vegaProjection.projectionProperties.forEach(prop => {
+        if (_[prop] != null) set(proj, prop, _[prop]);
+      });
+    } else {
+      vegaProjection.projectionProperties.forEach(prop => {
+        if (_.modified(prop)) set(proj, prop, _[prop]);
+      });
+    }
+    if (_.pointRadius != null) proj.path.pointRadius(_.pointRadius);
+    if (_.fit) fit(proj, _);
+    return pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS);
+  }
+});
+function fit(proj, _) {
+  const data = collectGeoJSON(_.fit);
+  _.extent ? proj.fitExtent(_.extent, data) : _.size ? proj.fitSize(_.size, data) : 0;
+}
+function create(type) {
+  const constructor = vegaProjection.projection((type || 'mercator').toLowerCase());
+  if (!constructor) vegaUtil.error('Unrecognized projection type: ' + type);
+  return constructor();
+}
+function set(proj, key, value) {
+  if (vegaUtil.isFunction(proj[key])) proj[key](value);
+}
+function collectGeoJSON(data) {
+  data = vegaUtil.array(data);
+  return data.length === 1 ? data[0] : {
+    type: FeatureCollection,
+    features: data.reduce((a, f) => a.concat(featurize(f)), [])
+  };
+}
+function featurize(f) {
+  return f.type === FeatureCollection ? f.features : vegaUtil.array(f).filter(d => d != null).map(d => d.type === Feature ? d : {
+    type: Feature,
+    geometry: d
+  });
+}
+
+exports.contour = Contour;
+exports.geojson = GeoJSON;
+exports.geopath = GeoPath;
+exports.geopoint = GeoPoint;
+exports.geoshape = GeoShape;
+exports.graticule = Graticule;
+exports.heatmap = Heatmap;
+exports.isocontour = Isocontour;
+exports.kde2d = KDE2D;
+exports.projection = Projection;