@developmentseed/deck.gl-geotiff 0.4.0 → 0.5.0

package/dist/multi-cog-layer.js

@@ -0,0 +1,649 @@
+import { COORDINATE_SYSTEM, CompositeLayer } from "@deck.gl/core";
+import { TileLayer } from "@deck.gl/geo-layers";
+import { PathLayer, TextLayer } from "@deck.gl/layers";
+import { createMultiTilesetDescriptor, RasterLayer, RasterTileset2D, resolveSecondaryTiles, selectSecondaryLevel, TileMatrixSetAdaptor, tilesetLevelsEqual, } from "@developmentseed/deck.gl-raster";
+import { buildCompositeBandsProps, CompositeBands, } from "@developmentseed/deck.gl-raster/gpu-modules";
+import { assembleTiles, defaultDecoderPool, generateTileMatrixSet, } from "@developmentseed/geotiff";
+import { tileTransform } from "@developmentseed/morecantile";
+import { epsgResolver as defaultEpsgResolver, makeClampedForwardTo3857, parseWkt, } from "@developmentseed/proj";
+import proj4 from "proj4";
+import { fetchGeoTIFF, getGeographicBounds } from "./geotiff/geotiff.js";
+import { fromAffine } from "./geotiff-reprojection.js";
+/** Size of deck.gl's common coordinate space in world units. */
+const TILE_SIZE = 512;
+/** The size of the globe in web mercator meters. */
+const WEB_MERCATOR_METER_CIRCUMFERENCE = 40075016.686;
+/**
+ * Scale factor for converting EPSG:3857 meters into deck.gl world units
+ * (512x512).
+ */
+const WEB_MERCATOR_TO_WORLD_SCALE = TILE_SIZE / WEB_MERCATOR_METER_CIRCUMFERENCE;
+/**
+ * Color palette for debug overlays.
+ *
+ * Index 0 is the primary tileset (red outline, white text).
+ * Indices 1+ cycle through distinct colors for secondary tilesets.
+ */
+const DEBUG_COLORS = [
+    { outline: [255, 0, 0, 255], text: [255, 255, 255, 255] }, // primary: red outline, white text
+    { outline: [0, 255, 255, 255], text: [0, 255, 255, 255] }, // cyan
+    { outline: [255, 255, 0, 255], text: [255, 255, 0, 255] }, // yellow
+    { outline: [255, 0, 255, 255], text: [255, 0, 255, 255] }, // magenta
+    { outline: [0, 255, 128, 255], text: [0, 255, 128, 255] }, // lime
+];
+const defaultProps = {
+    epsgResolver: { type: "accessor", value: defaultEpsgResolver },
+    maxError: { type: "number", value: 0.125 },
+    debug: { type: "boolean", value: false },
+    debugOpacity: { type: "number", value: 0.5 },
+    debugLevel: { type: "number", value: 1 },
+};
+/**
+ * A deck.gl {@link CompositeLayer} that opens multiple Cloud-Optimized GeoTIFFs
+ * (COGs) in parallel, builds a {@link TilesetDescriptor} for each, and groups
+ * them into a single {@link MultiTilesetDescriptor}.
+ *
+ * The finest-resolution source is automatically selected as the primary
+ * tileset, which drives the tile grid. Secondary sources are sampled at the
+ * closest matching resolution.
+ *
+ * @see {@link MultiCOGLayerProps} for accepted props.
+ * @see {@link createMultiTilesetDescriptor} for the grouping logic.
+ * @see {@link TileMatrixSetAdaptor} for the per-source tileset adapter.
+ */
+export class MultiCOGLayer extends CompositeLayer {
+    static layerName = "MultiCOGLayer";
+    static defaultProps = defaultProps;
+    initializeState() {
+        this.setState({
+            sources: null,
+            multiDescriptor: null,
+            forwardTo4326: null,
+            inverseFrom4326: null,
+            forwardTo3857: null,
+            inverseFrom3857: null,
+        });
+    }
+    updateState({ changeFlags, props, oldProps, }) {
+        if (changeFlags.dataChanged || props.sources !== oldProps.sources) {
+            // Reset state so renderLayers() returns null while we re-open COGs.
+            // Without this, the TileLayer renders with new props but stale state,
+            // caching tiles with the wrong bands.
+            this.setState({
+                sources: null,
+                multiDescriptor: null,
+            });
+            this._parseAllSources();
+        }
+    }
+    /**
+     * Open all configured COG sources in parallel, compute shared projection
+     * functions, and build the {@link MultiTilesetDescriptor}.
+     *
+     * All sources are assumed to share the same CRS; the projection of the
+     * first source is used for the shared coordinate converters.
+     *
+     * @returns Resolves when all sources have been opened and state has been set.
+     */
+    async _parseAllSources() {
+        const { sources } = this.props;
+        const entries = Object.entries(sources);
+        // Open all COGs in parallel
+        const cogSources = await Promise.all(entries.map(async ([name, config]) => {
+            const geotiff = await fetchGeoTIFF(config.url);
+            const crs = geotiff.crs;
+            const sourceProjection = typeof crs === "number"
+                ? await this.props.epsgResolver(crs)
+                : parseWkt(crs);
+            const tms = generateTileMatrixSet(geotiff, sourceProjection);
+            return { name, geotiff, tms, sourceProjection };
+        }));
+        // Use the first source's projection for shared projection functions
+        // (all sources must share the same CRS)
+        const firstCogSource = cogSources[0];
+        const sourceProjection = firstCogSource.sourceProjection;
+        // @ts-expect-error - proj4 typings are incomplete and don't support
+        // wkt-parser input
+        const converter4326 = proj4(sourceProjection, "EPSG:4326");
+        const forwardTo4326 = (x, y) => converter4326.forward([x, y], false);
+        const inverseFrom4326 = (x, y) => converter4326.inverse([x, y], false);
+        // @ts-expect-error - proj4 typings are incomplete and don't support
+        // wkt-parser input
+        const converter3857 = proj4(sourceProjection, "EPSG:3857");
+        const forwardTo3857 = makeClampedForwardTo3857((x, y) => converter3857.forward([x, y], false), forwardTo4326);
+        const inverseFrom3857 = (x, y) => converter3857.inverse([x, y], false);
+        // Build TilesetDescriptors
+        const tilesetMap = new Map();
+        const sourceMap = new Map();
+        for (const cogSource of cogSources) {
+            const descriptor = new TileMatrixSetAdaptor(cogSource.tms, {
+                projectTo4326: forwardTo4326,
+                projectTo3857: forwardTo3857,
+            });
+            tilesetMap.set(cogSource.name, descriptor);
+            sourceMap.set(cogSource.name, {
+                geotiff: cogSource.geotiff,
+                tms: cogSource.tms,
+            });
+        }
+        const multiDescriptor = createMultiTilesetDescriptor(tilesetMap);
+        this.setState({
+            sources: sourceMap,
+            multiDescriptor,
+            forwardTo4326,
+            inverseFrom4326,
+            forwardTo3857,
+            inverseFrom3857,
+        });
+        if (this.props.onGeoTIFFLoad) {
+            const primaryKey = multiDescriptor.primaryKey;
+            const primaryGeotiff = sourceMap.get(primaryKey).geotiff;
+            const geographicBounds = getGeographicBounds(primaryGeotiff, converter4326);
+            const geotiffMap = new Map();
+            for (const [name, state] of sourceMap) {
+                geotiffMap.set(name, state.geotiff);
+            }
+            this.props.onGeoTIFFLoad(geotiffMap, { primaryKey, geographicBounds });
+        }
+    }
+    /**
+     * Fetch tile data for all configured sources at the given tile index.
+     *
+     * Primary-grid sources are fetched directly at (x, y, z). Secondary
+     * sources are resolved to covering tiles at the closest matching zoom
+     * level, fetched (potentially multiple tiles), stitched if necessary,
+     * and returned with the appropriate UV transform.
+     *
+     * @param tile - Tile load props from the TileLayer, containing index and signal.
+     * @returns Per-band textures, UV transforms, and reprojection functions.
+     */
+    async _getTileData(tile) {
+        const { signal } = tile;
+        const { x, y, z } = tile.index;
+        const { multiDescriptor, sources } = this.state;
+        const pool = this.props.pool ?? defaultDecoderPool();
+        const device = this.context.device;
+        // Combine abort signals if both are defined
+        const combinedSignal = signal && this.props.signal
+            ? AbortSignal.any([signal, this.props.signal])
+            : signal || this.props.signal;
+        // Compute reprojection transforms from the primary TMS
+        const primaryKey = multiDescriptor.primaryKey;
+        const primarySource = sources.get(primaryKey);
+        const primaryTms = primarySource.tms;
+        const tileMatrix = primaryTms.tileMatrices[z];
+        const tileAffine = tileTransform(tileMatrix, { col: x, row: y });
+        const { forwardTransform, inverseTransform } = fromAffine(tileAffine);
+        const primaryLevel = multiDescriptor.primary.levels[z];
+        // Collect fetch promises for all bands
+        const bandPromises = [];
+        for (const [name, sourceState] of sources) {
+            const descriptor = name === primaryKey
+                ? multiDescriptor.primary
+                : multiDescriptor.secondaries.get(name);
+            const isPrimary = name === primaryKey ||
+                tilesetLevelsEqual(descriptor.levels[z] ?? descriptor.levels[0], primaryLevel);
+            if (isPrimary) {
+                // Primary-grid source: fetch tile directly with identity UV transform
+                bandPromises.push(this._fetchPrimaryBand(name, sourceState, {
+                    x,
+                    y,
+                    z,
+                    pool,
+                    signal: combinedSignal,
+                    device,
+                }));
+            }
+            else {
+                // Secondary source: resolve covering tiles and fetch
+                bandPromises.push(this._fetchSecondaryBand(name, sourceState, {
+                    descriptor,
+                    primaryLevel,
+                    primaryCol: x,
+                    primaryRow: y,
+                    primaryZ: z,
+                    pool,
+                    signal: combinedSignal,
+                    device,
+                    debug: this.props.debug ?? false,
+                }));
+            }
+        }
+        const bandEntries = await Promise.all(bandPromises);
+        const bands = new Map(bandEntries.map(([name, data]) => [name, data]));
+        // Collect debug info from secondary bands
+        let debugInfo;
+        if (this.props.debug) {
+            const debugBands = new Map();
+            for (const [name, , bandDebug] of bandEntries) {
+                if (bandDebug) {
+                    debugBands.set(name, bandDebug);
+                }
+            }
+            debugInfo = { bands: debugBands };
+        }
+        const byteLength = [...bands.values()].reduce((sum, band) => sum + band.byteLength, 0);
+        console.log(`Tile (${x}, ${y}, ${z}): fetched bands [${[...bands.keys()].join(", ")}], total byte length: ${byteLength}`);
+        return {
+            bands,
+            forwardTransform,
+            inverseTransform,
+            width: primaryLevel.tileWidth,
+            height: primaryLevel.tileHeight,
+            byteLength,
+            debugInfo,
+        };
+    }
+    /**
+     * Fetch a single tile for a source that shares the primary tile grid.
+     *
+     * @returns A `[name, BandTileData, null]` tuple with identity UV transform
+     *   and no debug info (primary bands don't need it).
+     */
+    async _fetchPrimaryBand(name, sourceState, opts) {
+        const { x, y, z, pool, signal, device } = opts;
+        const image = selectImage(sourceState.geotiff, z);
+        const tile = await image.fetchTile(x, y, {
+            boundless: true,
+            pool,
+            signal,
+        });
+        const texture = createBandTexture(device, tile.array);
+        const arr = tile.array;
+        const byteLength = arr.layout === "pixel-interleaved"
+            ? arr.data.byteLength
+            : arr.bands.reduce((sum, b) => sum + b.byteLength, 0);
+        return [
+            name,
+            {
+                texture,
+                uvTransform: [0, 0, 1, 1],
+                width: arr.width,
+                height: arr.height,
+                byteLength,
+            },
+            null,
+        ];
+    }
+    /**
+     * Fetch covering tiles for a secondary source and stitch them into a
+     * single texture using {@link assembleTiles}.
+     *
+     * @returns A `[name, BandTileData, BandDebugInfo | null]` tuple with the
+     *   computed UV transform and optional debug metadata.
+     */
+    async _fetchSecondaryBand(name, sourceState, opts) {
+        const { descriptor, primaryLevel, primaryCol, primaryRow, primaryZ, pool, signal, device, } = opts;
+        // Select the best secondary level
+        const primaryMpp = this.state.multiDescriptor.primary.levels[primaryZ].metersPerPixel;
+        const secondaryLevel = selectSecondaryLevel(descriptor.levels, primaryMpp);
+        const secondaryZ = descriptor.levels.indexOf(secondaryLevel);
+        // Resolve covering tile indices and UV transform
+        const resolution = resolveSecondaryTiles(primaryLevel, primaryCol, primaryRow, secondaryLevel, secondaryZ);
+        // Collect debug info if requested
+        let debugInfo = null;
+        if (opts.debug) {
+            const secondaryTileCorners = resolution.tileIndices.map((idx) => secondaryLevel.projectedTileCorners(idx.x, idx.y));
+            debugInfo = {
+                secondaryTileCorners,
+                secondaryZ,
+                uvTransform: resolution.uvTransform,
+                stitchedWidth: resolution.stitchedWidth,
+                stitchedHeight: resolution.stitchedHeight,
+                tileCount: resolution.tileIndices.length,
+                metersPerPixel: secondaryLevel.metersPerPixel,
+            };
+        }
+        // Fetch all covering tiles via fetchTiles
+        const image = selectImage(sourceState.geotiff, secondaryZ);
+        const xy = resolution.tileIndices.map((idx) => [
+            idx.x,
+            idx.y,
+        ]);
+        const tiles = await image.fetchTiles(xy, {
+            boundless: true,
+            pool,
+            signal,
+        });
+        // Assemble into a single RasterArray (handles stitching + typed array preservation)
+        const assembled = assembleTiles(tiles, {
+            width: resolution.stitchedWidth,
+            height: resolution.stitchedHeight,
+            tileWidth: secondaryLevel.tileWidth,
+            tileHeight: secondaryLevel.tileHeight,
+            minCol: resolution.minCol,
+            minRow: resolution.minRow,
+        });
+        const texture = createBandTexture(device, assembled);
+        const assembledByteLength = assembled.layout === "pixel-interleaved"
+            ? assembled.data.byteLength
+            : assembled.bands.reduce((sum, b) => sum + b.byteLength, 0);
+        return [
+            name,
+            {
+                texture,
+                uvTransform: resolution.uvTransform,
+                width: assembled.width,
+                height: assembled.height,
+                byteLength: assembledByteLength,
+            },
+            debugInfo,
+        ];
+    }
+    /**
+     * Create sub-layers for a single loaded tile.
+     *
+     * Builds a {@link RasterLayer} with reprojection functions and a render
+     * pipeline that starts with a {@link CompositeBands} module binding all
+     * band textures, followed by any user-provided pipeline modules.
+     */
+    _renderSubLayers(props, forwardTo4326, inverseFrom4326, forwardTo3857, inverseFrom3857) {
+        const { maxError, debug, debugOpacity } = this.props;
+        if (!props.data) {
+            return null;
+        }
+        const { bands, forwardTransform, inverseTransform, width, height } = props.data;
+        // Build the composite bands mapping — default to first source for R if
+        // no composite mapping is provided
+        const composite = this.props.composite ?? {
+            r: [...bands.keys()][0],
+        };
+        // Skip rendering if cached tile data doesn't have the required bands
+        // (happens when switching presets — old tiles will be re-fetched)
+        const requiredBands = [
+            composite.r,
+            composite.g,
+            composite.b,
+            composite.a,
+        ].filter((n) => n != null);
+        if (requiredBands.some((name) => !bands.has(name))) {
+            return null;
+        }
+        // Map named bands to fixed slot indices and build module props
+        const compositeBandsProps = buildCompositeBandsProps(composite, bands);
+        const renderPipeline = [
+            {
+                module: CompositeBands,
+                props: compositeBandsProps,
+            },
+            ...(this.props.renderPipeline ?? []),
+        ];
+        // Determine projection mode (globe vs web mercator)
+        const isGlobe = this.context.viewport.resolution !== undefined;
+        let reprojectionFns;
+        let deckProjectionProps;
+        if (isGlobe) {
+            reprojectionFns = {
+                forwardTransform,
+                inverseTransform,
+                forwardReproject: forwardTo4326,
+                inverseReproject: inverseFrom4326,
+            };
+            deckProjectionProps = {};
+        }
+        else {
+            reprojectionFns = {
+                forwardTransform,
+                inverseTransform,
+                forwardReproject: forwardTo3857,
+                inverseReproject: inverseFrom3857,
+            };
+            deckProjectionProps = {
+                coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+                coordinateOrigin: [TILE_SIZE / 2, TILE_SIZE / 2, 0],
+                // biome-ignore format: array
+                modelMatrix: [
+                    WEB_MERCATOR_TO_WORLD_SCALE, 0, 0, 0,
+                    0, WEB_MERCATOR_TO_WORLD_SCALE, 0, 0,
+                    0, 0, 1, 0,
+                    0, 0, 0, 1
+                ],
+            };
+        }
+        const rasterLayer = new RasterLayer(this.getSubLayerProps({
+            id: `${props.id}-raster`,
+            width,
+            height,
+            renderPipeline,
+            maxError,
+            reprojectionFns,
+            debug,
+            debugOpacity,
+            ...deckProjectionProps,
+        }));
+        const sublayers = [rasterLayer];
+        if (debug && props.data) {
+            sublayers.push(...this._renderDebugLayers(props.id, props.tile, props.data, forwardTo4326));
+        }
+        return sublayers;
+    }
+    /**
+     * Render debug overlay layers for a single tile: colored outlines for
+     * primary and secondary tile boundaries, and tiered text labels.
+     *
+     * @param tileId - Base id for sub-layer naming.
+     * @param tile - The tile header with index info.
+     * @param data - The fetched multi-tile result containing debug info.
+     * @param forwardTo4326 - Projection function for converting CRS corners to WGS84.
+     * @returns Array of PathLayer and TextLayer sub-layers.
+     */
+    _renderDebugLayers(tileId, tile, data, forwardTo4326) {
+        const layers = [];
+        const debugLevel = this.props.debugLevel ?? 1;
+        const { multiDescriptor } = this.state;
+        if (!multiDescriptor)
+            return layers;
+        const { x, y, z } = tile.index;
+        const primaryLevel = multiDescriptor.primary.levels[z];
+        if (!primaryLevel)
+            return layers;
+        // --- Primary tile outline and label ---
+        const primaryCrsCorners = primaryLevel.projectedTileCorners(x, y);
+        const { path: primaryPath, center: primaryCenter } = cornersToWgs84Path(primaryCrsCorners, forwardTo4326);
+        const primaryColor = DEBUG_COLORS[0];
+        layers.push(new PathLayer({
+            id: `${tileId}-debug-primary-outline`,
+            data: [primaryPath],
+            getPath: (d) => d,
+            getColor: primaryColor.outline,
+            getWidth: 2,
+            widthUnits: "pixels",
+            pickable: false,
+        }));
+        // Build primary label text
+        let primaryText = `x=${x} y=${y} z=${z}`;
+        if (debugLevel >= 2) {
+            primaryText += `  ${data.width}x${data.height}`;
+        }
+        if (debugLevel >= 3) {
+            primaryText += `  ${primaryLevel.metersPerPixel.toFixed(1)}m/px`;
+        }
+        // Count total label lines for vertical stacking
+        const secondaryNames = data.debugInfo
+            ? [...data.debugInfo.bands.keys()]
+            : [];
+        const totalLines = 1 + secondaryNames.length;
+        const lineSpacing = 18; // pixels
+        const topOffset = ((totalLines - 1) * lineSpacing) / 2;
+        layers.push(new TextLayer({
+            id: `${tileId}-debug-primary-label`,
+            data: [
+                {
+                    position: primaryCenter,
+                    text: primaryText,
+                },
+            ],
+            getColor: primaryColor.text,
+            getSize: 14,
+            getPixelOffset: [0, -topOffset],
+            sizeUnits: "pixels",
+            outlineWidth: 3,
+            outlineColor: [0, 0, 0, 255],
+            fontSettings: { sdf: true },
+        }));
+        // --- Secondary tile outlines and labels ---
+        if (!data.debugInfo)
+            return layers;
+        let secondaryIdx = 0;
+        for (const [name, info] of data.debugInfo.bands) {
+            const colorEntry = DEBUG_COLORS[1 + (secondaryIdx % (DEBUG_COLORS.length - 1))];
+            // Draw outline for each secondary tile
+            for (let i = 0; i < info.secondaryTileCorners.length; i++) {
+                const { path: secondaryPath } = cornersToWgs84Path(info.secondaryTileCorners[i], forwardTo4326);
+                layers.push(new PathLayer({
+                    id: `${tileId}-debug-${name}-outline-${i}`,
+                    data: [secondaryPath],
+                    getPath: (d) => d,
+                    getColor: colorEntry.outline,
+                    getWidth: 2,
+                    widthUnits: "pixels",
+                    pickable: false,
+                }));
+            }
+            // Build secondary label text
+            const mpp = info.metersPerPixel.toFixed(1);
+            let labelText = `${name}: ${mpp}m z=${info.secondaryZ}`;
+            if (debugLevel >= 2) {
+                const uv = info.uvTransform;
+                labelText += `  uv=[${uv.map((v) => v.toFixed(2)).join(",")}]  ${info.tileCount} tiles`;
+            }
+            if (debugLevel >= 3) {
+                labelText += `  stitch=${info.stitchedWidth}x${info.stitchedHeight}`;
+            }
+            const lineOffset = -topOffset + (1 + secondaryIdx) * lineSpacing;
+            layers.push(new TextLayer({
+                id: `${tileId}-debug-${name}-label`,
+                data: [
+                    {
+                        position: primaryCenter,
+                        text: labelText,
+                    },
+                ],
+                getColor: colorEntry.text,
+                getSize: 12,
+                getPixelOffset: [0, lineOffset],
+                sizeUnits: "pixels",
+                outlineWidth: 2,
+                outlineColor: [0, 0, 0, 255],
+                fontSettings: { sdf: true },
+            }));
+            secondaryIdx++;
+        }
+        return layers;
+    }
+    /**
+     * Build the tile layer that drives tile traversal and rendering.
+     *
+     * Creates a {@link RasterTileset2D} factory from the primary tileset,
+     * then returns a {@link TileLayer} wired up with tile fetching and
+     * sub-layer rendering.
+     */
+    renderTileLayer(multiDescriptor, forwardTo4326, inverseFrom4326, forwardTo3857, inverseFrom3857) {
+        const { primary } = multiDescriptor;
+        // Create a factory class that wraps RasterTileset2D with the primary descriptor
+        class PrimaryTilesetFactory extends RasterTileset2D {
+            constructor(opts) {
+                super(opts, primary, {
+                    projectTo4326: forwardTo4326,
+                });
+            }
+        }
+        const { maxRequests, maxCacheSize, maxCacheByteSize, debounceTime, refinementStrategy, } = this.props;
+        // Stringify sources to detect when the set of COG URLs changes.
+        // This triggers TileLayer to invalidate its cache and re-fetch.
+        const sourceKeys = Object.keys(this.props.sources).sort().join(",");
+        const sourceUrls = Object.values(this.props.sources)
+            .map((s) => String(s.url))
+            .sort()
+            .join(",");
+        return new TileLayer({
+            id: `multi-cog-tile-layer-${this.id}-${sourceUrls}`,
+            TilesetClass: PrimaryTilesetFactory,
+            getTileData: async (tile) => this._getTileData(tile),
+            renderSubLayers: (props) => this._renderSubLayers(props, forwardTo4326, inverseFrom4326, forwardTo3857, inverseFrom3857),
+            updateTriggers: {
+                getTileData: [sourceKeys, sourceUrls],
+            },
+            debounceTime,
+            maxCacheByteSize,
+            maxCacheSize,
+            maxRequests,
+            refinementStrategy,
+        });
+    }
+    renderLayers() {
+        const { multiDescriptor, forwardTo4326, inverseFrom4326, forwardTo3857, inverseFrom3857, } = this.state;
+        if (!multiDescriptor ||
+            !forwardTo4326 ||
+            !inverseFrom4326 ||
+            !forwardTo3857 ||
+            !inverseFrom3857) {
+            return null;
+        }
+        return this.renderTileLayer(multiDescriptor, forwardTo4326, inverseFrom4326, forwardTo3857, inverseFrom3857);
+    }
+}
+/**
+ * Select the correct GeoTIFF image (full-res or overview) for a zoom level.
+ *
+ * z=0 is the coarsest overview, z=max is full resolution.
+ */
+function selectImage(geotiff, z) {
+    const images = [geotiff, ...geotiff.overviews];
+    return images[images.length - 1 - z];
+}
+/**
+ * Create a GPU texture from a {@link RasterArray}.
+ *
+ * Infers the texture format from the typed array type. Currently supports
+ * single-band `Uint8Array` (`r8unorm`) and `Uint16Array` (`r16unorm`).
+ *
+ * TODO: use `inferTextureFormat` from `texture.ts` for full format support.
+ */
+function createBandTexture(device, array) {
+    if (array.layout !== "pixel-interleaved") {
+        throw new Error("Band-separate layout not yet supported in MultiCOGLayer");
+    }
+    const { data, width, height } = array;
+    let format;
+    if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
+        format = "r8unorm";
+    }
+    else if (data instanceof Uint16Array) {
+        format = "r16unorm";
+    }
+    else {
+        throw new Error(`Unsupported typed array type: ${data.constructor.name}. ` +
+            "Currently only Uint8Array and Uint16Array are supported.");
+    }
+    return device.createTexture({
+        data,
+        format,
+        width,
+        height,
+        sampler: { minFilter: "linear", magFilter: "linear" },
+    });
+}
+/**
+ * Project CRS tile corners to WGS84 and return a closed path suitable for
+ * PathLayer, plus the center point for label placement.
+ *
+ * @param corners - Tile corners in the source CRS.
+ * @param projectTo4326 - Projection function from source CRS to WGS84.
+ * @returns A closed `[topLeft, topRight, bottomRight, bottomLeft, topLeft]`
+ *   path and the geographic center.
+ */
+function cornersToWgs84Path(corners, projectTo4326) {
+    const topLeft = projectTo4326(corners.topLeft[0], corners.topLeft[1]);
+    const topRight = projectTo4326(corners.topRight[0], corners.topRight[1]);
+    const bottomRight = projectTo4326(corners.bottomRight[0], corners.bottomRight[1]);
+    const bottomLeft = projectTo4326(corners.bottomLeft[0], corners.bottomLeft[1]);
+    return {
+        path: [topLeft, topRight, bottomRight, bottomLeft, topLeft],
+        center: [
+            (topLeft[0] + bottomRight[0]) / 2,
+            (topLeft[1] + bottomRight[1]) / 2,
+        ],
+    };
+}
+//# sourceMappingURL=multi-cog-layer.js.map