@developmentseed/deck.gl-raster 0.5.0-beta.1 → 0.5.0

package/dist/raster-tileset/raster-tile-traversal.d.ts

@@ -1,6 +1,5 @@
 /**
- * This file implements tile traversal for generic 2D tilesets defined by
- * TileMatrixSet tile layouts.
+ * This file implements tile traversal for generic 2D tilesets.
  *
  * The main algorithm works as follows:
  *
@@ -8,26 +7,29 @@
  *    necessarily the whole world)
  * 2. Test if each tile is visible using viewport frustum culling
  * 3. For visible tiles, compute distance-based LOD (Level of Detail)
- * 4. If LOD is insufficient, recursively subdivide into 4 child tiles
+ * 4. If LOD is insufficient, recursively subdivide into child tiles
  * 5. Select tiles at appropriate zoom levels based on distance from camera
  *
  * The result is a set of tiles at varying zoom levels that efficiently
  * cover the visible area with appropriate detail.
+ *
+ * The traversal is driven by a {@link TilesetDescriptor}, which abstracts over
+ * both OGC TileMatrixSet grids and Zarr multiscale pyramids.
  */
 import type { Viewport } from "@deck.gl/core";
-import type { TileMatrix, TileMatrixSet } from "@developmentseed/morecantile";
 import type { OrientedBoundingBox } from "@math.gl/culling";
 import { CullingVolume } from "@math.gl/culling";
-import type { Bounds, CornerBounds, ProjectionFunction, TileIndex, ZRange } from "./types.js";
+import type { TilesetDescriptor, TilesetLevel } from "./tileset-interface.js";
+import type { Bounds, TileIndex, ZRange } from "./types.js";
 /**
- * Raster Tile Node - represents a single tile in the TileMatrixSet structure
+ * Raster Tile Node - represents a single tile in a tileset pyramid.
  *
  * Akin to the upstream OSMNode class.
  *
  * This node class uses the following coordinate system:
  *
- * - x: tile column (0 to TileMatrix.matrixWidth, left to right)
- * - y: tile row (0 to TileMatrix.matrixHeight, top to bottom)
+ * - x: tile column (0 to TilesetLevel.matrixWidth, left to right)
+ * - y: tile row (0 to TilesetLevel.matrixHeight, top to bottom)
  * - z: overview level. This assumes ordering where: 0 = coarsest, higher = finer
  */
 export declare class RasterTileNode {
@@ -37,7 +39,7 @@ export declare class RasterTileNode {
     y: number;
     /** Zoom index assumed to be (higher = finer detail) */
     z: number;
-    private metadata;
+    private descriptor;
     /**
      * Flag indicating whether any descendant of this tile is visible.
      *
@@ -53,35 +55,32 @@ export declare class RasterTileNode {
     private selected?;
     /** A cache of the children of this node. */
     private _children?;
-    private projectTo3857;
-    private projectTo4326;
     /**
      * A cached bounding volume for this tile, used for frustum culling
      *
      * This stores the result of `getBoundingVolume`.
      */
     private _boundingVolume?;
-    constructor(x: number, y: number, z: number, { metadata, projectTo3857, projectTo4326, }: {
-        metadata: TileMatrixSet;
-        projectTo3857: ProjectionFunction;
-        projectTo4326: ProjectionFunction;
+    constructor(x: number, y: number, z: number, { descriptor }: {
+        descriptor: TilesetDescriptor;
     });
-    /** Get overview info for this tile's z level */
-    get tileMatrix(): TileMatrix;
+    /** Get the level info for this tile's z index. */
+    get level(): TilesetLevel;
     /** Get the children of this node.
      *
      * Find all tiles at level this.z + 1 whose spatial extent overlaps this tile.
      *
-     * A TileMatrixSet is not a quadtree, but rather a stack of independent grids. We can't cleanly find child tiles by decimation directly.
-     *
+     * A tileset pyramid is not guaranteed to be a quadtree — it is a stack of
+     * independent grids. We find children by mapping the parent tile's CRS bounds
+     * into the child grid using {@link TilesetLevel.crsBoundsToTileRange}.
      */
     get children(): RasterTileNode[] | null;
     /**
      * Recursively traverse the tile pyramid to determine if this tile (or its
      * descendants) should be rendered.
      *
-     * I.e. “Given this tile node, should I render this tile, or should I recurse
-     * into its children?”
+     * I.e. "Given this tile node, should I render this tile, or should I recurse
+     * into its children?"
      *
      * The algorithm performs:
      * 1. Visibility culling - reject tiles outside the view frustum
@@ -99,9 +98,9 @@ export declare class RasterTileNode {
         project: ((xyz: number[]) => number[]) | null;
         cullingVolume: CullingVolume;
         elevationBounds: ZRange;
-        /** Minimum (coarsest) COG overview level */
+        /** Minimum (coarsest) overview level */
         minZ: number;
-        /** Maximum (finest) COG overview level */
+        /** Maximum (finest) overview level */
         maxZ?: number;
         /** Optional geographic bounds filter */
         bounds?: Bounds;
@@ -111,7 +110,7 @@ export declare class RasterTileNode {
      * Recursively traverses the entire tree and gathers tiles where selected=true.
      *
      * @param result - Accumulator array for selected tiles
-     * @returns Array of selected OSMNode tiles
+     * @returns Array of selected RasterTileNode tiles
      */
     getSelected(result?: RasterTileNode[]): RasterTileNode[];
     /**
@@ -141,38 +140,17 @@ export declare class RasterTileNode {
     private _getGenericBoundingVolume;
 }
 /**
- * Compute the projected tile bounds in the tile matrix's CRS.
+ * Get tile indices visible in viewport.
  *
- * Because it's a linear transformation from the tile index to projected bounds,
- * we don't need to sample this for each of the reference points. We only need
- * the corners.
+ * Uses frustum culling driven by a {@link TilesetDescriptor}, which abstracts
+ * over OGC TileMatrixSet grids and Zarr multiscale pyramids.
  *
- * @return      The bounding box as [minX, minY, maxX, maxY] in projected CRS.
+ * Overview levels follow the descriptor ordering: index 0 = coarsest, higher = finer.
  */
-declare function computeProjectedTileBounds(tileMatrix: TileMatrix, { x, y, }: {
-    x: number;
-    y: number;
-}): [number, number, number, number];
-/**
- * Get tile indices visible in viewport
- * Uses frustum culling similar to OSM implementation
- *
- * Overviews follow TileMatrixSet ordering: index 0 = coarsest, higher = finer
- */
-export declare function getTileIndices(metadata: TileMatrixSet, opts: {
+export declare function getTileIndices(descriptor: TilesetDescriptor, opts: {
     viewport: Viewport;
     maxZ: number;
     zRange: ZRange | null;
-    projectTo3857: ProjectionFunction;
-    projectTo4326: ProjectionFunction;
-    wgs84Bounds: CornerBounds;
+    wgs84Bounds: Bounds;
 }): TileIndex[];
-/**
- * Exports only for use in testing
- */
-export declare const __TEST_EXPORTS: {
-    computeProjectedTileBounds: typeof computeProjectedTileBounds;
-    RasterTileNode: typeof RasterTileNode;
-};
-export {};
 //# sourceMappingURL=raster-tile-traversal.d.ts.map

package/dist/raster-tileset/raster-tile-traversal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raster-tile-traversal.d.ts","sourceRoot":"","sources":["../../src/raster-tileset/raster-tile-traversal.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"raster-tile-traversal.d.ts","sourceRoot":"","sources":["../../src/raster-tileset/raster-tile-traversal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EACL,aAAa,EAGd,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,KAAK,EACV,MAAM,EAIN,SAAS,EACT,MAAM,EACP,MAAM,YAAY,CAAC;AAiEpB;;;;;;;;;;GAUG;AACH,qBAAa,cAAc;IACzB,yBAAyB;IACzB,CAAC,EAAE,MAAM,CAAC;IAEV,0BAA0B;IAC1B,CAAC,EAAE,MAAM,CAAC;IAEV,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAC;IAEV,OAAO,CAAC,UAAU,CAAoB;IAEtC;;;;;OAKG;IACH,OAAO,CAAC,YAAY,CAAC,CAAU;IAE/B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,CAAU;IAE3B,4CAA4C;IAC5C,OAAO,CAAC,SAAS,CAAC,CAA0B;IAE5C;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAAC,CAItB;gBAGA,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,UAAU,EAAE,EAAE;QAAE,UAAU,EAAE,iBAAiB,CAAA;KAAE;IAQnD,kDAAkD;IAClD,IAAI,KAAK,IAAI,YAAY,CAExB;IAED;;;;;;;OAOG;IACH,IAAI,QAAQ,IAAI,cAAc,EAAE,GAAG,IAAI,CA+BtC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,MAAM,EAAE;QACb,QAAQ,EAAE,QAAQ,CAAC;QAEnB,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;QAE9C,aAAa,EAAE,aAAa,CAAC;QAE7B,eAAe,EAAE,MAAM,CAAC;QACxB,wCAAwC;QACxC,IAAI,EAAE,MAAM,CAAC;QACb,sCAAsC;QACtC,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,wCAAwC;QACxC,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GAAG,OAAO;IAiFX;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,GAAE,cAAc,EAAO,GAAG,cAAc,EAAE;IAY5D;;;;;;OAMG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO;IAUhE;;;;;;OAMG;IACH,iBAAiB,CACf,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,GAAG,IAAI,GAC5C;QAAE,cAAc,EAAE,mBAAmB,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE;IAgCrE;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;CAiDlC;AA4GD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,iBAAiB,EAC7B,IAAI,EAAE;IACJ,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,GACA,SAAS,EAAE,CA4Fb"}

package/dist/raster-tileset/raster-tile-traversal.js

@@ -1,6 +1,5 @@
 /**
- * This file implements tile traversal for generic 2D tilesets defined by
- * TileMatrixSet tile layouts.
+ * This file implements tile traversal for generic 2D tilesets.
  *
  * The main algorithm works as follows:
  *
@@ -8,14 +7,16 @@
  *    necessarily the whole world)
  * 2. Test if each tile is visible using viewport frustum culling
  * 3. For visible tiles, compute distance-based LOD (Level of Detail)
- * 4. If LOD is insufficient, recursively subdivide into 4 child tiles
+ * 4. If LOD is insufficient, recursively subdivide into child tiles
  * 5. Select tiles at appropriate zoom levels based on distance from camera
  *
  * The result is a set of tiles at varying zoom levels that efficiently
  * cover the visible area with appropriate detail.
+ *
+ * The traversal is driven by a {@link TilesetDescriptor}, which abstracts over
+ * both OGC TileMatrixSet grids and Zarr multiscale pyramids.
  */
 import { _GlobeViewport, assert } from "@deck.gl/core";
-import { xy_bounds } from "@developmentseed/morecantile";
 import { CullingVolume, makeOrientedBoundingBoxFromPoints, Plane, } from "@math.gl/culling";
 import { lngLatToWorld, worldToLngLat } from "@math.gl/web-mercator";
 /**
@@ -74,18 +75,15 @@ const EPSG_3857_CIRCUMFERENCE = 2 * Math.PI * WGS84_ELLIPSOID_A;
 const EPSG_3857_HALF_CIRCUMFERENCE = EPSG_3857_CIRCUMFERENCE / 2;
 // Maximum latitude representable in Web Mercator (EPSG:3857), in degrees.
 const MAX_WEB_MERCATOR_LAT = 85.05112877980659;
-// 0.28 mm per pixel
-// https://docs.ogc.org/is/17-083r4/17-083r4.html#toc15
-const SCREEN_PIXEL_SIZE = 0.00028;
 /**
- * Raster Tile Node - represents a single tile in the TileMatrixSet structure
+ * Raster Tile Node - represents a single tile in a tileset pyramid.
  *
  * Akin to the upstream OSMNode class.
  *
  * This node class uses the following coordinate system:
  *
- * - x: tile column (0 to TileMatrix.matrixWidth, left to right)
- * - y: tile row (0 to TileMatrix.matrixHeight, top to bottom)
+ * - x: tile column (0 to TilesetLevel.matrixWidth, left to right)
+ * - y: tile row (0 to TilesetLevel.matrixHeight, top to bottom)
  * - z: overview level. This assumes ordering where: 0 = coarsest, higher = finer
  */
 export class RasterTileNode {
@@ -95,7 +93,7 @@ export class RasterTileNode {
     y;
     /** Zoom index assumed to be (higher = finer detail) */
     z;
-    metadata;
+    descriptor;
     /**
      * Flag indicating whether any descendant of this tile is visible.
      *
@@ -111,61 +109,50 @@ export class RasterTileNode {
     selected;
     /** A cache of the children of this node. */
     _children;
-    projectTo3857;
-    projectTo4326;
     /**
      * A cached bounding volume for this tile, used for frustum culling
      *
      * This stores the result of `getBoundingVolume`.
      */
     _boundingVolume;
-    constructor(x, y, z, { metadata, projectTo3857, projectTo4326, }) {
+    constructor(x, y, z, { descriptor }) {
         this.x = x;
         this.y = y;
         this.z = z;
-        this.metadata = metadata;
-        this.projectTo3857 = projectTo3857;
-        this.projectTo4326 = projectTo4326;
+        this.descriptor = descriptor;
     }
-    /** Get overview info for this tile's z level */
-    get tileMatrix() {
-        return this.metadata.tileMatrices[this.z];
+    /** Get the level info for this tile's z index. */
+    get level() {
+        return this.descriptor.levels[this.z];
     }
     /** Get the children of this node.
      *
      * Find all tiles at level this.z + 1 whose spatial extent overlaps this tile.
      *
-     * A TileMatrixSet is not a quadtree, but rather a stack of independent grids. We can't cleanly find child tiles by decimation directly.
-     *
+     * A tileset pyramid is not guaranteed to be a quadtree — it is a stack of
+     * independent grids. We find children by mapping the parent tile's CRS bounds
+     * into the child grid using {@link TilesetLevel.crsBoundsToTileRange}.
      */
     get children() {
         if (!this._children) {
-            const maxZ = this.metadata.tileMatrices.length - 1;
+            const maxZ = this.descriptor.levels.length - 1;
             if (this.z >= maxZ) {
                 // Already at finest resolution, no children
                 this._children = null;
                 return null;
             }
-            // In TileMatrixSet ordering: refine to z + 1 (finer detail)
-            const parentMatrix = this.tileMatrix;
             const childZ = this.z + 1;
-            const childMatrix = this.metadata.tileMatrices[childZ];
-            // Compute this tile's bounds in TMS' CRS
-            const parentBounds = computeProjectedTileBounds(parentMatrix, {
-                x: this.x,
-                y: this.y,
-            });
+            const childLevel = this.descriptor.levels[childZ];
+            // Compute this tile's bounds in the source CRS
+            const parentCorners = this.level.projectedTileCorners(this.x, this.y);
+            const parentBounds = cornersToBounds(parentCorners);
             // Find overlapping child index range
-            const { minCol, maxCol, minRow, maxRow } = getOverlappingChildRange(parentBounds, childMatrix);
+            const { minCol, maxCol, minRow, maxRow } = childLevel.crsBoundsToTileRange(...parentBounds);
             const children = [];
-            const { metadata, projectTo3857, projectTo4326 } = this;
+            const { descriptor } = this;
             for (let y = minRow; y <= maxRow; y++) {
                 for (let x = minCol; x <= maxCol; x++) {
-                    children.push(new RasterTileNode(x, y, childZ, {
-                        metadata,
-                        projectTo3857,
-                        projectTo4326,
-                    }));
+                    children.push(new RasterTileNode(x, y, childZ, { descriptor }));
                 }
             }
             this._children = children.length > 0 ? children : null;
@@ -176,8 +163,8 @@ export class RasterTileNode {
      * Recursively traverse the tile pyramid to determine if this tile (or its
      * descendants) should be rendered.
      *
-     * I.e. “Given this tile node, should I render this tile, or should I recurse
-     * into its children?”
+     * I.e. "Given this tile node, should I render this tile, or should I recurse
+     * into its children?"
      *
      * The algorithm performs:
      * 1. Visibility culling - reject tiles outside the view frustum
@@ -194,7 +181,7 @@ export class RasterTileNode {
         // Reset state
         this.childVisible = false;
         this.selected = false;
-        const { viewport, cullingVolume, elevationBounds, minZ, maxZ = this.metadata.tileMatrices.length - 1, project, bounds, } = params;
+        const { viewport, cullingVolume, elevationBounds, minZ, maxZ = this.descriptor.levels.length - 1, project, bounds, } = params;
         // Get bounding volume for this tile
         const { boundingVolume, commonSpaceBounds } = this.getBoundingVolume(elevationBounds, project);
         // Step 1: Bounds checking
@@ -212,29 +199,14 @@ export class RasterTileNode {
         const children = this.children;
         // LOD (Level of Detail) selection (only if allowed at this level)
         // Only select this tile if no child is visible (prevents overlapping tiles)
-        // “When pitch is low, force selection at maxZ.”
+        // "When pitch is low, force selection at maxZ."
         if (!this.childVisible && this.z >= minZ) {
             const metersPerScreenPixel = getMetersPerPixelAtBoundingVolume(boundingVolume, viewport.zoom);
-            // console.log("metersPerScreenPixel", metersPerScreenPixel);
-            const tileMetersPerPixel = this.tileMatrix.scaleDenominator * SCREEN_PIXEL_SIZE;
-            // console.log("tileMetersPerPixel", tileMetersPerPixel);
-            // const screenScaleDenominator = metersPerScreenPixel / SCREEN_PIXEL_SIZE;
-            // console.log("screenScaleDenominator", screenScaleDenominator);
-            // TODO: in the future we could try adding a bias
-            // const LOD_BIAS = 0.75;
-            // this.tileMatrix.scaleDenominator <= screenScaleDenominator * LOD_BIAS
-            // console.log(
-            //   "this.tileMatrix.scaleDenominator",
-            //   this.tileMatrix.scaleDenominator,
-            // );
-            // console.log(
-            //   "tileMetersPerPixel <= metersPerScreenPixel",
-            //   tileMetersPerPixel <= metersPerScreenPixel,
-            // );
+            const tileMetersPerPixel = this.level.metersPerPixel;
             if (tileMetersPerPixel <= metersPerScreenPixel ||
                 this.z >= maxZ ||
                 (children === null && this.z >= minZ)) {
-                // “Select this tile when its scale is at least as detailed as the screen.”
+                // "Select this tile when its scale is at least as detailed as the screen."
                 this.selected = true;
                 return true;
             }
@@ -261,7 +233,7 @@ export class RasterTileNode {
      * Recursively traverses the entire tree and gathers tiles where selected=true.
      *
      * @param result - Accumulator array for selected tiles
-     * @returns Array of selected OSMNode tiles
+     * @returns Array of selected RasterTileNode tiles
      */
     getSelected(result = []) {
         if (this.selected) {
@@ -325,13 +297,9 @@ export class RasterTileNode {
      *
      */
     _getGenericBoundingVolume(zRange) {
-        const tileMatrix = this.tileMatrix;
         const [minZ, maxZ] = zRange;
-        const tileCrsBounds = computeProjectedTileBounds(tileMatrix, {
-            x: this.x,
-            y: this.y,
-        });
-        const refPointsEPSG3857 = sampleReferencePointsInEPSG3857(REF_POINTS_9, tileCrsBounds, this.projectTo3857, this.projectTo4326);
+        const tileCorners = this.level.projectedTileCorners(this.x, this.y);
+        const refPointsEPSG3857 = sampleReferencePointsInEPSG3857(REF_POINTS_9, tileCorners, this.descriptor.projectTo3857, this.descriptor.projectTo4326);
         const commonSpacePositions = refPointsEPSG3857.map((xy) => rescaleEPSG3857ToCommonSpace(xy));
         const refPointPositions = [];
         for (const p of commonSpacePositions) {
@@ -364,24 +332,6 @@ export class RasterTileNode {
         };
     }
 }
-/**
- * Compute the projected tile bounds in the tile matrix's CRS.
- *
- * Because it's a linear transformation from the tile index to projected bounds,
- * we don't need to sample this for each of the reference points. We only need
- * the corners.
- *
- * @return      The bounding box as [minX, minY, maxX, maxY] in projected CRS.
- */
-function computeProjectedTileBounds(tileMatrix, { x, y, }) {
-    const bounds = xy_bounds(tileMatrix, { x, y });
-    return [
-        bounds.lowerLeft[0],
-        bounds.lowerLeft[1],
-        bounds.upperRight[0],
-        bounds.upperRight[1],
-    ];
-}
 /**
  * Wrap a forward projection to EPSG:3857 so that it never returns NaN.
  *
@@ -417,22 +367,25 @@ function makeClampedForwardTo3857(projectTo3857, projectTo4326) {
     };
 }
 /**
- * Sample the selected reference points in EPSG:3857
+ * Sample the selected reference points in EPSG:3857.
+ *
+ * Reference points are given as `[relX, relY]` fractions in `[0, 1]` and are
+ * bilinearly interpolated across the tile's four CRS corners. For axis-aligned
+ * tiles this is equivalent to the old AABB lerp; for rotated tiles it correctly
+ * samples the actual quadrilateral rather than its bounding box.
  *
- * Note that EPSG:3857 is **not** the same as deck.gl's common space! deck.gl's
- * common space is the size of `TILE_SIZE` (512) units, while EPSG:3857 uses
- * meters.
+ * Note that EPSG:3857 is **not** the same as deck.gl's common space — deck.gl's
+ * common space is 512 units wide, while EPSG:3857 uses meters.
  *
- * @param  refPoints selected reference points. Each coordinate should be in [0-1]
- * @param  tileBounds the bounds of the tile in **tile CRS** [minX, minY, maxX, maxY]
+ * @param refPoints  Reference points as `[relX, relY]` fractions in `[0, 1]`.
+ * @param tileCorners  The four CRS corners of the tile.
  */
-function sampleReferencePointsInEPSG3857(refPoints, tileBounds, projectTo3857, projectTo4326) {
-    const [minX, minY, maxX, maxY] = tileBounds;
+function sampleReferencePointsInEPSG3857(refPoints, tileCorners, projectTo3857, projectTo4326) {
+    const { topLeft, topRight, bottomLeft, bottomRight } = tileCorners;
     const clampedProjectTo3857 = makeClampedForwardTo3857(projectTo3857, projectTo4326);
     const refPointPositions = [];
     for (const [relX, relY] of refPoints) {
-        const geoX = minX + relX * (maxX - minX);
-        const geoY = minY + relY * (maxY - minY);
+        const [geoX, geoY] = bilerpPoint(topLeft, topRight, bottomLeft, bottomRight, relX, relY);
         refPointPositions.push(clampedProjectTo3857(geoX, geoY));
     }
     return refPointPositions;
@@ -442,10 +395,6 @@ function sampleReferencePointsInEPSG3857(refPoints, tileBounds, projectTo3857, p
  *
  * Similar to the upstream code here:
  * https://github.com/visgl/deck.gl/blob/b0134f025148b52b91320d16768ab5d14a745328/modules/geo-layers/src/tileset-2d/tile-2d-traversal.ts#L172-L177
- *
- * @param   {number[]}  xy  [xy description]
- *
- * @return  {number}        [return description]
  */
 function rescaleEPSG3857ToCommonSpace([x, y]) {
     // Clamp Y to Web Mercator bounds
@@ -456,63 +405,14 @@ function rescaleEPSG3857ToCommonSpace([x, y]) {
     ];
 }
 /**
- * Compute the range of tile indices in a child TileMatrix that spatially
- * overlap a parent tile.
- *
- * TileMatrixSets are not guaranteed to form a strict quadtree: successive
- * TileMatrix levels may differ by non-integer refinement ratios and may not
- * align perfectly in tile space. As a result, parent/child relationships
- * cannot be inferred from zoom level or resolution alone.
- *
- * This function determines parent→child relationships by:
- * 1. Treating each TileMatrix as an independent, axis-aligned grid in CRS space
- * 2. Mapping the parent tile's CRS bounding box into the child grid
- * 3. Returning the inclusive range of child tile indices whose spatial extent
- *    intersects the parent tile
- *
- * The returned indices are clamped to the valid extents of the child matrix
- * (`[0, matrixWidth)` and `[0, matrixHeight)`).
- *
- * Assumptions:
- * - The TileMatrix grid is axis-aligned in CRS space
- * - `cornerOfOrigin` is `"topLeft"`
- * - Tiles are rectangular and uniformly sized within a TileMatrix
+ * Get tile indices visible in viewport.
  *
- * @param parentBounds  Bounding box of the parent tile in CRS coordinates
- *                      as `[minX, minY, maxX, maxY]`
- * @param childMatrix   The TileMatrix definition for the child zoom level
+ * Uses frustum culling driven by a {@link TilesetDescriptor}, which abstracts
+ * over OGC TileMatrixSet grids and Zarr multiscale pyramids.
  *
- * @returns An object containing inclusive index ranges:
- *          `{ minCol, maxCol, minRow, maxRow }`, identifying all child tiles
- *          that spatially overlap the parent tile
+ * Overview levels follow the descriptor ordering: index 0 = coarsest, higher = finer.
  */
-function getOverlappingChildRange(parentBounds, childMatrix) {
-    const [pMinX, pMinY, pMaxX, pMaxY] = parentBounds;
-    const { tileWidth, tileHeight, cellSize, matrixWidth, matrixHeight, pointOfOrigin, } = childMatrix;
-    const childTileWidthCRS = tileWidth * cellSize;
-    const childTileHeightCRS = tileHeight * cellSize;
-    // Note: we assume top left origin
-    const originX = pointOfOrigin[0];
-    const originY = pointOfOrigin[1];
-    // Convert CRS bounds → tile indices
-    let minCol = Math.floor((pMinX - originX) / childTileWidthCRS);
-    let maxCol = Math.floor((pMaxX - originX) / childTileWidthCRS);
-    let minRow = Math.floor((originY - pMaxY) / childTileHeightCRS);
-    let maxRow = Math.floor((originY - pMinY) / childTileHeightCRS);
-    // Clamp to matrix bounds
-    minCol = Math.max(0, Math.min(matrixWidth - 1, minCol));
-    maxCol = Math.max(0, Math.min(matrixWidth - 1, maxCol));
-    minRow = Math.max(0, Math.min(matrixHeight - 1, minRow));
-    maxRow = Math.max(0, Math.min(matrixHeight - 1, maxRow));
-    return { minCol, maxCol, minRow, maxRow };
-}
-/**
- * Get tile indices visible in viewport
- * Uses frustum culling similar to OSM implementation
- *
- * Overviews follow TileMatrixSet ordering: index 0 = coarsest, higher = finer
- */
-export function getTileIndices(metadata, opts) {
+export function getTileIndices(descriptor, opts) {
     const { viewport, maxZ, zRange, wgs84Bounds } = opts;
     // Only define `project` function for Globe viewports, same as upstream
     const project = viewport instanceof _GlobeViewport && viewport.resolution
@@ -551,9 +451,7 @@ export function getTileIndices(metadata, opts) {
     // In our case we want LOD to be evaluated at **all** levels, so we set the
     // minZ to 0
     const minZ = 0;
-    const { lowerLeft, upperRight } = wgs84Bounds;
-    const [minLng, minLat] = lowerLeft;
-    const [maxLng, maxLat] = upperRight;
+    const [minLng, minLat, maxLng, maxLat] = wgs84Bounds;
     const bottomLeft = lngLatToWorld([minLng, minLat]);
     const topRight = lngLatToWorld([maxLng, maxLat]);
     const bounds = [
@@ -562,19 +460,15 @@ export function getTileIndices(metadata, opts) {
         topRight[0],
         topRight[1],
     ];
-    // Start from coarsest overview
-    const rootMatrix = metadata.tileMatrices[0];
-    // Create root tiles at coarsest level
+    // Start from coarsest level
+    const rootLevel = descriptor.levels[0];
+    // Create root tiles at coarsest level.
     // In contrary to OSM tiling, we might have more than one tile at the
-    // coarsest level (z=0)
+    // coarsest level (z=0).
     const roots = [];
-    for (let y = 0; y < rootMatrix.matrixHeight; y++) {
-        for (let x = 0; x < rootMatrix.matrixWidth; x++) {
-            roots.push(new RasterTileNode(x, y, 0, {
-                metadata,
-                projectTo3857: opts.projectTo3857,
-                projectTo4326: opts.projectTo4326,
-            }));
+    for (let y = 0; y < rootLevel.matrixHeight; y++) {
+        for (let x = 0; x < rootLevel.matrixWidth; x++) {
+            roots.push(new RasterTileNode(x, y, 0, { descriptor }));
         }
     }
     // Traverse and update visibility
@@ -616,10 +510,58 @@ function getMetersPerPixelAtBoundingVolume(boundingVolume, zoom) {
     return getMetersPerPixel(lat, zoom);
 }
 /**
- * Exports only for use in testing
+ * Compute the axis-aligned bounding box of a rotated tile rectangle.
+ */
+function cornersToBounds({ topLeft, topRight, bottomLeft, bottomRight, }) {
+    const xs = [topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]];
+    const ys = [topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]];
+    return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
+}
+/**
+ * Bilinearly interpolate a 2D point over a unit square.
+ *
+ * Given four corner points of a quadrilateral, this evaluates the bilinear
+ * interpolation at normalized coordinates `(x, y)` ∈ [0, 1]². The mapping is:
+ *
+ *   p(x, y) =
+ *     p00 * (1 - x) * (1 - y) +
+ *     p10 * x       * (1 - y) +
+ *     p01 * (1 - x) * y       +
+ *     p11 * x       * y
+ *
+ * where:
+ *   - `p00` corresponds to (x=0, y=0) (top-left)
+ *   - `p10` corresponds to (x=1, y=0) (top-right)
+ *   - `p01` corresponds to (x=0, y=1) (bottom-left)
+ *   - `p11` corresponds to (x=1, y=1) (bottom-right)
+ *
+ * This performs interpolation in Euclidean space (component-wise on x/y),
+ * producing a bilinear mapping from the unit square to the quadrilateral
+ * defined by the four input points.
+ *
+ * @param p00 - Point at (0, 0), typically top-left.
+ * @param p10 - Point at (1, 0), typically top-right.
+ * @param p01 - Point at (0, 1), typically bottom-left.
+ * @param p11 - Point at (1, 1), typically bottom-right.
+ * @param x - Normalized horizontal coordinate in [0, 1].
+ * @param y - Normalized vertical coordinate in [0, 1].
+ * @returns Interpolated 2D point `[x, y]`.
+ *
+ * @remarks
+ * - Reduces to linear interpolation along edges when `x = 0/1` or `y = 0/1`.
+ * - Produces an affine mapping only if the four points form a parallelogram;
+ *   otherwise the interior mapping is bilinear (not affine).
+ * - No CRS or geodesic behavior is implied; inputs are treated as Cartesian
+ *   coordinates.
  */
-export const __TEST_EXPORTS = {
-    computeProjectedTileBounds,
-    RasterTileNode,
-};
+function bilerpPoint(p00, p10, p01, p11, x, y) {
+    const w00 = (1 - x) * (1 - y);
+    const w10 = x * (1 - y);
+    const w01 = (1 - x) * y;
+    const w11 = x * y;
+    return [
+        p00[0] * w00 + p10[0] * w10 + p01[0] * w01 + p11[0] * w11,
+        p00[1] * w00 + p10[1] * w10 + p01[1] * w01 + p11[1] * w11,
+    ];
+}
 //# sourceMappingURL=raster-tile-traversal.js.map