@loaders.gl/tiles 5.0.0-alpha.6 → 5.0.0-alpha.7

package/src/spatial/get-spatial-coordinate-frame.ts

@@ -2,19 +2,19 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {ReadonlyCRSDefinition, SpatialReferenceCoordinateFrame} from '@math.gl/crs';
-
-const GEOGRAPHIC_CRS = 'EPSG:4326';
-const GEOCENTRIC_CRS = 'EPSG:4978';
-
-/** Normalize common OGC URL and URN CRS spellings to authority identifiers. */
-function normalizeCrsIdentifier(identifier: string): string {
-  const normalizedIdentifier = identifier.trim().toUpperCase();
-  const ogcMatch = normalizedIdentifier.match(
-    /(?:\/DEF\/CRS\/|URN:OGC:DEF:CRS:)([A-Z0-9_-]+)(?:\/|::)(?:[^/:]*[/:])?([A-Z0-9_.-]+)$/
-  );
-  return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
-}
+import {
+  inferCRSRepresentation,
+  parsePROJString,
+  parseWKTCRS,
+  type ReadonlyCRSDefinition,
+  type SpatialReferenceCoordinateFrame,
+  type WKTCRSNode
+} from '@math.gl/crs';
+import {
+  normalizeCrsIdentifier,
+  WGS84_GEOCENTRIC_CRS,
+  WGS84_GEOGRAPHIC_CRS
+} from './normalize-crs-identifier';
 
 /**
  * Classify a CRS definition into the broad coordinate frame used by 3D format adapters.
@@ -26,25 +26,14 @@ export function getSpatialCoordinateFrame(
   definition: ReadonlyCRSDefinition
 ): SpatialReferenceCoordinateFrame {
   if (typeof definition === 'string') {
-    const normalized = normalizeCrsIdentifier(definition);
-    if (normalized === GEOCENTRIC_CRS || /^GEOCCS\s*[\[(]/.test(normalized)) {
-      return 'geocentric';
+    const representation = inferCRSRepresentation(definition);
+    if (representation === 'wkt') {
+      return getWktCoordinateFrame(definition);
     }
-    if (
-      normalized === GEOGRAPHIC_CRS ||
-      normalized === 'EPSG:4490' ||
-      normalized === 'EPSG:4979' ||
-      normalized === 'OGC:CRS84' ||
-      normalized.includes('+PROJ=LONGLAT') ||
-      normalized.includes('+PROJ=LATLONG') ||
-      /^(?:GEOGCS|GEOGCRS|GEOGRAPHICCRS|GEOGRAPHIC2DCRS|GEOGRAPHIC3DCRS)\s*[\[(]/.test(normalized)
-    ) {
-      return 'geographic';
+    if (representation === 'proj-string') {
+      return getProjStringCoordinateFrame(definition);
     }
-    if (/^(?:GEODCRS|GEODETICCRS)\s*[\[(]/.test(normalized)) {
-      return /CS\s*[\[(]\s*CARTESIAN/.test(normalized) ? 'geocentric' : 'geographic';
-    }
-    return 'projected';
+    return getKnownCrsIdentifierCoordinateFrame(definition) || 'projected';
   }
 
   const projJsonDefinition = definition as {
@@ -70,5 +59,111 @@ export function getSpatialCoordinateFrame(
       ? 'geocentric'
       : 'geographic';
   }
-  return 'projected';
+  return 'unknown';
+}
+
+/**
+ * Classifies authority identifiers for which the tiles runtime has explicit frame knowledge.
+ *
+ * Unlike {@link getSpatialCoordinateFrame}, this function does not assume that an unrecognized
+ * authority identifier is projected. Draft formats use this strict result to avoid inventing
+ * semantics for unknown authorities or registry codes.
+ *
+ * @param definition - Serialized CRS identifier.
+ * @returns A known frame, or `undefined` when registry semantics are unavailable.
+ */
+export function getKnownCrsIdentifierCoordinateFrame(
+  definition: ReadonlyCRSDefinition | undefined
+): SpatialReferenceCoordinateFrame | undefined {
+  if (typeof definition !== 'string') {
+    return undefined;
+  }
+  const normalized = normalizeCrsIdentifier(definition);
+  if (normalized === WGS84_GEOCENTRIC_CRS) {
+    return 'geocentric';
+  }
+  if (normalized === WGS84_GEOGRAPHIC_CRS || normalized === 'OGC:CRS84') {
+    return 'geographic';
+  }
+  const epsgMatch = /^EPSG:(\d+)$/.exec(normalized);
+  if (!epsgMatch) {
+    return undefined;
+  }
+  const identifier = Number(epsgMatch[1]);
+  if (identifier === 7789) {
+    return 'geocentric';
+  }
+  if (identifier === 4490 || identifier === 4979) {
+    return 'geographic';
+  }
+  if (
+    identifier === 3857 ||
+    (identifier >= 32601 && identifier <= 32660) ||
+    (identifier >= 32701 && identifier <= 32760)
+  ) {
+    return 'projected';
+  }
+  return undefined;
+}
+
+/** Classifies a WKT definition using the syntax tree parsed by `@math.gl/crs`. */
+function getWktCoordinateFrame(definition: string): SpatialReferenceCoordinateFrame {
+  let root: WKTCRSNode;
+  try {
+    root = parseWKTCRS(definition).root;
+  } catch {
+    return 'unknown';
+  }
+  switch (root.keyword.toUpperCase()) {
+    case 'GEOCCS':
+      return 'geocentric';
+    case 'GEOGCS':
+    case 'GEOGCRS':
+    case 'GEOGRAPHICCRS':
+    case 'GEOGRAPHIC2DCRS':
+    case 'GEOGRAPHIC3DCRS':
+      return 'geographic';
+    case 'PROJCS':
+    case 'PROJCRS':
+    case 'PROJECTEDCRS':
+      return 'projected';
+    case 'GEODCRS':
+    case 'GEODETICCRS': {
+      const coordinateSystem = root.values.find(
+        (value): value is WKTCRSNode =>
+          value.type === 'node' && value.keyword.toUpperCase() === 'CS'
+      );
+      const subtype = coordinateSystem?.values[0];
+      if (subtype?.type !== 'enumeration' && subtype?.type !== 'string') {
+        return 'unknown';
+      }
+      return subtype.value.toUpperCase() === 'CARTESIAN'
+        ? 'geocentric'
+        : subtype.value.toUpperCase() === 'ELLIPSOIDAL'
+          ? 'geographic'
+          : 'unknown';
+    }
+    default:
+      return 'unknown';
+  }
+}
+
+/** Classifies a PROJ string using the syntax tree parsed by `@math.gl/crs`. */
+function getProjStringCoordinateFrame(definition: string): SpatialReferenceCoordinateFrame {
+  try {
+    const projection = parsePROJString(definition).parameters.find(
+      parameter => parameter.name.toLowerCase() === 'proj'
+    )?.value;
+    switch (projection?.toLowerCase()) {
+      case 'longlat':
+      case 'latlong':
+        return 'geographic';
+      case 'geocent':
+        return 'geocentric';
+      default:
+        return projection ? 'projected' : 'unknown';
+    }
+  } catch {
+    return 'unknown';
+  }
 }

package/src/spatial/normalize-crs-identifier.ts

@@ -0,0 +1,26 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Compact identifier for conventional WGS84 longitude/latitude coordinates. */
+export const WGS84_GEOGRAPHIC_CRS = 'EPSG:4326';
+
+/** Compact identifier for WGS84 Earth-centered, Earth-fixed coordinates. */
+export const WGS84_GEOCENTRIC_CRS = 'EPSG:4978';
+
+/**
+ * Normalizes common OGC URL and URN CRS spellings to compact authority identifiers.
+ *
+ * This intentionally performs syntax normalization only. Authority lookup and semantic
+ * equivalence remain outside the scope of `@math.gl/crs` and the tiles runtime.
+ *
+ * @param identifier - Serialized CRS identifier.
+ * @returns Uppercase compact identifier when an OGC spelling is recognized.
+ */
+export function normalizeCrsIdentifier(identifier: string): string {
+  const normalizedIdentifier = identifier.trim().toUpperCase();
+  const ogcMatch = normalizedIdentifier.match(
+    /(?:\/DEF\/CRS\/|URN:OGC:DEF:CRS:)([A-Z0-9_-]+)(?:\/|::)(?:[^/:]*[/:])?([A-Z0-9_.-]+)$/
+  );
+  return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
+}

package/src/spatial/spatial-coordinate-transformer.ts

@@ -8,6 +8,11 @@ import {Ellipsoid} from '@math.gl/geospatial';
 import type {ReadonlyCRSDefinition} from '@math.gl/crs';
 import {Proj4Projection, toProj4CRSDefinition, type Proj4CRSDefinition} from '@math.gl/proj4';
 import {getGeoidModel} from './spatial-resource-registry';
+import {
+  normalizeCrsIdentifier,
+  WGS84_GEOCENTRIC_CRS,
+  WGS84_GEOGRAPHIC_CRS
+} from './normalize-crs-identifier';
 import type {
   TilesetHeightReference,
   TilesetSpatialOptions,
@@ -16,9 +21,6 @@ import type {
 } from './spatial-types';
 export {getSpatialCoordinateFrame} from './get-spatial-coordinate-frame';
 
-const GEOGRAPHIC_CRS = 'EPSG:4326';
-const GEOCENTRIC_CRS = 'EPSG:4978';
-
 /**
  * Deterministic coordinate transformer used by 3D tile format adapters.
  *
@@ -90,13 +92,13 @@ export class SpatialCoordinateTransformer {
       if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
         this.geographicProjection = new Proj4Projection({
           from: getHorizontalProj4Definition(spatialReference.sourceCrs),
-          to: GEOGRAPHIC_CRS,
+          to: WGS84_GEOGRAPHIC_CRS,
           enforceAxis: false
         });
       }
       if (!this.outputIsGeographic && !this.outputIsGeocentric) {
         this.heightOutputProjection = new Proj4Projection({
-          from: GEOGRAPHIC_CRS,
+          from: WGS84_GEOGRAPHIC_CRS,
           to: getHorizontalProj4Definition(outputCrs),
           enforceAxis: false
         });
@@ -157,6 +159,59 @@ export class SpatialCoordinateTransformer {
     return result;
   }
 
+  /** Transform a packed sequence of xyz positions, preserving the input array type only when safe. */
+  transformPositions(positions: ArrayLike<number>): Float64Array {
+    if (positions.length % 3 !== 0) {
+      throw new Error('Packed spatial positions must contain a multiple of three components');
+    }
+    const transformedPositions = new Float64Array(positions.length);
+    for (let index = 0; index < positions.length; index += 3) {
+      const transformed = this.transformPosition([
+        Number(positions[index]),
+        Number(positions[index + 1]),
+        Number(positions[index + 2])
+      ]);
+      transformedPositions[index] = transformed[0];
+      transformedPositions[index + 1] = transformed[1];
+      transformedPositions[index + 2] = transformed[2];
+    }
+    return transformedPositions;
+  }
+
+  /** Transform packed xyz normals using a local finite-difference tangent approximation. */
+  transformNormals(normals: ArrayLike<number>, positions: ArrayLike<number>): Float32Array {
+    if (normals.length !== positions.length || normals.length % 3 !== 0) {
+      throw new Error('Spatial normals and positions must have matching xyz component counts');
+    }
+    const transformedNormals = new Float32Array(normals.length);
+    const epsilon = 1e-5;
+    for (let index = 0; index < normals.length; index += 3) {
+      const position = [
+        Number(positions[index]),
+        Number(positions[index + 1]),
+        Number(positions[index + 2])
+      ];
+      const normal = [
+        Number(normals[index]),
+        Number(normals[index + 1]),
+        Number(normals[index + 2])
+      ];
+      const jacobian = getFiniteDifferenceJacobian(this, position, epsilon);
+      const transformedNormal = inverseTransposeMultiply(jacobian, normal);
+      const length = Math.hypot(...transformedNormal);
+      if (length > 0 && Number.isFinite(length)) {
+        transformedNormals[index] = transformedNormal[0] / length;
+        transformedNormals[index + 1] = transformedNormal[1] / length;
+        transformedNormals[index + 2] = transformedNormal[2] / length;
+      } else {
+        transformedNormals[index] = normal[0];
+        transformedNormals[index + 1] = normal[1];
+        transformedNormals[index + 2] = normal[2];
+      }
+    }
+    return transformedNormals;
+  }
+
   /** Convert one source coordinate to conventional WGS84 longitude, latitude, and height. */
   private toGeographic(coordinate: number[]): number[] {
     if (this.sourceIsGeocentric) {
@@ -180,6 +235,47 @@ export class SpatialCoordinateTransformer {
   }
 }
 
+function getFiniteDifferenceJacobian(
+  transformer: SpatialCoordinateTransformer,
+  position: number[],
+  epsilon: number
+): number[][] {
+  const columns: number[][] = [];
+  for (let axis = 0; axis < 3; axis++) {
+    const plus = position.slice();
+    const minus = position.slice();
+    plus[axis] += epsilon;
+    minus[axis] -= epsilon;
+    const plusPosition = transformer.transformPosition(plus);
+    const minusPosition = transformer.transformPosition(minus);
+    columns.push([
+      (plusPosition[0] - minusPosition[0]) / (2 * epsilon),
+      (plusPosition[1] - minusPosition[1]) / (2 * epsilon),
+      (plusPosition[2] - minusPosition[2]) / (2 * epsilon)
+    ]);
+  }
+  return columns;
+}
+
+function inverseTransposeMultiply(jacobianColumns: number[][], vector: number[]): number[] {
+  const [a, b, c] = jacobianColumns;
+  const determinant =
+    a[0] * (b[1] * c[2] - b[2] * c[1]) -
+    b[0] * (a[1] * c[2] - a[2] * c[1]) +
+    c[0] * (a[1] * b[2] - a[2] * b[1]);
+  if (!Number.isFinite(determinant) || Math.abs(determinant) < 1e-15) {
+    return vector;
+  }
+  const inverseTranspose = [
+    [b[1] * c[2] - b[2] * c[1], a[2] * c[1] - a[1] * c[2], a[1] * b[2] - a[2] * b[1]],
+    [b[2] * c[0] - b[0] * c[2], a[0] * c[2] - a[2] * c[0], a[2] * b[0] - a[0] * b[2]],
+    [b[0] * c[1] - b[1] * c[0], a[1] * c[0] - a[0] * c[1], a[0] * b[1] - a[1] * b[0]]
+  ];
+  return inverseTranspose.map(
+    row => (row[0] * vector[0] + row[1] * vector[1] + row[2] * vector[2]) / determinant
+  );
+}
+
 /** Select the horizontal component that the proj4js runtime can execute. */
 function getHorizontalProj4Definition(
   definition: ReadonlyCRSDefinition | undefined
@@ -224,7 +320,9 @@ function validateTransformRequest(spatialReference: TilesetSpatialReference): vo
 
 /** Return whether a CRS definition identifies the WGS84 geocentric frame. */
 function isWgs84Geocentric(definition: unknown): boolean {
-  return typeof definition === 'string' && normalizeCrsIdentifier(definition) === GEOCENTRIC_CRS;
+  return (
+    typeof definition === 'string' && normalizeCrsIdentifier(definition) === WGS84_GEOCENTRIC_CRS
+  );
 }
 
 /** Return whether a CRS definition uses conventional WGS84 longitude/latitude coordinates. */
@@ -233,16 +331,9 @@ function isWgs84Geographic(definition: unknown): boolean {
     return false;
   }
   const identifier = normalizeCrsIdentifier(definition);
-  return identifier === GEOGRAPHIC_CRS || identifier === 'EPSG:4979' || identifier === 'OGC:CRS84';
-}
-
-/** Normalize common OGC URL and URN CRS spellings to authority identifiers. */
-function normalizeCrsIdentifier(identifier: string): string {
-  const normalizedIdentifier = identifier.trim().toUpperCase();
-  const ogcMatch = normalizedIdentifier.match(
-    /(?:\/DEF\/CRS\/|URN:OGC:DEF:CRS:)([A-Z0-9_-]+)(?:\/|::)(?:[^/:]*[/:])?([A-Z0-9_.-]+)$/
+  return (
+    identifier === WGS84_GEOGRAPHIC_CRS || identifier === 'EPSG:4979' || identifier === 'OGC:CRS84'
   );
-  return ogcMatch ? `${ogcMatch[1]}:${ogcMatch[2]}` : normalizedIdentifier;
 }
 
 /** Return whether source and target height interpretations differ. */

package/src/spatial/tiles-3d-spatial-transformer.ts

@@ -0,0 +1,206 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {SpatialCoordinateTransformer} from './spatial-coordinate-transformer';
+import {getSpatialCoordinateFrame} from './get-spatial-coordinate-frame';
+import {Matrix4} from '@math.gl/core';
+import {Ellipsoid} from '@math.gl/geospatial';
+import type {TilesetSpatialOptions, TilesetSpatialReference} from './spatial-types';
+
+/** Structural 3D Tiles volume shape used by the source adapter. */
+export type Tiles3DSpatialBoundingVolume = {
+  box?: number[];
+  sphere?: number[];
+  region?: number[];
+  [key: string]: unknown;
+};
+
+/**
+ * Applies nonlinear CRS operations to 3D Tiles geometry bounds.
+ *
+ * Bounds are rebuilt from conservative samples. This intentionally produces an axis-aligned box
+ * in the target frame; it is safe for culling and screen-space-error calculations even when the
+ * source volume is rotated or the projection is nonlinear.
+ */
+export class Tiles3DSpatialTransformer {
+  /** Normalized reference describing the completed operation. */
+  readonly spatialReference: TilesetSpatialReference;
+  private readonly coordinateTransformer: SpatialCoordinateTransformer;
+  private readonly geographicCoordinateTransformer: SpatialCoordinateTransformer;
+
+  /** Creates a 3D Tiles transformer for a requested target CRS. */
+  constructor(spatialReference: TilesetSpatialReference, options: TilesetSpatialOptions = {}) {
+    this.coordinateTransformer = new SpatialCoordinateTransformer(spatialReference, options);
+    // 3D Tiles regions are always encoded as WGS84 longitude/latitude radians, independently
+    // of the tileset's local CRS. Build a second pipeline for that fixed source frame.
+    const geographicSpatialReference = {
+      ...spatialReference,
+      sourceCrs: 'EPSG:4326' as const,
+      targetCrs: spatialReference.targetCrs || spatialReference.sourceCrs,
+      coordinateFrame: 'geographic' as const,
+      axisOrder: 'xy' as const
+    };
+    this.geographicCoordinateTransformer = new SpatialCoordinateTransformer(
+      geographicSpatialReference,
+      options
+    );
+    this.spatialReference = spatialReference;
+  }
+
+  /** Transform packed POSITION values into the target CRS. */
+  transformPositions(positions: ArrayLike<number>): Float64Array {
+    return this.coordinateTransformer.transformPositions(positions);
+  }
+
+  /** Transform packed NORMAL values using the corresponding source positions. */
+  transformNormals(normals: ArrayLike<number>, positions: ArrayLike<number>): Float32Array {
+    return this.coordinateTransformer.transformNormals(normals, positions);
+  }
+
+  /** Rebuild a conservative target-frame volume from a source volume. */
+  transformBoundingVolume(
+    volume: Tiles3DSpatialBoundingVolume,
+    sourceTransform?: ArrayLike<number>
+  ): Tiles3DSpatialBoundingVolume {
+    const transform = sourceTransform ? new Matrix4(Array.from(sourceTransform)) : undefined;
+    const samples = volume.region
+      ? getRegionSamples(volume.region)
+      : getVolumeSamples(volume).map(sample =>
+          transform ? Array.from(transform.transformAsPoint(sample)) : sample
+        );
+    if (!samples.length) {
+      return volume;
+    }
+    const transformed = volume.region
+      ? samples.map(sample => this.transformRegionSample(sample))
+      : samples.map(sample => this.coordinateTransformer.transformPosition(sample));
+    return {box: createAxisAlignedBox(transformed)};
+  }
+
+  /** Transforms one WGS84 region sample into the selected output frame. */
+  private transformRegionSample(sample: number[]): number[] {
+    const [longitudeDegrees, latitudeDegrees, height] = sample;
+    const targetCrs = this.spatialReference.targetCrs || this.spatialReference.sourceCrs;
+    if (targetCrs && getSpatialCoordinateFrame(targetCrs) === 'geocentric') {
+      const cartesian = Ellipsoid.WGS84.cartographicToCartesian([
+        longitudeDegrees,
+        latitudeDegrees,
+        height
+      ]);
+      return Array.from(cartesian);
+    }
+    return this.geographicCoordinateTransformer.transformPosition(sample);
+  }
+}
+
+/** Samples region corners, center lines, and both height planes in degrees/meters. */
+function getRegionSamples(region: number[]): number[][] {
+  if (region.length < 6 || region.some(value => !Number.isFinite(value))) {
+    return [];
+  }
+  const [west, south, east, north, minimumHeight, maximumHeight] = region;
+  const longitudeEnd = east < west ? east + Math.PI * 2 : east;
+  const longitudes = getIntervalSamples(west, longitudeEnd);
+  const latitudes = getIntervalSamples(south, north);
+  const samples: number[][] = [];
+  for (const longitude of longitudes) {
+    for (const latitude of latitudes) {
+      for (const height of [minimumHeight, maximumHeight]) {
+        samples.push([(longitude * 180) / Math.PI, (latitude * 180) / Math.PI, height]);
+      }
+    }
+  }
+  return samples;
+}
+
+/** Includes interval endpoints and every quarter-turn where ECEF axes reach an extremum. */
+function getIntervalSamples(start: number, end: number): number[] {
+  const samples = [start, (start + end) / 2, end];
+  const angularStep = Math.PI / 2;
+  const firstCriticalIndex = Math.ceil(start / angularStep);
+  const lastCriticalIndex = Math.floor(end / angularStep);
+  for (
+    let criticalIndex = firstCriticalIndex;
+    criticalIndex <= lastCriticalIndex;
+    criticalIndex++
+  ) {
+    samples.push(criticalIndex * angularStep);
+  }
+  return samples;
+}
+
+function getVolumeSamples(volume: Tiles3DSpatialBoundingVolume): number[][] {
+  if (volume.box && volume.box.length >= 12) {
+    const center = volume.box.slice(0, 3);
+    const axes = [volume.box.slice(3, 6), volume.box.slice(6, 9), volume.box.slice(9, 12)];
+    const samples: number[][] = [];
+    for (let firstIndex = 0; firstIndex <= 4; firstIndex++) {
+      for (let secondIndex = 0; secondIndex <= 4; secondIndex++) {
+        for (let thirdIndex = 0; thirdIndex <= 4; thirdIndex++) {
+          const first = firstIndex / 2 - 1;
+          const second = secondIndex / 2 - 1;
+          const third = thirdIndex / 2 - 1;
+          samples.push([
+            center[0] + first * axes[0][0] + second * axes[1][0] + third * axes[2][0],
+            center[1] + first * axes[0][1] + second * axes[1][1] + third * axes[2][1],
+            center[2] + first * axes[0][2] + second * axes[1][2] + third * axes[2][2]
+          ]);
+        }
+      }
+    }
+    return samples;
+  }
+  if (volume.sphere && volume.sphere.length >= 4) {
+    const [x, y, z, radius] = volume.sphere;
+    const samples = [
+      [x - radius, y, z],
+      [x + radius, y, z],
+      [x, y - radius, z],
+      [x, y + radius, z],
+      [x, y, z - radius],
+      [x, y, z + radius]
+    ];
+    for (let longitudeIndex = 0; longitudeIndex < 16; longitudeIndex++) {
+      const longitude = (longitudeIndex * Math.PI * 2) / 16;
+      samples.push([x + radius * Math.cos(longitude), y + radius * Math.sin(longitude), z]);
+    }
+    return samples;
+  }
+  // Regions are already WGS84 geographic volumes. Keep them unchanged until a dedicated
+  // geographic-region adapter can account for longitude wrapping and datum semantics.
+  return [];
+}
+
+function createAxisAlignedBox(samples: number[][]): number[] {
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  for (const sample of samples) {
+    for (let axis = 0; axis < 3; axis++) {
+      minimum[axis] = Math.min(minimum[axis], sample[axis]);
+      maximum[axis] = Math.max(maximum[axis], sample[axis]);
+    }
+  }
+  const padding = [
+    Math.max((maximum[0] - minimum[0]) * 0.01, 1e-9),
+    Math.max((maximum[1] - minimum[1]) * 0.01, 1e-9),
+    Math.max((maximum[2] - minimum[2]) * 0.01, 1e-9)
+  ];
+  const center = [
+    (minimum[0] + maximum[0]) / 2,
+    (minimum[1] + maximum[1]) / 2,
+    (minimum[2] + maximum[2]) / 2
+  ];
+  return [
+    ...center,
+    (maximum[0] - minimum[0]) / 2 + padding[0],
+    0,
+    0,
+    0,
+    (maximum[1] - minimum[1]) / 2 + padding[1],
+    0,
+    0,
+    0,
+    (maximum[2] - minimum[2]) / 2 + padding[2]
+  ];
+}