The geometry channels accepts a channelSpec

src/marks/geo.d.ts

@@ -8,7 +8,7 @@ export interface GeoOptions extends MarkOptions {
    * A required channel for the geometry to render; defaults to identity,
    * assuming *data* is a GeoJSON object or an iterable of GeoJSON objects.
    */
-  geometry?: ChannelValue;
+  geometry?: ChannelValueSpec | {value: ChannelValue; scale?: null | boolean | "auto" | "projection"};
 
   /**
    * The size of Point and MultiPoint geometries, defaulting to a constant 3

src/marks/geo.js

@@ -21,18 +21,17 @@ export class Geo extends Mark {
     const [vr, cr] = maybeNumberChannel(options.r, 3);
     super(
       data,
-      {
-        geometry: {value: options.geometry, scale: "projection"},
-        r: {value: vr, scale: "r", filter: positive, optional: true}
-      },
+      {geometry: maybeGeometry(options.geometry), r: {value: vr, scale: "r", filter: positive, optional: true}},
       withDefaultSort(options),
       defaults
     );
     this.r = cr;
   }
   render(index, scales, channels, dimensions, context) {
     const {geometry: G, r: R} = channels;
-    const path = geoPath(context.projection ?? scaleProjection(scales));
+    const path = geoPath(
+      channels.channels.geometry.scale === "projection" ? context.projection ?? scaleProjection(scales) : null
+    );
     const {r} = this;
     if (negative(r)) index = [];
     else if (r !== undefined) path.pointRadius(r);
@@ -95,3 +94,19 @@ export function sphere({strokeWidth = 1.5, ...options} = {}) {
 export function graticule({strokeOpacity = 0.1, ...options} = {}) {
   return geo(geoGraticule10(), {strokeOpacity, ...options});
 }
+
+export function maybeGeometry(geometry) {
+  const {value, scale} = geometry?.value ? geometry : {value: geometry};
+  switch (scale) {
+    case false:
+    case null:
+      return {value, scale: null};
+    case undefined:
+    case true:
+    case "auto":
+    case "projection":
+      return {value, scale: "projection"};
+    default:
+      throw new Error(`invalid projection scale: ${scale}`);
+  }
+}

src/transforms/centroid.d.ts

@@ -1,13 +1,14 @@
-import type {ChannelTransform, ChannelValue} from "../channel.js";
+import type {ChannelTransform} from "../channel.js";
 import type {Initialized} from "./basic.js";
+import type {GeoOptions} from "../marks/geo.js";
 
 /** Options for the centroid and geoCentroid transforms. */
 export interface CentroidOptions {
   /**
    * A channel supplying GeoJSON geometry; defaults to the identity transform,
    * assuming that the data is GeoJSON geometry.
    */
-  geometry?: ChannelValue;
+  geometry?: GeoOptions["geometry"];
 }
 
 /**

src/transforms/centroid.js

@@ -1,15 +1,17 @@
 import {geoCentroid as GeoCentroid, geoPath} from "d3";
 import {identity, valueof} from "../options.js";
 import {initializer} from "./basic.js";
+import {maybeGeometry} from "../marks/geo.js";
 
 export function centroid({geometry = identity, ...options} = {}) {
   // Suppress defaults for x and y since they will be computed by the initializer.
   return initializer({...options, x: null, y: null}, (data, facets, channels, scales, dimensions, {projection}) => {
-    const G = valueof(data, geometry);
+    const {value, scale} = maybeGeometry(geometry);
+    const G = valueof(data, value);
     const n = G.length;
     const X = new Float64Array(n);
     const Y = new Float64Array(n);
-    const path = geoPath(projection);
+    const path = geoPath(scale === "projection" ? projection : null);
     for (let i = 0; i < n; ++i) [X[i], Y[i]] = path.centroid(G[i]);
     return {
       data,

test/plots/index.ts

@@ -306,6 +306,7 @@ export * from "./us-county-choropleth.js";
 export * from "./us-county-spikes.js";
 export * from "./us-population-state-age-dots.js";
 export * from "./us-population-state-age.js";
+export * from "./us-preprojected.js";
 export * from "./us-president-favorability-dots.js";
 export * from "./us-president-gallery.js";
 export * from "./us-presidential-election-2020.js";

test/plots/us-preprojected.ts

@@ -0,0 +1,22 @@
+import * as Plot from "@observablehq/plot";
+import * as d3 from "d3";
+import {feature, mesh} from "topojson-client";
+
+export async function usPreprojected() {
+  const [[pr_nation, {features: pr_counties}], statemesh] = await Promise.all([
+    d3
+      .json<any>("data/counties-albers-10m.json")
+      .then((us) => [feature(us, us.objects.nation), feature(us, us.objects.counties)]),
+    d3.json<any>("data/us-counties-10m.json").then((us) => mesh(us, us.objects.states))
+  ]);
+  return Plot.plot({
+    width: 975,
+    height: 610,
+    projection: "albers-usa",
+    marks: [
+      Plot.geo(pr_nation, {fill: "#dedede", geometry: {value: Plot.identity, scale: null}}),
+      Plot.geo(statemesh, {stroke: "#fff", geometry: {value: Plot.identity, scale: "projection"}}),
+      Plot.dot(pr_counties, Plot.centroid({geometry: {value: Plot.identity, scale: null}}))
+    ]
+  });
+}

test/scales/scales-test.js

@@ -2235,11 +2235,45 @@ it("mark(data, {channels}) respects a scale set to true or false", () => {
 
 it("mark(data, {channels}) rejects unknown scales", () => {
   assert.throws(
-    () => Plot.dot([], {channels: {fill: {value: (d) => d, scale: "neo"}}}).initialize().channels.fill.scale,
+    () => Plot.dot([], {channels: {fill: {value: (d) => d, scale: "neo"}}}).initialize(),
     /^Error: unknown scale: neo$/
   );
 });
 
+it("geo(data, {geometry: {scale}}) rejects invalid scales", () => {
+  assert.ok(Plot.geo([], {geometry: {value: Plot.identity, scale: "projection"}}));
+  assert.ok(Plot.geo([], {geometry: {value: Plot.identity, scale: "auto"}}));
+  assert.ok(Plot.geo([], {geometry: {value: Plot.identity, scale: true}}));
+  assert.ok(Plot.geo([], {geometry: {value: Plot.identity, scale: null}}));
+  assert.ok(Plot.geo([], {geometry: {value: Plot.identity}}));
+  assert.ok(Plot.geo([], {geometry: {value: Plot.identity, scale: false}}));
+  assert.throws(
+    () => Plot.geo([], {geometry: {value: Plot.identity, scale: "x"}}),
+    /^Error: invalid projection scale: x$/
+  );
+  assert.throws(
+    () => Plot.geo([], {geometry: {value: Plot.identity, scale: "neo"}}),
+    /^Error: invalid projection scale: neo$/
+  );
+});
+
+it("centroid(data, {geometry: {scale}}) rejects invalid scales", () => {
+  assert.ok(Plot.text([], Plot.centroid({geometry: {value: Plot.identity, scale: "projection"}})).plot());
+  assert.ok(Plot.text([], Plot.centroid({geometry: {value: Plot.identity, scale: "auto"}})).plot());
+  assert.ok(Plot.text([], Plot.centroid({geometry: {value: Plot.identity, scale: true}})).plot());
+  assert.ok(Plot.text([], Plot.centroid({geometry: {value: Plot.identity, scale: null}})).plot());
+  assert.ok(Plot.text([], Plot.centroid({geometry: {value: Plot.identity}})).plot());
+  assert.ok(Plot.text([], Plot.centroid({geometry: {value: Plot.identity, scale: false}})).plot());
+  assert.throws(
+    () => Plot.text([], Plot.centroid({geometry: {value: Plot.identity, scale: "x"}})).plot(),
+    /^Error: invalid projection scale: x$/
+  );
+  assert.throws(
+    () => Plot.text([], Plot.centroid({geometry: {value: Plot.identity, scale: "neo"}})).plot(),
+    /^Error: invalid projection scale: neo$/
+  );
+});
+
 // Given a plot specification (or, as shorthand, an array of marks or a single
 // mark), asserts that the given named scales, when materialized from the first
 // plot and used to produce a second plot, produce the same output and the same