bruce-cesium 7.2.2 → 7.2.3

package/dist/lib/rendering/texture-frame-series-animator.js

@@ -6,38 +6,221 @@ const Cesium = require("cesium");
 const image_utils_1 = require("../internal/image-utils");
 var TextureFrameSeriesAnimator;
 (function (TextureFrameSeriesAnimator) {
-    // Values are measured up from the ground beneath them.
-    TextureFrameSeriesAnimator.QUANTITY_THICKNESS = "thickness";
-    // Values are heights against a vertical datum, so they need that datum to be placed.
-    TextureFrameSeriesAnimator.QUANTITY_ELEVATION = "elevation";
     TextureFrameSeriesAnimator.LAYOUT_TILES = "tiles";
+    // The only generation this renderer draws. Anything else is refused rather than half read: the
+    // shapes differ enough that a partial reading produces a plausible wrong surface, which is worse
+    // than an empty one.
+    TextureFrameSeriesAnimator.SUPPORTED_VERSION = 3;
+    // Value in R at 8 bits, or high in R and low in G at 16.
+    TextureFrameSeriesAnimator.FORMAT_U8 = "u8";
+    TextureFrameSeriesAnimator.FORMAT_RG16 = "rg16";
+    // Declared as a field with one value, so a second mode can be added later without an absent
+    // Encoding having to mean anything.
+    TextureFrameSeriesAnimator.ENCODING_ABSOLUTE = "absolute";
+    TextureFrameSeriesAnimator.LAYER_VALUE = "Value";
+    TextureFrameSeriesAnimator.LAYER_VALUE_MIN = "ValueMin";
+    TextureFrameSeriesAnimator.LAYER_VALUE_MAX = "ValueMax";
+    TextureFrameSeriesAnimator.LAYER_BASELINE = "Baseline";
+    // The per-texel correction that was applied, published only on an archive that was transformed.
+    TextureFrameSeriesAnimator.LAYER_VALUE_SHIFT = "ValueShift";
     /**
-     * The generator that produced an archive, for telling a stale one from a current one.
+     * Turns a published value map into the flat shape this renderer works in, or null when it cannot be drawn.
+     * @param published the archive's Data.generation
+     */
+    function Adapt(published) {
+        if (!published || published.Version !== TextureFrameSeriesAnimator.SUPPORTED_VERSION) {
+            const found = published && published.Version != null ? published.Version : "none";
+            const at = published && published.Identity ? published.Identity.Generated : undefined;
+            // In theory should be no files.
+            console.warn("bruce-cesium: value map version " + found + " is not supported (this build reads "
+                + TextureFrameSeriesAnimator.SUPPORTED_VERSION + "), so nothing will be drawn for it."
+                + (at ? " The archive was generated at " + at + " and needs regenerating." : ""));
+            return null;
+        }
+        const geometry = published.Geometry || {};
+        const tiles = published.Tiles || [];
+        if (geometry.Layout !== TextureFrameSeriesAnimator.LAYOUT_TILES || tiles.length === 0) {
+            const at = published.Identity ? published.Identity.Generated : undefined;
+            console.warn("bruce-cesium: value map declares no tiles, so nothing will be drawn for it."
+                + (at ? " The archive was generated at " + at + " and needs regenerating." : ""));
+            return null;
+        }
+        const value = published.Value || {};
+        if (value.Encoding && value.Encoding !== TextureFrameSeriesAnimator.ENCODING_ABSOLUTE) {
+            const at = published.Identity ? published.Identity.Generated : undefined;
+            console.warn("bruce-cesium: value map encoding " + value.Encoding + " is not supported"
+                + " (this build reads " + TextureFrameSeriesAnimator.ENCODING_ABSOLUTE + "), so nothing will be drawn for it."
+                + (at ? " The archive was generated at " + at + " and needs regenerating." : ""));
+            return null;
+        }
+        const series = published.Series || {};
+        const layerRange = declaredRange(published, TextureFrameSeriesAnimator.LAYER_VALUE_MIN);
+        const flat = {
+            Frames: [],
+            ValueMin: value.Min,
+            ValueMax: value.Max,
+            Format: value.Format || TextureFrameSeriesAnimator.FORMAT_U8,
+            Encoding: value.Encoding || TextureFrameSeriesAnimator.ENCODING_ABSOLUTE,
+            Units: value.Units,
+            West: geometry.West,
+            East: geometry.East,
+            South: geometry.South,
+            North: geometry.North,
+            ResolutionX: geometry.ResolutionX,
+            ResolutionY: geometry.ResolutionY,
+            PixelPlacement: geometry.PixelPlacement,
+            Times: series.Times,
+            ExtremesValueMin: layerRange ? layerRange.min : undefined,
+            ExtremesValueMax: layerRange ? layerRange.max : undefined,
+            // The delivered values are what gets drawn. What the source called them, and any shift
+            // applied on the way, travel for labels and analysis rather than for placement.
+            SourceVerticalDatum: published.ValueSource ? published.ValueSource.VerticalDatum : undefined,
+            Transform: published.ValueSource ? published.ValueSource.Transform : undefined,
+            SourceUnits: published.ValueSource ? published.ValueSource.Units : undefined,
+            SourceValueMin: published.ValueSource ? published.ValueSource.Min : undefined,
+            SourceValueMax: published.ValueSource ? published.ValueSource.Max : undefined
+        };
+        flat.Tiles = tiles.map((tile) => adaptTile(tile, series.Times));
+        // The coarsest tile covers the whole extent, so it is what a caller wanting one time list reads.
+        flat.Frames = flat.Tiles[0].Frames;
+        warnIfUnshifted(published, flat);
+        return flat;
+    }
+    TextureFrameSeriesAnimator.Adapt = Adapt;
+    /*
+     * Says so when an archive's heights are not on the ellipsoid they will be drawn against.
+     */
+    function warnIfUnshifted(published, flat) {
+        const datum = flat.SourceVerticalDatum;
+        if (!datum || datum === TextureFrameSeriesAnimator.DATUM_ELLIPSOIDAL || flat.Transform) {
+            return;
+        }
+        const at = published.Identity ? published.Identity.Generated : undefined;
+        console.warn("bruce-cesium: value map heights are in " + datum + " and report no transform, so"
+            + " they are not ellipsoidal and will draw at the wrong height when placed absolutely."
+            + (at ? " The archive was generated at " + at + " and needs regenerating with the shift"
+                + " applied." : ""));
+    }
+    /*
+     * The Min and Max a named layer declares, since a statistics layer is encoded over the true data
+     * range rather than over the frames' own.
+     */
+    function declaredRange(published, name) {
+        const layers = published.Layers || [];
+        for (const layer of layers) {
+            if (layer.Name === name && typeof layer.Min === "number" && typeof layer.Max === "number") {
+                return { min: layer.Min, max: layer.Max };
+            }
+        }
+        return null;
+    }
+    /*
+     * One tile, with its per-time value rasters lined up against the shared time list.
+     */
+    function adaptTile(tile, times) {
+        const layers = tile.Layers || {};
+        const perTime = layers[TextureFrameSeriesAnimator.LAYER_VALUE] || [];
+        const frames = perTime.map((entry, index) => ({
+            Timestamp: times && times[index] ? times[index] : "",
+            ByteOffset: entry.Bytes.Offset,
+            ByteLength: entry.Bytes.Length
+        }));
+        return {
+            Level: tile.Level,
+            X: tile.X,
+            Y: tile.Y,
+            West: tile.West,
+            East: tile.East,
+            South: tile.South,
+            North: tile.North,
+            TexelMetres: tile.TexelMetres,
+            ResolutionX: tile.ResolutionX,
+            ResolutionY: tile.ResolutionY,
+            Frames: frames,
+            Floor: single(layers[TextureFrameSeriesAnimator.LAYER_VALUE_MIN]),
+            Ceiling: single(layers[TextureFrameSeriesAnimator.LAYER_VALUE_MAX]),
+            BaselineMask: single(layers[TextureFrameSeriesAnimator.LAYER_BASELINE])
+        };
+    }
+    function single(layer) {
+        if (!layer || !layer.Bytes) {
+            return undefined;
+        }
+        return { ByteOffset: layer.Bytes.Offset, ByteLength: layer.Bytes.Length };
+    }
+    /**
+     * How to turn a delivered value into the number the source published, or null when the archive
+     * does not say enough to do it.
+     * @param metadata the archive's Data.generation
+     */
+    function SourceMap(metadata) {
+        if (!metadata) {
+            return null;
+        }
+        const { ValueMin, ValueMax, SourceValueMin, SourceValueMax } = metadata;
+        if (typeof ValueMin !== "number" || typeof ValueMax !== "number"
+            || typeof SourceValueMin !== "number" || typeof SourceValueMax !== "number") {
+            return null;
+        }
+        const delivered = ValueMax - ValueMin;
+        // A single delivered value describes no line, so all that can be recovered is where it sits.
+        const scale = delivered !== 0 ? (SourceValueMax - SourceValueMin) / delivered : 1;
+        return { scale, offset: SourceValueMin - ValueMin * scale };
+    }
+    TextureFrameSeriesAnimator.SourceMap = SourceMap;
+    /**
+     * A delivered value in the source's own terms, or unchanged when it cannot be turned back.
+     * @param map from SourceMap(), null when the archive does not say enough
+     */
+    function ToSource(map, value) {
+        return map ? value * map.scale + map.offset : value;
+    }
+    TextureFrameSeriesAnimator.ToSource = ToSource;
+    /**
+     * Whether the archive's frames carry a 16 bit value packed across R and G.
      *
-     * Read the version rather than sniffing for fields: an archive can legitimately omit Tiles or
-     * GeoidSeparation and still be current, so their absence says nothing about its age.
+     * Every consumer that reads a texel has to ask: taking R alone from a packed frame yields a
+     * plausible surface quantised to 255 steps of the full range rather than an obvious failure.
      * @param metadata the archive's Data.generation
      */
-    function GeneratorVersion(metadata) {
-        if (!metadata || typeof metadata.GeneratorVersion !== "number") {
-            return 1;
+    function IsPackedValue(metadata) {
+        return Boolean(metadata && metadata.Format === TextureFrameSeriesAnimator.FORMAT_RG16);
+    }
+    TextureFrameSeriesAnimator.IsPackedValue = IsPackedValue;
+    /**
+     * The normalised 0 to 1 value at a texel, from whichever format the archive packed it in.
+     * @param metadata the archive's Data.generation
+     * @param pixels untinted RGBA value pixels
+     * @param at index of the texel's red channel
+     */
+    function NormalisedAt(metadata, pixels, at) {
+        if (IsPackedValue(metadata)) {
+            return (pixels[at] * 256 + pixels[at + 1]) / 65535;
         }
-        return metadata.GeneratorVersion;
+        return pixels[at] / 255;
+    }
+    TextureFrameSeriesAnimator.NormalisedAt = NormalisedAt;
+    // Values already sit on the ellipsoid Cesium measures against, so nothing is added to place them.
+    TextureFrameSeriesAnimator.DATUM_ELLIPSOIDAL = "WGS84";
+    /**
+     * Whether the values are heights against a vertical datum rather than a thickness.
+     *
+     * A thickness rises from wherever the polygon sits and a height already knows where it belongs, so
+     * this is what decides whether the polygon's own altitude may be added underneath it.
+     * @param metadata the archive's Data.generation
+     */
+    function IsDatumHeight(metadata) {
+        return Boolean(metadata && metadata.SourceVerticalDatum);
     }
-    TextureFrameSeriesAnimator.GeneratorVersion = GeneratorVersion;
+    TextureFrameSeriesAnimator.IsDatumHeight = IsDatumHeight;
     /**
-     * Whether an archive is an adaptive pyramid rather than one raster.
+     * The archive's tiles, which Adapt() guarantees are present.
      * @param metadata the archive's Data.generation
      */
-    function IsTiledLayout(metadata) {
-        return (Boolean(metadata && metadata.Layout === TextureFrameSeriesAnimator.LAYOUT_TILES &&
-            metadata.Tiles && metadata.Tiles.length > 0));
+    function TilesOf(metadata) {
+        return (metadata && metadata.Tiles) || [];
     }
-    TextureFrameSeriesAnimator.IsTiledLayout = IsTiledLayout;
-    // Frames carry the value as the source reported it.
-    TextureFrameSeriesAnimator.MEASURE_ABSOLUTE = "absolute";
-    // Frames carry the value minus each cell's own minimum over the series.
-    TextureFrameSeriesAnimator.MEASURE_ANOMALY = "anomaly";
+    TextureFrameSeriesAnimator.TilesOf = TilesOf;
     /**
      * Turns a value in the attribute's own units into the 0 to 1 position the ramp is indexed by.
      *
@@ -56,44 +239,18 @@ var TextureFrameSeriesAnimator;
         return Math.min(1, Math.max(0, (value - lo) / span));
     }
     TextureFrameSeriesAnimator.NormalisePosition = NormalisePosition;
-    /**
-     * Whether the frames are a departure from each cell's own normal rather than a raw reading.
-     *
-     * Worth asking before labelling anything: the two measures need different words for the same
-     * number, and calling an anomaly "water depth" is a worse error than the coarse ramp it replaced.
-     * @param metadata the archive's Data.generation
-     */
-    function IsAnomalyMeasure(metadata) {
-        return Boolean(metadata && metadata.Measure === TextureFrameSeriesAnimator.MEASURE_ANOMALY);
-    }
-    TextureFrameSeriesAnimator.IsAnomalyMeasure = IsAnomalyMeasure;
-    /**
-     * How much the value moves anywhere in the series, in source units.
-     *
-     * Falls back to the published range, which is the right answer for an anomaly archive (its range
-     * IS the movement) and the only available one for an archive predating AnomalyMax.
-     * @param metadata the archive's Data.generation
-     */
-    function MovingRange(metadata) {
-        if (!metadata) {
-            return undefined;
-        }
-        if (typeof metadata.AnomalyMax === "number" && metadata.AnomalyMax > 0) {
-            return metadata.AnomalyMax;
-        }
-        if (typeof metadata.ValueMin === "number" && typeof metadata.ValueMax === "number") {
-            return Math.abs(metadata.ValueMax - metadata.ValueMin);
-        }
-        return undefined;
-    }
-    TextureFrameSeriesAnimator.MovingRange = MovingRange;
     /**
      * Detects whether a ClientFile's `Data.generation` metadata describes a frame archive rather than a single static image,
      * so a caller can decide whether to construct an Animator or fall back to the existing static-texture path.
-     * @param data ClientFile.Data (the `IFile.Data` field), as returned by ClientFile.Get().
+     * @param data ClientFile.Data
      */
     function IsFrameArchiveMetadata(data) {
-        return Boolean(data && data.generation && Array.isArray(data.generation.Frames) && data.generation.Frames.length > 0);
+        const generation = data && data.generation;
+        if (!generation) {
+            return false;
+        }
+        return (typeof generation.Version === "number" ||
+            (Array.isArray(generation.Frames) && generation.Frames.length > 0));
     }
     TextureFrameSeriesAnimator.IsFrameArchiveMetadata = IsFrameArchiveMetadata;
     // First resolvable static number out of a calculator field list, since that is all a border needs.
@@ -139,10 +296,27 @@ var TextureFrameSeriesAnimator;
     TextureFrameSeriesAnimator.AppearanceSignature = AppearanceSignature;
     const MAX_COMPOSITE_TEXELS = 2048;
     const VALUE_DILATE_PASSES = 2;
+    /*
+     * Rewrites a packed 16 bit value as the 8 bit grey the colour ramps index on.
+     *
+     * All three channels, since a ramp is free to read any of them and a leftover low byte in G would
+     * show up as a green cast on the one that reads them all.
+     */
+    function flattenPacked(pixels, packed) {
+        if (!packed) {
+            return;
+        }
+        for (let i = 0; i < pixels.length; i += 4) {
+            const grey = Math.round((pixels[i] * 256 + pixels[i + 1]) / 65535 * 255);
+            pixels[i] = grey;
+            pixels[i + 1] = grey;
+            pixels[i + 2] = grey;
+        }
+    }
     /*
      * Bleeds covered values outward into uncovered texels, leaving alpha untouched.
      */
-    function dilateValues(value, width, height, passes) {
+    function dilateValues(value, width, height, passes, packed) {
         const texels = width * height;
         const filled = new Uint8Array(texels);
         for (let p = 0; p < texels; p++) {
@@ -166,15 +340,25 @@ var TextureFrameSeriesAnimator;
                             if (nx < 0 || ny < 0 || nx >= width || ny >= height || !wasFilled[ny * width + nx]) {
                                 continue;
                             }
-                            sum += source[(ny * width + nx) * 4];
+                            const at = (ny * width + nx) * 4;
+                            // Averaged as a value rather than per byte: averaging a packed low byte
+                            // on its own wraps at every 256th step and speckles the bled edge.
+                            sum += packed ? source[at] * 256 + source[at + 1] : source[at];
                             hits++;
                         }
                     }
                     if (hits > 0) {
                         const v = Math.round(sum / hits);
-                        value[p * 4] = v;
-                        value[p * 4 + 1] = v;
-                        value[p * 4 + 2] = v;
+                        if (packed) {
+                            value[p * 4] = (v >> 8) & 255;
+                            value[p * 4 + 1] = v & 255;
+                            value[p * 4 + 2] = 0;
+                        }
+                        else {
+                            value[p * 4] = v;
+                            value[p * 4 + 1] = v;
+                            value[p * 4 + 2] = v;
+                        }
                         filled[p] = 1;
                     }
                 }
@@ -212,7 +396,6 @@ var TextureFrameSeriesAnimator;
             // forcing Cesium to re-upload the texture only when something changed.
             this.pool = [document.createElement("canvas"), document.createElement("canvas")];
             this.poolIdx = 0;
-            this.scratch = null;
             this.valueDims = null;
             this.presentVersion = 0;
             this.extremesLoad = null;
@@ -235,7 +418,7 @@ var TextureFrameSeriesAnimator;
             this.highColor = (mask && bruce_models_1.Color.ColorFromStr(mask.maxColor)) || DEFAULT_HIGH_COLOR;
             // Positions are authored in the attribute's units and normalised once here, so the
             // per-pixel loop stays a comparison against 0 to 1 like the two-colour path.
-            const points = mask === null || mask === void 0 ? void 0 : mask.points;
+            const points = mask && mask.points;
             this.rampStops = (points && points.length > 0)
                 ? points.map((p) => ({
                     position: NormalisePosition(options.metadata, p.position),
@@ -261,9 +444,8 @@ var TextureFrameSeriesAnimator;
             this.produceValueCanvas = Boolean(options.produceValueCanvas);
             this.metadata = options.metadata;
             this.drapeExtent = options.drapeExtent;
-            this.tiles = IsTiledLayout(options.metadata) ? options.metadata.Tiles : undefined;
-            this.baselineMaskEntry = options.baselineMask || null;
-            this.maskBaseline = (_c = options.maskBaseline) !== null && _c !== void 0 ? _c : Boolean(options.baselineMask);
+            this.tiles = TilesOf(options.metadata);
+            this.maskBaseline = (_c = options.maskBaseline) !== null && _c !== void 0 ? _c : this.tiles.some((tile) => Boolean(tile.BaselineMask));
             this.valueCanvas = this.produceValueCanvas ? document.createElement("canvas") : null;
             this.driveMaterial = options.driveMaterial !== false;
             this.originalMaterial = options.entity.polygon.material;
@@ -439,32 +621,20 @@ var TextureFrameSeriesAnimator;
         }
         async fetchAndTint(idx) {
             const tiles = this.tiles;
-            let buffer;
-            let span = 0;
-            if (tiles) {
-                // Every tile's frame for one timestep sits contiguously, because the generator writes
-                // frame major. So a tiled frame is still ONE range request, not one per tile.
-                let lo = Number.MAX_SAFE_INTEGER;
-                let hi = 0;
-                for (const tile of tiles) {
-                    const at = tile.Frames[idx];
-                    if (!at) {
-                        continue;
-                    }
-                    lo = Math.min(lo, at.ByteOffset);
-                    hi = Math.max(hi, at.ByteOffset + at.ByteLength);
+            // Every tile's frame for one timestep sits contiguously, because the generator writes
+            // frame major. So a tiled frame is still ONE range request, not one per tile.
+            let lo = Number.MAX_SAFE_INTEGER;
+            let hi = 0;
+            for (const tile of tiles) {
+                const at = tile.Frames[idx];
+                if (!at) {
+                    continue;
                 }
-                span = lo;
-                const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${lo}-${hi - 1}` } });
-                buffer = await response.arrayBuffer();
-            }
-            else {
-                const entry = this.frames[idx];
-                const start = entry.ByteOffset;
-                const end = entry.ByteOffset + entry.ByteLength - 1;
-                const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } });
-                buffer = await response.arrayBuffer();
+                lo = Math.min(lo, at.ByteOffset);
+                hi = Math.max(hi, at.ByteOffset + at.ByteLength);
             }
+            const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${lo}-${hi - 1}` } });
+            const buffer = await response.arrayBuffer();
             if (this.disposed) {
                 return;
             }
@@ -474,9 +644,7 @@ var TextureFrameSeriesAnimator;
             if (this.disposed) {
                 return;
             }
-            const decoded = tiles
-                ? await this.composeTiles(tiles, idx, buffer, span)
-                : await this.decodeAndTint(buffer);
+            const decoded = await this.composeTiles(tiles, idx, buffer, lo);
             if (this.disposed) {
                 return;
             }
@@ -487,26 +655,6 @@ var TextureFrameSeriesAnimator;
                 this.beginCrossfadeTo(idx);
             }
         }
-        /**
-         * Decodes one frame's raw PNG bytes (as returned by a Range GET) and applies the grayscale color mask.
-         */
-        async decodeAndTint(buffer) {
-            const blob = new Blob([buffer], { type: "image/png" });
-            const objectUrl = URL.createObjectURL(blob);
-            let image;
-            try {
-                image = await (0, image_utils_1.loadImage)(objectUrl);
-            }
-            finally {
-                URL.revokeObjectURL(objectUrl);
-            }
-            const canvas = document.createElement("canvas");
-            canvas.width = image.width;
-            canvas.height = image.height;
-            const ctx = canvas.getContext("2d");
-            ctx.drawImage(image, 0, 0);
-            return this.tint(ctx.getImageData(0, 0, canvas.width, canvas.height));
-        }
         /*
          * Draws every tile of one frame into a single raster covering the drape extent.
          */
@@ -579,6 +727,10 @@ var TextureFrameSeriesAnimator;
             // Copied before tinting: the ramp is a lerp between two colours, so the value cannot be
             // recovered from the tinted pixels afterwards.
             const valuePixels = this.produceValueCanvas ? new Uint8ClampedArray(imageData.data) : undefined;
+            // The ramp indexes on R as an 8 bit grey, so a packed frame is flattened to one here
+            // rather than teaching every ramp function a second format.
+            // The copy above keeps the packed pair, which is what displacement and labels read.
+            flattenPacked(imageData.data, IsPackedValue(this.metadata));
             // Stops win when supplied: they can express a band and a hidden floor, which a two
             // colour ramp cannot. The pair stays the fallback so an older style still draws.
             if (this.rampStops && this.rampStops.length > 0) {
@@ -592,72 +744,20 @@ var TextureFrameSeriesAnimator;
             }
             this.applyBaselineMask(imageData.data, valuePixels, canvas.width, canvas.height);
             if (valuePixels) {
-                dilateValues(valuePixels, canvas.width, canvas.height, VALUE_DILATE_PASSES);
+                dilateValues(valuePixels, canvas.width, canvas.height, VALUE_DILATE_PASSES, IsPackedValue(this.metadata));
             }
             return { pixels: imageData.data, width: canvas.width, height: canvas.height, valuePixels };
         }
         /*
-         * Paints one frame's pixels onto a canvas, resampled into the drape extent when there is one.
+         * Paints one frame's composited pixels onto a canvas.
          */
         writeInto(canvas, pixels, dims) {
-            const rect = this.sourceRect(dims);
-            if (!rect) {
-                canvas.width = dims.width;
-                canvas.height = dims.height;
-                const direct = canvas.getContext("2d");
-                const image = direct.createImageData(dims.width, dims.height);
-                image.data.set(pixels);
-                direct.putImageData(image, 0, 0);
-                return;
-            }
-            if (!this.scratch) {
-                this.scratch = document.createElement("canvas");
-            }
-            this.scratch.width = dims.width;
-            this.scratch.height = dims.height;
-            const scratchCtx = this.scratch.getContext("2d");
-            const image = scratchCtx.createImageData(dims.width, dims.height);
-            image.data.set(pixels);
-            scratchCtx.putImageData(image, 0, 0);
             canvas.width = dims.width;
             canvas.height = dims.height;
             const ctx = canvas.getContext("2d");
-            // Nearest neighbour: a value texel has to survive the resample exactly, or a label reads
-            // a blend of two cells rather than the cell it points at.
-            ctx.imageSmoothingEnabled = false;
-            ctx.clearRect(0, 0, dims.width, dims.height);
-            ctx.drawImage(this.scratch, rect.x, rect.y, rect.width, rect.height, 0, 0, dims.width, dims.height);
-        }
-        /*
-         * The part of the archive raster that the drape extent covers, in source pixels.
-         */
-        sourceRect(dims) {
-            const drape = this.drapeExtent;
-            const m = this.metadata;
-            // A composited frame was drawn into the drape extent already, so resampling it again
-            // would apply the same correction twice.
-            if (this.tiles) {
-                return null;
-            }
-            if (!drape || !m || m.West == null || m.East == null || m.South == null || m.North == null) {
-                return null;
-            }
-            const spanLon = m.East - m.West;
-            const spanLat = m.North - m.South;
-            if (!(spanLon > 0) || !(spanLat > 0)) {
-                return null;
-            }
-            const x = (drape.West - m.West) / spanLon * dims.width;
-            const width = (drape.East - drape.West) / spanLon * dims.width;
-            const y = (m.North - drape.North) / spanLat * dims.height;
-            const height = (drape.North - drape.South) / spanLat * dims.height;
-            // A drape that already matches the archive is the common case and must not pay for a
-            // resample, nor lose a half pixel to rounding.
-            if (Math.abs(x) < 0.01 && Math.abs(y) < 0.01
-                && Math.abs(width - dims.width) < 0.01 && Math.abs(height - dims.height) < 0.01) {
-                return null;
-            }
-            return { x, y, width, height };
+            const image = ctx.createImageData(dims.width, dims.height);
+            image.data.set(pixels);
+            ctx.putImageData(image, 0, 0);
         }
         /**
          * The archive's per-cell floor and ceiling rasters, once EnsureExtremes has resolved.
@@ -669,45 +769,16 @@ var TextureFrameSeriesAnimator;
          * Fetches and decodes the floor and ceiling rasters, at most once.
          */
         EnsureExtremes() {
-            if (this.extremesLoad) {
-                return this.extremesLoad;
-            }
-            if (this.tiles) {
+            if (!this.extremesLoad) {
                 this.extremesLoad = this.loadTiledExtremes();
-                return this.extremesLoad;
             }
-            const floor = this.metadata && this.metadata.Floor;
-            const ceiling = this.metadata && this.metadata.Ceiling;
-            if (!floor && !ceiling) {
-                this.extremesLoad = Promise.resolve();
-                return this.extremesLoad;
-            }
-            this.extremesLoad = Promise.all([
-                floor ? this.loadImageDataAt(floor) : Promise.resolve(null),
-                ceiling ? this.loadImageDataAt(ceiling) : Promise.resolve(null)
-            ]).then(([f, c]) => {
-                if (this.disposed) {
-                    return;
-                }
-                this.floorPixels = f;
-                this.ceilingPixels = c;
-            }).catch((e) => {
-                // Missing extremes cost a label its range, and must not take the animation with them.
-                console.warn("TextureFrameSeriesAnimator: could not load the extremes rasters.", e);
-            });
             return this.extremesLoad;
         }
         /*
          * Composites each tile's baseline mask into one covering the composited frames.
-         *
-         * A tiled archive publishes the mask per tile, so reading the archive level BaselineMask
-         * finds nothing and hiding dry cells silently does nothing at all.
          */
         async loadTiledBaselineMask() {
             const tiles = this.tiles;
-            if (!tiles) {
-                return;
-            }
             const entries = tiles.map((tile) => tile.BaselineMask);
             let lo = Number.MAX_SAFE_INTEGER;
             let hi = 0;
@@ -761,14 +832,11 @@ var TextureFrameSeriesAnimator;
         /*
          * Composites each tile's floor and ceiling into rasters matching the composited frames.
          *
-         * A tiled archive has no whole-extent extremes to fetch, only per-tile ones, and a label
-         * indexes them by the same texel as the value canvas, so they have to be laid out the same way.
+         * A label indexes them by the same texel as the value canvas, so they have to be laid out the
+         * same way rather than fetched as whole-extent rasters.
          */
         async loadTiledExtremes() {
             const tiles = this.tiles;
-            if (!tiles) {
-                return;
-            }
             const target = this.compositeExtent();
             const size = this.compositeSize(tiles, target);
             // One request for the whole extremes block. They sit contiguously after the frames, so
@@ -863,70 +931,6 @@ var TextureFrameSeriesAnimator;
                 }
             }));
         }
-        /*
-         * Range GETs one entry and decodes it to an image.
-         */
-        async loadImageAt(entry) {
-            const start = entry.ByteOffset;
-            const end = entry.ByteOffset + entry.ByteLength - 1;
-            const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } });
-            const buffer = await response.arrayBuffer();
-            const objectUrl = URL.createObjectURL(new Blob([buffer], { type: "image/png" }));
-            try {
-                return await (0, image_utils_1.loadImage)(objectUrl);
-            }
-            finally {
-                URL.revokeObjectURL(objectUrl);
-            }
-        }
-        /*
-         * Puts a static raster through the same resample the frames get.
-         */
-        remap(image) {
-            if (!image) {
-                return null;
-            }
-            const rect = this.sourceRect({ width: image.width, height: image.height });
-            if (!rect) {
-                return image;
-            }
-            const from = document.createElement("canvas");
-            from.width = image.width;
-            from.height = image.height;
-            from.getContext("2d").putImageData(image, 0, 0);
-            const to = document.createElement("canvas");
-            to.width = image.width;
-            to.height = image.height;
-            const ctx = to.getContext("2d");
-            ctx.imageSmoothingEnabled = false;
-            ctx.clearRect(0, 0, image.width, image.height);
-            ctx.drawImage(from, rect.x, rect.y, rect.width, rect.height, 0, 0, image.width, image.height);
-            return ctx.getImageData(0, 0, image.width, image.height);
-        }
-        /*
-         * Range GETs one entry out of the blob and decodes it to pixels.
-         */
-        async loadImageDataAt(entry) {
-            const start = entry.ByteOffset;
-            const end = entry.ByteOffset + entry.ByteLength - 1;
-            const response = await fetch(this.archiveUrl, { headers: { Range: `bytes=${start}-${end}` } });
-            const buffer = await response.arrayBuffer();
-            const blob = new Blob([buffer], { type: "image/png" });
-            const objectUrl = URL.createObjectURL(blob);
-            let image;
-            try {
-                image = await (0, image_utils_1.loadImage)(objectUrl);
-            }
-            finally {
-                URL.revokeObjectURL(objectUrl);
-            }
-            const canvas = document.createElement("canvas");
-            canvas.width = image.width;
-            canvas.height = image.height;
-            const ctx = canvas.getContext("2d");
-            ctx.drawImage(image, 0, 0);
-            return ctx.getImageData(0, 0, canvas.width, canvas.height);
-        }
         /**
          * Fetches and decodes the archive's static baseline mask, at most once.
          */