@uwdata/mosaic-plot 0.5.0 → 0.6.1

package/src/marks/util/density.js

@@ -96,7 +96,7 @@ 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 h = new Float64Array(5); // q + 1
   const d = new Float64Array(grid.length);
 
   // convolve rows
@@ -119,7 +119,7 @@ export function dericheConv1d(
   stride = 1,
   y_causal = new Float64Array(N),
   y_anticausal = new Float64Array(N),
-  h = new Float64Array(5),
+  h = new Float64Array(5), // q + 1
   d = y_causal,
   init = dericheInitZeroPad
 ) {
@@ -153,6 +153,7 @@ export function dericheConv1d(
   }
 
   // initialize the anticausal filter on the right boundary
+  // dest, src, N, stride, b, p, a, q, sum, h
   init(
     y_anticausal, src, N, -stride,
     c.b_anticausal, 4, c.a, 4, c.sum_anticausal, h, c.sigma
@@ -176,7 +177,7 @@ export function dericheConv1d(
 
   // 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
+    // do not threshold if the input grid includes negative values
     for (n = 0, i = 0; n < N; ++n, i += stride) {
       d[i] = y_causal[n] + y_anticausal[N - n - 1];
     }
@@ -190,13 +191,16 @@ export function dericheConv1d(
   return d;
 }
 
-export function dericheInitZeroPad(dest, src, N, stride, b, p, a, q, sum, h) {
+export function dericheInitZeroPad(
+  dest, src, N, stride, b, p, a, q,
+  sum, h, sigma, tol = 0.5
+) {
   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) {
+  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];
@@ -214,12 +218,27 @@ export function dericheInitZeroPad(dest, src, N, stride, b, p, a, q, sum, h) {
     }
   }
 
-  // dest_m = dest_m + h_{n+m} src_{-n}
   const cur = src[off];
-  if (cur > 0) {
+  const max_iter = Math.ceil(sigma * 10);
+  for (n = 0; n < max_iter; ++n) {
+    /* dest_m = dest_m + h_{n+m} src_{-n} */
     for (m = 0; m < q; ++m) {
       dest[m] += h[m] * cur;
     }
+
+    sum -= Math.abs(h[0]);
+    if (sum <= tol) break;
+
+    /* Compute the next impulse response tap, h_{n+q} */
+    h[q] = (n + q <= p) ? b[n + q] : 0;
+    for (m = 1; m <= q; ++m) {
+      h[q] -= a[m] * h[q - m];
+    }
+
+    /* Shift the h array for the next iteration */
+    for (m = 0; m < q; ++m) {
+      h[m] = h[m + 1];
+    }
   }
 
   return;

package/src/marks/util/grid.js

@@ -1,57 +1,122 @@
-import { isArrowTable } from './is-arrow-table.js';
+import { InternSet, ascending } from 'd3';
+import { convertArrowColumn, convertArrowType, isArrowTable } from './arrow.js';
 
-export function grid1d(n, values) {
-  return valuesToGrid(new Float64Array(n), values);
+function arrayType(values, name = 'density') {
+  if (isArrowTable(values)) {
+    return convertArrowType(values.getChild(name).type);
+  } else {
+    return typeof values[0][name] === 'number' ? Float64Array : Array;
+  }
 }
 
-export function grid2d(m, n, values, groupby = []) {
-  return groupby.length
-    ? Object.values(groupedValuesToGrids(m * n, values, groupby))
-    : [{ grid: valuesToGrid(new Float64Array(m * n), values) }];
+export function grid1d(n, values) {
+  const Type = arrayType(values);
+  return valuesToGrid(new Type(n), values);
 }
 
-function valuesToGrid(grid, values) {
+function valuesToGrid(grid, values, name = 'density') {
   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();
+    const index = convertArrowColumn(values.getChild('index'));
+    const value = convertArrowColumn(values.getChild(name));
     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;
+      grid[row.index] = row[name];
     }
   }
   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;
+export function grid2d(w, h, values, aggr, groupby = [], interpolate) {
+  const size = w * h;
+  const Types = aggr.map(name => arrayType(values, name));
+  const numAggr = aggr.length;
+
+  // grid data tuples
+  const createCell = (key) => {
+    const cell = {};
+    groupby.forEach((name, i) => cell[name] = key[i]);
+    aggr.forEach((name, i) => cell[name] = new Types[i](size));
+    return cell;
   };
-  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));
+  const cellMap = {};
+  const baseCell = groupby.length ? null : (cellMap[[]] = createCell([]));
+  const getCell = groupby.length
+    ? key => cellMap[key] ?? (cellMap[key] = createCell(key))
+    : () => baseCell;
+
+  // early exit if empty query result
+  const numRows = values.numRows;
+  if (numRows === 0) return Object.values(cellMap);
+
+  // extract arrays from arrow table
+  const index = convertArrowColumn(values.getChild('index'));
+  const value = aggr.map(name => convertArrowColumn(values.getChild(name)));
+  const groups = groupby.map(name => values.getChild(name));
+
+  if (!interpolate) {
+    // if no interpolation, copy values over
     for (let row = 0; row < numRows; ++row) {
       const key = groups.map(vec => vec.get(row));
-      getGrid(key)[index[row]] = value[row];
+      const cell = getCell(key);
+      for (let i = 0; i < numAggr; ++i) {
+        cell[aggr[i]][index[row]] = value[i][row];
+      }
     }
   } else {
-    // fallback to iterable data
-    for (const row of values) {
-      const key = groupby.map(col => row[col]);
-      getGrid(key)[row.index] = row.value;
+    // prepare index arrays, then interpolate grid values
+    const X = index.map(k => k % w);
+    const Y = index.map(k => Math.floor(k / w));
+    if (groupby.length) {
+      for (let row = 0; row < numRows; ++row) {
+        const key = groups.map(vec => vec.get(row));
+        const cell = getCell(key);
+        if (!cell.index) { cell.index = []; }
+        cell.index.push(row);
+      }
+    } else {
+      baseCell.index = index.map((_, i) => i);
     }
+    Object.values(cellMap).forEach(cell => {
+      for (let i = 0; i < numAggr; ++i) {
+        interpolate(cell.index, w, h, X, Y, value[i], cell[aggr[i]]);
+      }
+      delete cell.index;
+    })
   }
-  return grids;
+
+  return Object.values(cellMap);
+}
+
+export function gridDomainContinuous(grids, prop) {
+  let lo = 0, hi = 0;
+  grids.forEach(cell => {
+    const grid = cell[prop];
+    const n = grid.length;
+    for (let i = 0; i < n; ++i) {
+      const v = grid[i];
+      if (v < lo) lo = v;
+      if (v > hi) hi = v;
+    }
+  });
+  return (lo === 0 && hi === 0) ? [0, 1] : [lo, hi];
+}
+
+export function gridDomainDiscrete(grids, prop) {
+    // TODO: sort options?
+  const values = new InternSet();
+  grids.forEach(cell => {
+    const grid = cell[prop];
+    const n = grid.length;
+    for (let i = 0; i < n; ++i) {
+      values.add(grid[i]);
+    }
+  });
+  return Array.from(values).sort(ascending);
 }

package/src/marks/util/interpolate.js

@@ -0,0 +1,196 @@
+import { Delaunay, randomLcg } from 'd3';
+
+export function interpolatorBarycentric({random = randomLcg(42)} = {}) {
+  return (index, width, height, X, Y, V, W) => {
+    // Interpolate the interior of all triangles with barycentric coordinates
+    const {points, triangles, hull} = Delaunay.from(index, (i) => X[i], (i) => Y[i]);
+    const S = new Uint8Array(width * height); // 1 if pixel has been seen.
+    const mix = mixer(V, random);
+
+    for (let i = 0; i < triangles.length; i += 3) {
+      const ta = triangles[i];
+      const tb = triangles[i + 1];
+      const tc = triangles[i + 2];
+      const Ax = points[2 * ta];
+      const Bx = points[2 * tb];
+      const Cx = points[2 * tc];
+      const Ay = points[2 * ta + 1];
+      const By = points[2 * tb + 1];
+      const Cy = points[2 * tc + 1];
+      const x1 = Math.min(Ax, Bx, Cx);
+      const x2 = Math.max(Ax, Bx, Cx);
+      const y1 = Math.min(Ay, By, Cy);
+      const y2 = Math.max(Ay, By, Cy);
+      const z = (By - Cy) * (Ax - Cx) + (Ay - Cy) * (Cx - Bx);
+      if (!z) continue;
+      const va = V[index[ta]];
+      const vb = V[index[tb]];
+      const vc = V[index[tc]];
+      for (let x = Math.floor(x1); x < x2; ++x) {
+        for (let y = Math.floor(y1); y < y2; ++y) {
+          if (x < 0 || x >= width || y < 0 || y >= height) continue;
+          const xp = x + 0.5; // sample pixel centroids
+          const yp = y + 0.5;
+          const ga = ((By - Cy) * (xp - Cx) + (yp - Cy) * (Cx - Bx)) / z;
+          if (ga < 0) continue;
+          const gb = ((Cy - Ay) * (xp - Cx) + (yp - Cy) * (Ax - Cx)) / z;
+          if (gb < 0) continue;
+          const gc = 1 - ga - gb;
+          if (gc < 0) continue;
+          const i = x + width * y;
+          W[i] = mix(va, ga, vb, gb, vc, gc, x, y);
+          S[i] = 1;
+        }
+      }
+    }
+    extrapolateBarycentric(W, S, X, Y, V, width, height, hull, index, mix);
+    return W;
+  };
+}
+
+// Extrapolate by finding the closest point on the hull.
+function extrapolateBarycentric(W, S, X, Y, V, width, height, hull, index, mix) {
+  X = Float64Array.from(hull, (i) => X[index[i]]);
+  Y = Float64Array.from(hull, (i) => Y[index[i]]);
+  V = Array.from(hull, (i) => V[index[i]]);
+  const n = X.length;
+  const rays = Array.from({length: n}, (_, j) => ray(j, X, Y));
+  let k = 0;
+  for (let y = 0; y < height; ++y) {
+    const yp = y + 0.5;
+    for (let x = 0; x < width; ++x) {
+      const i = x + width * y;
+      if (!S[i]) {
+        const xp = x + 0.5;
+        for (let l = 0; l < n; ++l) {
+          const j = (n + k + (l % 2 ? (l + 1) / 2 : -l / 2)) % n;
+          if (rays[j](xp, yp)) {
+            const t = segmentProject(X.at(j - 1), Y.at(j - 1), X[j], Y[j], xp, yp);
+            W[i] = mix(V.at(j - 1), t, V[j], 1 - t, V[j], 0, x, y);
+            k = j;
+            break;
+          }
+        }
+      }
+    }
+  }
+}
+
+// Projects a point p = [x, y] onto the line segment [p1, p2], returning the
+// projected coordinates p’ as t in [0, 1] with p’ = t p1 + (1 - t) p2.
+function segmentProject(x1, y1, x2, y2, x, y) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const a = dx * (x2 - x) + dy * (y2 - y);
+  const b = dx * (x - x1) + dy * (y - y1);
+  return a > 0 && b > 0 ? a / (a + b) : +(a > b);
+}
+
+function cross(xa, ya, xb, yb) {
+  return xa * yb - xb * ya;
+}
+
+function ray(j, X, Y) {
+  const n = X.length;
+  const xc = X.at(j - 2);
+  const yc = Y.at(j - 2);
+  const xa = X.at(j - 1);
+  const ya = Y.at(j - 1);
+  const xb = X[j];
+  const yb = Y[j];
+  const xd = X.at(j + 1 - n);
+  const yd = Y.at(j + 1 - n);
+  const dxab = xa - xb;
+  const dyab = ya - yb;
+  const dxca = xc - xa;
+  const dyca = yc - ya;
+  const dxbd = xb - xd;
+  const dybd = yb - yd;
+  const hab = Math.hypot(dxab, dyab);
+  const hca = Math.hypot(dxca, dyca);
+  const hbd = Math.hypot(dxbd, dybd);
+  return (x, y) => {
+    const dxa = x - xa;
+    const dya = y - ya;
+    const dxb = x - xb;
+    const dyb = y - yb;
+    return (
+      cross(dxa, dya, dxb, dyb) > -1e-6 &&
+      cross(dxa, dya, dxab, dyab) * hca - cross(dxa, dya, dxca, dyca) * hab > -1e-6 &&
+      cross(dxb, dyb, dxbd, dybd) * hab - cross(dxb, dyb, dxab, dyab) * hbd <= 0
+    );
+  };
+}
+
+export function interpolateNearest(index, width, height, X, Y, V, W) {
+  const delaunay = Delaunay.from(index, (i) => X[i], (i) => Y[i]);
+  // memoization of delaunay.find for the line start (iy) and pixel (ix)
+  let iy, ix;
+  for (let y = 0.5, k = 0; y < height; ++y) {
+    ix = iy;
+    for (let x = 0.5; x < width; ++x, ++k) {
+      ix = delaunay.find(x, y, ix);
+      if (x === 0.5) iy = ix;
+      W[k] = V[index[ix]];
+    }
+  }
+  return W;
+}
+
+// https://observablehq.com/@observablehq/walk-on-spheres-precision
+export function interpolatorRandomWalk({random = randomLcg(42), minDistance = 0.5, maxSteps = 2} = {}) {
+  return (index, width, height, X, Y, V, W) => {
+    const delaunay = Delaunay.from(index, (i) => X[i], (i) => Y[i]);
+    // memoization of delaunay.find for the line start (iy), pixel (ix), and wos step (iw)
+    let iy, ix, iw;
+    for (let y = 0.5, k = 0; y < height; ++y) {
+      ix = iy;
+      for (let x = 0.5; x < width; ++x, ++k) {
+        let cx = x;
+        let cy = y;
+        iw = ix = delaunay.find(cx, cy, ix);
+        if (x === 0.5) iy = ix;
+        let distance; // distance to closest sample
+        let step = 0; // count of steps for this walk
+        while ((distance = Math.hypot(X[index[iw]] - cx, Y[index[iw]] - cy)) > minDistance && step < maxSteps) {
+          const angle = random(x, y, step) * 2 * Math.PI;
+          cx += Math.cos(angle) * distance;
+          cy += Math.sin(angle) * distance;
+          iw = delaunay.find(cx, cy, iw);
+          ++step;
+        }
+        W[k] = V[index[iw]];
+      }
+    }
+    return W;
+  };
+}
+
+function blend(a, ca, b, cb, c, cc) {
+  return ca * a + cb * b + cc * c;
+}
+
+function pick(random) {
+  return (a, ca, b, cb, c, cc, x, y) => {
+    const u = random(x, y);
+    return u < ca ? a : u < ca + cb ? b : c;
+  };
+}
+
+function mixer(F, random) {
+  return isNumeric(F) || isTemporal(F) ? blend : pick(random);
+}
+
+function isNumeric(values) {
+  for (const value of values) {
+    if (value == null) continue;
+    return typeof value === "number";
+  }
+}
+
+function isTemporal(values) {
+  for (const value of values) {
+    if (value == null) continue;
+    return value instanceof Date;
+  }
+}

package/src/marks/util/raster.js

@@ -1,44 +1,131 @@
 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 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 palette(size, interp) {
-  const p = new Uint8ClampedArray(4 * size);
-  const n = size - 1;
+export function alphaConstant(v = 1) {
+  const a = (255 * v) | 0;
+
+  // rasterize
+  return (data, w, h) => {
+    for (let j = 0, k = 0; j < h; ++j) {
+      for (let i = 0; i < w; ++i, k += 4) {
+        data[k + 3] = a;
+      }
+    }
+  };
+}
+
+export function alphaScheme(scale) {
+  const { apply } = scale;
+
+  // rasterize
+  return (data, w, h, grid) => {
+    for (let j = 0, k = 0; j < h; ++j) {
+      for (let i = 0, row = (h - j - 1) * w; i < w; ++i, k += 4) {
+        data[k + 3] = (255 * apply(grid[i + row])) | 0;
+      }
+    }
+  };
+}
+
+export function colorConstant(v = {}) {
+  const { r = 0, g = 0, b = 0, opacity = 1 } = typeof v === 'string' ? rgb(v) : v;
+  const c = new Uint8ClampedArray([r, g, b, (255 * opacity) | 0]);
+
+  // rasterize
+  return (data, w, h) => {
+    for (let j = 0, k = 0; j < h; ++j) {
+      for (let i = 0; i < w; ++i, k += 4) {
+        data[k + 0] = c[0];
+        data[k + 1] = c[1];
+        data[k + 2] = c[2];
+        data[k + 3] = c[3];
+      }
+    }
+  };
+}
+
+export function colorCategory(scale) {
+  const { domain, range } = scale;
+  const idx = Object.create(null);
+  const p = new Uint8ClampedArray(4 * domain.length);
+  const n = domain.length - 1;
+  const m = range.length;
+
+  // build palette and index lookup map
   for (let i = 0; i <= n; ++i) {
-    const v = interp(i / n);
+    const v = range[i % m];
     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;
+    idx[domain[i]] = k;
   }
-  return p;
+
+  // rasterize
+  return (data, w, h, grid) => {
+    if (grid.map) {
+      // categorical values in grid
+      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 = idx[grid[i + row]];
+          data[k + 0] = p[c + 0];
+          data[k + 1] = p[c + 1];
+          data[k + 2] = p[c + 2];
+          data[k + 3] = p[c + 3];
+        }
+      }
+    } else {
+      // categorical value for group
+      const c = idx[grid];
+      for (let j = 0, k = 0; j < h; ++j) {
+        for (let i = 0; i < w; ++i, k += 4) {
+          data[k + 0] = p[c + 0];
+          data[k + 1] = p[c + 1];
+          data[k + 2] = p[c + 2];
+          data[k + 3] = p[c + 3];
+        }
+      }
+    }
+  };
 }
 
-export function createCanvas(w, h) {
-  if (typeof document !== 'undefined') {
-    const c = document.createElement('canvas');
-    c.setAttribute('width', w);
-    c.setAttribute('height', h);
-    return c;
+export function colorScheme(size, scale, frac) {
+  const { interpolate } = scale;
+  const p = new Uint8ClampedArray(4 * size);
+  const n = size - 1;
+
+  // build palette
+  for (let i = 0; i <= n; ++i) {
+    const v = interpolate(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;
   }
-  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 });
+  // rasterize
+  return (data, w, h, grid) => {
+    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 * frac(grid[i + row])) << 2;
+        data[k + 0] = p[c + 0];
+        data[k + 1] = p[c + 1];
+        data[k + 2] = p[c + 2];
+        data[k + 3] = p[c + 3];
+      }
+    }
+  };
 }

package/src/marks/util/to-data-array.js

@@ -1,7 +1,4 @@
-import { isArrowTable } from './is-arrow-table.js';
-
-const INTEGER = 2;
-const TIMESTAMP = 10;
+import { convertArrow, isArrowTable } from './arrow.js';
 
 export function toDataArray(data) {
   return isArrowTable(data) ? arrowToObjects(data) : data;
@@ -37,7 +34,7 @@ export function arrowToObjects(data) {
     for (let j = 0; j < numCols; ++j) {
       const child = batch.getChildAt(j);
       const { name, type } = schema.fields[j];
-      const valueOf = convert(type);
+      const valueOf = convertArrow(type);
 
       // for each row in the current batch...
       for (let o = k, i = 0; i < numRows; ++i, ++o) {
@@ -51,20 +48,3 @@ export function arrowToObjects(data) {
 
   return objects;
 }
-
-function convert(type) {
-  const { typeId } = type;
-
-  // map timestamp numbers to date objects
-  if (typeId === TIMESTAMP) {
-    return v => v == null ? v : new Date(v);
-  }
-
-  // map bignum to number
-  if (typeId === INTEGER && type.bitWidth >= 64) {
-    return v => v == null ? v : Number(v);
-  }
-
-  // otherwise use Arrow JS defaults
-  return v => v;
-}

package/src/plot-attributes.js

@@ -45,6 +45,9 @@ export const attributeMap = new Map([
   ['xAriaDescription', 'x.ariaDescription'],
   ['xReverse', 'x.reverse'],
   ['xZero', 'x.zero'],
+  ['xBase', 'x.base'],
+  ['xExponent', 'x.exponent'],
+  ['xConstant', 'x.constant'],
   ['yScale', 'y.type'],
   ['yDomain', 'y.domain'],
   ['yRange', 'y.range'],
@@ -75,6 +78,9 @@ export const attributeMap = new Map([
   ['yAriaDescription', 'y.ariaDescription'],
   ['yReverse', 'y.reverse'],
   ['yZero', 'y.zero'],
+  ['yBase', 'y.base'],
+  ['yExponent', 'y.exponent'],
+  ['yConstant', 'y.constant'],
   ['facetMargin', 'facet.margin'],
   ['facetMarginTop', 'facet.marginTop'],
   ['facetMarginBottom', 'facet.marginBottom'],
@@ -150,6 +156,9 @@ export const attributeMap = new Map([
   ['colorReverse', 'color.reverse'],
   ['colorZero', 'color.zero'],
   ['colorTickFormat', 'color.tickFormat'],
+  ['colorBase', 'color.base'],
+  ['colorExponent', 'color.exponent'],
+  ['colorConstant', 'color.constant'],
   ['opacityScale', 'opacity.type'],
   ['opacityDomain', 'opacity.domain'],
   ['opacityRange', 'opacity.range'],
@@ -159,18 +168,27 @@ export const attributeMap = new Map([
   ['opacityReverse', 'opacity.reverse'],
   ['opacityZero', 'opacity.zero'],
   ['opacityTickFormat', 'opacity.tickFormat'],
+  ['opacityBase', 'opacity.base'],
+  ['opacityExponent', 'opacity.exponent'],
+  ['opacityConstant', 'opacity.constant'],
   ['rScale', 'r.type'],
   ['rDomain', 'r.domain'],
   ['rRange', 'r.range'],
   ['rClamp', 'r.clamp'],
   ['rNice', 'r.nice'],
   ['rZero', 'r.zero'],
+  ['rBase', 'r.base'],
+  ['rExponent', 'r.exponent'],
+  ['rConstant', 'r.constant'],
   ['lengthScale', 'length.type'],
   ['lengthDomain', 'length.domain'],
   ['lengthRange', 'length.range'],
   ['lengthClamp', 'length.clamp'],
   ['lengthNice', 'length.nice'],
   ['lengthZero', 'length.zero'],
+  ['lengthBase', 'length.base'],
+  ['lengthExponent', 'length.exponent'],
+  ['lengthConstant', 'length.constant'],
   ['projectionType', 'projection.type'],
   ['projectionParallels', 'projection.parallels'],
   ['projectionPrecision', 'projection.precision'],