projection + hexbin

Author: mbostock

src/channel.js

@@ -26,15 +26,28 @@ export function Channels(descriptors, data) {
 
 // TODO Use Float64Array for scales with numeric ranges, e.g. position?
 export function valueObject(channels, scales, {projection}) {
+  let scaledX, scaledY;
+
   const values = Object.fromEntries(
     Object.entries(channels).map(([name, {scale: scaleName, value}]) => {
-      const scale = scales[scaleName];
+      let scale;
+      if (scaleName !== undefined) {
+        if (name === "x") scaledX = true;
+        else if (name === "y") scaledY = true;
+        scale = scales[scaleName];
+      }
       return [name, scale === undefined ? value : map(value, scale)];
     })
   );
-  if (projection) {
+
+  // If there is a projection, and there are both x and y channels, and those x
+  // and y channels are associated with a scale (presumably the x and y scale)
+  // rather than being in screen coordinates (as with an initializer), then
+  // apply the projection, replacing the x and y values.
+  if (projection && scaledX && scaledY) {
     applyProjection(values, projection);
   }
+
   return values;
 }
 

src/plot.js

@@ -134,8 +134,17 @@ export function plot(options = {}) {
   const newByScale = new Set();
   for (const [mark, state] of stateByMark) {
     if (mark.initializer != null) {
-      const {facets, channels} = mark.initializer(state.data, state.facets, state.channels, scales, subdimensions);
-      if (facets !== undefined) state.facets = facets;
+      const {facets, channels} = mark.initializer(
+        state.data,
+        state.facets,
+        state.channels,
+        scales,
+        subdimensions,
+        context
+      );
+      if (facets !== undefined) {
+        state.facets = facets;
+      }
       if (channels !== undefined) {
         inferChannelScale(channels, mark);
         applyScaleTransforms(channels, options);

src/projection.js

@@ -73,14 +73,12 @@ export function maybeProjection(projection, dimensions) {
 
 export function applyProjection(values, projection) {
   const {x, y} = values;
-  if (x && y) {
-    const n = x.length;
-    const X = (values.x = new Float64Array(n));
-    const Y = (values.y = new Float64Array(n));
-    for (let i = 0; i < n; ++i) {
-      const p = projection([x[i], y[i]]);
-      if (p) (X[i] = p[0]), (Y[i] = p[1]);
-      else X[i] = Y[i] = NaN;
-    }
+  const n = x.length;
+  const X = (values.x = new Float64Array(n));
+  const Y = (values.y = new Float64Array(n));
+  for (let i = 0; i < n; ++i) {
+    const p = projection([x[i], y[i]]);
+    if (p) (X[i] = p[0]), (Y[i] = p[1]);
+    else X[i] = Y[i] = NaN;
   }
 }

src/transforms/basic.js

@@ -51,10 +51,10 @@ function composeTransform(t1, t2) {
 function composeInitializer(i1, i2) {
   if (i1 == null) return i2 === null ? undefined : i2;
   if (i2 == null) return i1 === null ? undefined : i1;
-  return function (data, facets, channels, scales, dimensions) {
+  return function (data, facets, channels, ...args) {
     let c1, d1, f1, c2, d2, f2;
-    ({data: d1 = data, facets: f1 = facets, channels: c1} = i1.call(this, data, facets, channels, scales, dimensions));
-    ({data: d2 = d1, facets: f2 = f1, channels: c2} = i2.call(this, d1, f1, {...channels, ...c1}, scales, dimensions));
+    ({data: d1 = data, facets: f1 = facets, channels: c1} = i1.call(this, data, facets, channels, ...args));
+    ({data: d2 = d1, facets: f2 = f1, channels: c2} = i2.call(this, d1, f1, {...channels, ...c1}, ...args));
     return {data: d2, facets: f2, channels: {...c1, ...c2}};
   };
 }

src/transforms/hexbin.js

@@ -1,6 +1,7 @@
+import {valueObject} from "../channel.js";
 import {coerceNumbers} from "../scales.js";
 import {sqrt3} from "../symbols.js";
-import {identity, isNoneish, number, valueof} from "../options.js";
+import {isNoneish, number, valueof} from "../options.js";
 import {initializer} from "./basic.js";
 import {hasOutput, maybeGroup, maybeOutputs, maybeSubgroup} from "./group.js";
 
@@ -13,32 +14,34 @@ export const ox = 0.5,
   oy = 0;
 
 /** @jsdoc hexbin */
-export function hexbin(outputs = {fill: "count"}, options = {}) {
+export function hexbin(outputs = {fill: "count"}, {binWidth, ...options} = {}) {
   // TODO filter e.g. to show empty hexbins?
   // TODO disallow x, x1, x2, y, y1, y2 reducers?
-  let {binWidth, ...remainingOptions} = options;
   binWidth = binWidth === undefined ? 20 : number(binWidth);
-  outputs = maybeOutputs(outputs, remainingOptions);
+  outputs = maybeOutputs(outputs, options);
 
   // A fill output means a fill channel, and hence the stroke should default to
   // none (assuming a mark that defaults to fill and no stroke, such as dot).
   // Note that it’s safe to mutate options here because we just created it with
   // the rest operator above.
-  const {z, fill, stroke} = remainingOptions;
-  if (stroke === undefined && isNoneish(fill) && hasOutput(outputs, "fill")) remainingOptions.stroke = "none";
+  const {z, fill, stroke} = options;
+  if (stroke === undefined && isNoneish(fill) && hasOutput(outputs, "fill")) options.stroke = "none";
 
   // Populate default values for the r and symbol options, as appropriate.
-  if (remainingOptions.symbol === undefined) remainingOptions.symbol = "hexagon";
-  if (remainingOptions.r === undefined && !hasOutput(outputs, "r")) remainingOptions.r = binWidth / 2;
+  if (options.symbol === undefined) options.symbol = "hexagon";
+  if (options.r === undefined && !hasOutput(outputs, "r")) options.r = binWidth / 2;
 
-  return initializer(remainingOptions, (data, facets, {x: X, y: Y, z: Z, fill: F, stroke: S, symbol: Q}, scales) => {
+  return initializer(options, (data, facets, {x: X, y: Y, z: Z, fill: F, stroke: S, symbol: Q}, scales, _, context) => {
     if (X === undefined) throw new Error("missing channel: x");
     if (Y === undefined) throw new Error("missing channel: y");
 
-    // Coerce the X and Y channels to numbers (so that null is properly treated
-    // as an undefined value rather than being coerced to zero).
-    X = coerceNumbers(valueof(X.value, scales[X.scale] || identity));
-    Y = coerceNumbers(valueof(Y.value, scales[Y.scale] || identity));
+    // Extract the scaled (or projected!) values for the x and y channels.
+    ({x: X, y: Y} = valueObject({x: X, y: Y}, scales, context));
+
+    // Coerce the x and y channels to numbers (so that null is properly
+    // treated as an undefined value rather than being coerced to zero).
+    X = coerceNumbers(X);
+    Y = coerceNumbers(Y);
 
     // Extract the values for channels that are eligible for grouping; not all
     // marks define a z channel, so compute one if it not already computed. If z