bruce-cesium 7.2.0 → 7.2.2

package/dist/lib/rendering/texture-value-labels.js

@@ -0,0 +1,687 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextureValueLabels = void 0;
+const Cesium = require("cesium");
+const texture_frame_series_animator_1 = require("./texture-frame-series-animator");
+/**
+ * Prints a value texture's own numbers over the cells they belong to.
+ */
+var TextureValueLabels;
+(function (TextureValueLabels) {
+    // Off by default: a caller can still set a floor, but thinning is the mechanism that keeps a
+    // distant view readable.
+    const DEFAULT_MIN_CELL_PIXELS = 0;
+    const MIN_VISIBLE_PIXELS = 60;
+    const MAX_STRIDE = 512;
+    const STRIDE_HYSTERESIS = 1.4;
+    const DEFAULT_MIN_SPACING_PIXELS = 78;
+    const DEFAULT_MAX_LABELS = 240;
+    const LABEL_RADIUS = 4;
+    const LABEL_FONT = "600 11px ui-monospace, SFMono-Regular, Menlo, monospace";
+    // Clear space either side of a label box, so neighbours read as separate.
+    const LABEL_GAP_PIXELS = 16;
+    const LABEL_ANCHOR_COLOR = "rgba(255,255,255,0.85)";
+    // 8 rather than 5: below this a cell reads as texture rather than as a boundary, and it also
+    // bounds the worst case, since a full screen of 8 px cells fits inside MAX_GRID_CELLS.
+    const DEFAULT_MIN_GRID_CELL_PIXELS = 8;
+    const DEFAULT_GRID_WIDTH_PIXELS = 1;
+    // Enough for a full screen at the minimum legible cell size, with headroom for an oblique view
+    // whose texel window is larger than the screen. The budget is shared across tiles, so sizing it
+    // too tightly made the grid depend on which tile happened to be walked first.
+    const MAX_GRID_CELLS = 40000;
+    // Probes per side when hunting a labellable cell inside one lattice block.
+    const MAX_LABEL_PROBES_PER_SIDE = 8;
+    const TILE_OUTLINE_ALPHA = 0.45;
+    // Cells per grid square at the coarsest. Beyond this a tile is outlined instead.
+    const MAX_GRID_STRIDE = 256;
+    const LINE_HEIGHT = 13;
+    /**
+     * A clip outline from a projected ring, or null when the ring cannot be drawn.
+     * @param projected one entry per ring vertex, null where the vertex has no window coordinate
+     */
+    function ClipOutline(projected) {
+        if (projected.length < 3) {
+            return null;
+        }
+        const out = [];
+        for (const at of projected) {
+            if (!at) {
+                return null;
+            }
+            out.push(at);
+        }
+        return out;
+    }
+    TextureValueLabels.ClipOutline = ClipOutline;
+    /**
+     * How many cells apart labels should sit, as a power of two.
+     * @param options cellPixels is one cell's size on screen, held is the stride already in use
+     */
+    function ChooseLabelStride(options) {
+        const { cellPixels, visibleCols, visibleRows, maxLabels, minSpacingPixels } = options;
+        const fits = (s, slack) => cellPixels * s >= minSpacingPixels / slack
+            && Math.ceil(visibleCols / s) * Math.ceil(visibleRows / s) <= maxLabels * slack;
+        let stride = 1;
+        while (stride < MAX_STRIDE && !fits(stride, 1)) {
+            stride *= 2;
+        }
+        const held = options.held;
+        if (held && fits(held, STRIDE_HYSTERESIS)) {
+            if (held === stride / 2 && cellPixels * held >= minSpacingPixels / STRIDE_HYSTERESIS) {
+                return held;
+            }
+            if (held === stride * 2 && cellPixels * stride < minSpacingPixels * STRIDE_HYSTERESIS) {
+                return held;
+            }
+        }
+        return stride;
+    }
+    TextureValueLabels.ChooseLabelStride = ChooseLabelStride;
+    class Labels {
+        constructor(options) {
+            this.source = null;
+            this.painted = null;
+            this.floor = null;
+            this.ceiling = null;
+            this.disposed = false;
+            this.drawn = 0;
+            this.stride = 0;
+            this.viewer = options.viewer;
+            this.extent = options.extent;
+            this.settings = options.settings || {};
+            this.metadata = options.metadata;
+            this.tiles = options.tiles;
+            this.clipRing = options.clipRing;
+            this.canvas = document.createElement("canvas");
+            this.canvas.style.position = "absolute";
+            this.canvas.style.inset = "0";
+            this.canvas.style.pointerEvents = "none";
+            const parent = this.viewer.canvas.parentElement;
+            if (parent) {
+                parent.appendChild(this.canvas);
+            }
+            this.ctx = this.canvas.getContext("2d");
+        }
+        SetExtent(extent) {
+            this.extent = extent;
+        }
+        /**
+         * The current frame's decoded values, as the animator's value canvas already provides them.
+         * @param source value pixels, one texel per cell
+         */
+        SetSource(source) {
+            this.source = source;
+        }
+        /**
+         * The tinted pixels of the same frame, so the grid can skip cells the ramp painted nothing in.
+         * @param painted RGBA of the presented frame, or null to fall back to coverage alone
+         */
+        SetPainted(painted) {
+            this.painted = painted;
+        }
+        /**
+         * The archive's per-cell extremes, when it publishes them. Without these a label can still
+         * print the current reading, just not the range behind it.
+         */
+        SetExtremes(floor, ceiling) {
+            this.floor = floor;
+            this.ceiling = ceiling;
+        }
+        GetDrawnCount() {
+            return this.drawn;
+        }
+        Clear() {
+            this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+            this.drawn = 0;
+        }
+        Dispose() {
+            this.disposed = true;
+            if (this.canvas.parentElement) {
+                this.canvas.parentElement.removeChild(this.canvas);
+            }
+        }
+        /**
+         * Redraws every visible label. Cheap enough to call per rendered frame, because the cell
+         * count it considers is bounded by the view rather than by the texture.
+         */
+        Render() {
+            var _a, _b, _c;
+            if (this.disposed || !this.source) {
+                return;
+            }
+            const view = this.viewer.canvas;
+            if (this.canvas.width !== view.clientWidth || this.canvas.height !== view.clientHeight) {
+                this.canvas.width = view.clientWidth;
+                this.canvas.height = view.clientHeight;
+            }
+            this.Clear();
+            const cols = this.source.width;
+            const rows = this.source.height;
+            const window = this.visibleTexels(cols, rows);
+            if (!window) {
+                return;
+            }
+            const midCol = (window.col0 + window.col1) / 2;
+            const midRow = (window.row0 + window.row1) / 2;
+            const a = this.project(this.lonAt(midCol, cols), this.latAt(midRow, rows));
+            const b = this.project(this.lonAt(midCol + 1, cols), this.latAt(midRow + 1, rows));
+            if (!a || !b) {
+                return;
+            }
+            const cellPixels = Math.min(Math.abs(b.x - a.x), Math.abs(b.y - a.y));
+            // Ahead of the label threshold on purpose: a grid still reads at a cell size where a
+            // number no longer fits.
+            this.drawGrid(window, cols, rows, cellPixels);
+            if (cellPixels < ((_a = this.settings.minCellPixels) !== null && _a !== void 0 ? _a : DEFAULT_MIN_CELL_PIXELS)) {
+                return;
+            }
+            const visibleWidth = cellPixels * (window.col1 - window.col0 + 1);
+            const visibleHeight = cellPixels * (window.row1 - window.row0 + 1);
+            if (Math.max(visibleWidth, visibleHeight) < MIN_VISIBLE_PIXELS) {
+                return;
+            }
+            const parts = this.settings.parts || ["value", "floor", "ceiling"];
+            this.ctx.font = LABEL_FONT;
+            this.ctx.textAlign = "center";
+            const maxLabels = (_b = this.settings.maxLabels) !== null && _b !== void 0 ? _b : DEFAULT_MAX_LABELS;
+            this.stride = ChooseLabelStride({
+                cellPixels,
+                visibleCols: window.col1 - window.col0 + 1,
+                visibleRows: window.row1 - window.row0 + 1,
+                maxLabels,
+                // Measured, not assumed: the spacing that keeps labels apart is whatever the widest
+                // one is, so changing what a label says cannot quietly start overlapping them.
+                minSpacingPixels: Math.max((_c = this.settings.minSpacingPixels) !== null && _c !== void 0 ? _c : DEFAULT_MIN_SPACING_PIXELS, this.widestLabel(parts)),
+                held: this.stride
+            });
+            const stride = this.stride;
+            const firstRow = Math.floor(window.row0 / stride) * stride;
+            const firstCol = Math.floor(window.col0 / stride) * stride;
+            for (let row = firstRow; row <= window.row1 && this.drawn < maxLabels; row += stride) {
+                for (let col = firstCol; col <= window.col1 && this.drawn < maxLabels; col += stride) {
+                    const found = this.readNear(col, row, cols, rows, stride);
+                    if (!found) {
+                        continue;
+                    }
+                    const point = this.project(this.lonAt(found.col, cols), this.latAt(found.row, rows));
+                    if (!point || point.x < 0 || point.y < 0
+                        || point.x > this.canvas.width || point.y > this.canvas.height) {
+                        continue;
+                    }
+                    this.drawLabel(point, found.reading, parts, this.cellOutline(found.col, found.row, cols, rows));
+                }
+            }
+        }
+        /*
+         * Outlines each covered cell, from a projected lattice of its corners.
+         */
+        drawGrid(window, cols, rows, cellPixels) {
+            var _a, _b;
+            const color = this.settings.gridColor;
+            if (!color) {
+                return;
+            }
+            if (this.tiles && this.tiles.length) {
+                this.ctx.save();
+                this.applyRingClip();
+                this.drawTileGrid(color);
+                this.ctx.restore();
+                return;
+            }
+            if (cellPixels < ((_a = this.settings.minGridCellPixels) !== null && _a !== void 0 ? _a : DEFAULT_MIN_GRID_CELL_PIXELS)) {
+                return;
+            }
+            // Corners are shared by four cells, so projecting the lattice once rather than per cell
+            // cuts the work by about four and keeps neighbouring outlines exactly coincident.
+            const wide = window.col1 - window.col0 + 1;
+            const high = window.row1 - window.row0 + 1;
+            if (wide * high > MAX_GRID_CELLS) {
+                return;
+            }
+            const lattice = new Array((wide + 1) * (high + 1));
+            for (let r = 0; r <= high; r++) {
+                for (let c = 0; c <= wide; c++) {
+                    // Corners sit half a texel out from the centres lonAt/latAt return.
+                    const lon = this.lonAt(window.col0 + c - 0.5, cols);
+                    const lat = this.latAt(window.row0 + r - 0.5, rows);
+                    lattice[r * (wide + 1) + c] = this.project(lon, lat);
+                }
+            }
+            const path = new Path2D();
+            let drew = false;
+            for (let r = 0; r < high; r++) {
+                for (let c = 0; c < wide; c++) {
+                    if (!this.isCovered(window.col0 + c, window.row0 + r, cols)) {
+                        continue;
+                    }
+                    const tl = lattice[r * (wide + 1) + c];
+                    const tr = lattice[r * (wide + 1) + c + 1];
+                    const bl = lattice[(r + 1) * (wide + 1) + c];
+                    const br = lattice[(r + 1) * (wide + 1) + c + 1];
+                    if (!tl || !tr || !bl || !br) {
+                        continue;
+                    }
+                    path.moveTo(tl.x, tl.y);
+                    path.lineTo(tr.x, tr.y);
+                    path.lineTo(br.x, br.y);
+                    path.lineTo(bl.x, bl.y);
+                    path.closePath();
+                    drew = true;
+                }
+            }
+            if (!drew) {
+                return;
+            }
+            this.ctx.strokeStyle = color;
+            this.ctx.lineWidth = (_b = this.settings.gridWidthPixels) !== null && _b !== void 0 ? _b : DEFAULT_GRID_WIDTH_PIXELS;
+            this.ctx.stroke(path);
+            +" alpha" + this.ctx.globalAlpha;
+        }
+        /*
+         * Restricts drawing to the polygon, so nothing is ruled over ground it does not cover.
+         */
+        applyRingClip() {
+            const ring = this.clipRing;
+            if (!ring || ring.length < 3) {
+                return;
+            }
+            const outline = ClipOutline(ring.map(point => this.project(point.lon, point.lat)));
+            if (!outline) {
+                return;
+            }
+            const path = new Path2D();
+            path.moveTo(outline[0].x, outline[0].y);
+            for (let i = 1; i < outline.length; i++) {
+                path.lineTo(outline[i].x, outline[i].y);
+            }
+            path.closePath();
+            this.ctx.clip(path);
+        }
+        /*
+         * The cell of whichever tile covers a point, as screen corners.
+         */
+        tileCellOutline(lon, lat) {
+            for (const tile of this.tiles) {
+                if (lon < tile.West || lon > tile.East || lat < tile.South || lat > tile.North) {
+                    continue;
+                }
+                const c = (Math.min(tile.ResolutionX - 1, Math.max(0, Math.floor((lon - tile.West) / (tile.East - tile.West) * tile.ResolutionX))));
+                const r = (Math.min(tile.ResolutionY - 1, Math.max(0, Math.floor((tile.North - lat) / (tile.North - tile.South) * tile.ResolutionY))));
+                const w0 = tile.West + (c / tile.ResolutionX) * (tile.East - tile.West);
+                const w1 = tile.West + ((c + 1) / tile.ResolutionX) * (tile.East - tile.West);
+                const n0 = tile.North - (r / tile.ResolutionY) * (tile.North - tile.South);
+                const n1 = tile.North - ((r + 1) / tile.ResolutionY) * (tile.North - tile.South);
+                const corners = [
+                    this.project(w0, n0), this.project(w1, n0),
+                    this.project(w1, n1), this.project(w0, n1)
+                ];
+                return corners.every((q) => q) ? corners : null;
+            }
+            return null;
+        }
+        /*
+         * Outlines each tile's own cells, so cell size still shows where the mesh is refined.
+         */
+        drawTileGrid(color) {
+            var _a, _b, _c;
+            const view = this.viewer.camera.computeViewRectangle(Cesium.Ellipsoid.WGS84);
+            if (!view) {
+                return;
+            }
+            const west = Cesium.Math.toDegrees(view.west);
+            const east = Cesium.Math.toDegrees(view.east);
+            const south = Cesium.Math.toDegrees(view.south);
+            const north = Cesium.Math.toDegrees(view.north);
+            const minCell = (_a = this.settings.minGridCellPixels) !== null && _a !== void 0 ? _a : DEFAULT_MIN_GRID_CELL_PIXELS;
+            const focus = this.groundAtScreenCentre();
+            const path = new Path2D();
+            // A tile too fine to rule, or one the budget cannot afford, contributes its own outline
+            // instead of vanishing. Dropping such tiles entirely is what made whole regions blink out.
+            const coarse = new Path2D();
+            let drew = false;
+            let drewCoarse = false;
+            const outlineTile = (tile) => {
+                const tl = this.project(tile.West, tile.North);
+                const tr = this.project(tile.East, tile.North);
+                const br = this.project(tile.East, tile.South);
+                const bl = this.project(tile.West, tile.South);
+                if (!tl || !tr || !br || !bl) {
+                    return;
+                }
+                coarse.moveTo(tl.x, tl.y);
+                coarse.lineTo(tr.x, tr.y);
+                coarse.lineTo(br.x, br.y);
+                coarse.lineTo(bl.x, bl.y);
+                coarse.closePath();
+                drewCoarse = true;
+            };
+            // Planned for every visible tile BEFORE any is drawn.
+            const planned = [];
+            for (const tile of this.tiles) {
+                if (tile.East < west || tile.West > east || tile.North < south || tile.South > north) {
+                    continue;
+                }
+                const c0 = Math.max(0, Math.floor((Math.max(west, tile.West) - tile.West)
+                    / (tile.East - tile.West) * tile.ResolutionX));
+                const c1 = Math.min(tile.ResolutionX, Math.ceil((Math.min(east, tile.East) - tile.West)
+                    / (tile.East - tile.West) * tile.ResolutionX));
+                const r0 = Math.max(0, Math.floor((tile.North - Math.min(north, tile.North))
+                    / (tile.North - tile.South) * tile.ResolutionY));
+                const r1 = Math.min(tile.ResolutionY, Math.ceil((tile.North - Math.max(south, tile.South))
+                    / (tile.North - tile.South) * tile.ResolutionY));
+                if (c1 <= c0 || r1 <= r0) {
+                    continue;
+                }
+                const focusC = focus
+                    ? Math.round((focus.lon - tile.West) / (tile.East - tile.West) * tile.ResolutionX)
+                    : Math.floor((c0 + c1) / 2);
+                const focusR = focus
+                    ? Math.round((tile.North - focus.lat) / (tile.North - tile.South) * tile.ResolutionY)
+                    : Math.floor((r0 + r1) / 2);
+                const midC = Math.min(c1 - 1, Math.max(c0, focusC));
+                const midR = Math.min(r1 - 1, Math.max(r0, focusR));
+                const cellLon = (tile.East - tile.West) / tile.ResolutionX;
+                const cellLat = (tile.North - tile.South) / tile.ResolutionY;
+                const at = this.project(tile.West + midC * cellLon, tile.North - midR * cellLat);
+                const next = (this.project(tile.West + (midC + 1) * cellLon, tile.North - (midR + 1) * cellLat));
+                if (!at || !next) {
+                    outlineTile(tile);
+                    continue;
+                }
+                const onScreen = Math.min(Math.abs(next.x - at.x), Math.abs(next.y - at.y));
+                let step = 1;
+                while (step < MAX_GRID_STRIDE && onScreen * step < minCell) {
+                    step *= 2;
+                }
+                if (onScreen * step < minCell) {
+                    outlineTile(tile);
+                    continue;
+                }
+                planned.push({ tile, c0, c1, r0, r1, step });
+            }
+            // Coarsened together rather than dropped one by one, so a busy view thins out evenly.
+            const blocksOf = (p) => Math.ceil((p.c1 - p.c0) / p.step) * Math.ceil((p.r1 - p.r0) / p.step);
+            let total = planned.reduce((sum, p) => sum + blocksOf(p), 0);
+            while (total > MAX_GRID_CELLS && planned.some((p) => p.step < MAX_GRID_STRIDE)) {
+                for (const p of planned) {
+                    p.step = Math.min(MAX_GRID_STRIDE, p.step * 2);
+                }
+                total = planned.reduce((sum, p) => sum + blocksOf(p), 0);
+            }
+            for (const { tile, c0, c1, r0, r1, step } of planned) {
+                // Anchored to the tile's own origin so lines stay on the same boundaries as the camera
+                // moves, and so each step up is a subset of the one below it.
+                const firstR = Math.floor(r0 / step) * step;
+                const firstC = Math.floor(c0 / step) * step;
+                for (let r = firstR; r < r1; r += step) {
+                    const n0 = tile.North - (r / tile.ResolutionY) * (tile.North - tile.South);
+                    const n1 = tile.North
+                        - (Math.min(r + step, tile.ResolutionY) / tile.ResolutionY) * (tile.North - tile.South);
+                    for (let c = firstC; c < c1; c += step) {
+                        const w0 = tile.West + (c / tile.ResolutionX) * (tile.East - tile.West);
+                        const w1 = tile.West
+                            + (Math.min(c + step, tile.ResolutionX) / tile.ResolutionX) * (tile.East - tile.West);
+                        if (!this.coveredAt((w0 + w1) / 2, (n0 + n1) / 2)) {
+                            continue;
+                        }
+                        const tl = this.project(w0, n0);
+                        const tr = this.project(w1, n0);
+                        const br = this.project(w1, n1);
+                        const bl = this.project(w0, n1);
+                        if (!tl || !tr || !br || !bl) {
+                            continue;
+                        }
+                        path.moveTo(tl.x, tl.y);
+                        path.lineTo(tr.x, tr.y);
+                        path.lineTo(br.x, br.y);
+                        path.lineTo(bl.x, bl.y);
+                        path.closePath();
+                        drew = true;
+                    }
+                }
+            }
+            const gridWidth = (_b = this.settings.gridWidthPixels) !== null && _b !== void 0 ? _b : DEFAULT_GRID_WIDTH_PIXELS;
+            if (drewCoarse) {
+                this.ctx.save();
+                // Dimmer than a cell edge, so a tile boundary reads as "there is finer data here"
+                // rather than as a cell in its own right.
+                this.ctx.globalAlpha = TILE_OUTLINE_ALPHA;
+                this.ctx.strokeStyle = color;
+                this.ctx.lineWidth = gridWidth;
+                this.ctx.stroke(coarse);
+                this.ctx.restore();
+            }
+            if (!drew) {
+                return;
+            }
+            this.ctx.strokeStyle = color;
+            this.ctx.lineWidth = (_c = this.settings.gridWidthPixels) !== null && _c !== void 0 ? _c : DEFAULT_GRID_WIDTH_PIXELS;
+            this.ctx.stroke(path);
+        }
+        /*
+         * Lon/lat of the ground at the centre of the view, or null when the centre misses the globe.
+         */
+        groundAtScreenCentre() {
+            const scene = this.viewer.scene;
+            const centre = new Cesium.Cartesian2(this.viewer.canvas.clientWidth / 2, this.viewer.canvas.clientHeight / 2);
+            const hit = scene.camera.pickEllipsoid(centre, Cesium.Ellipsoid.WGS84);
+            if (!hit) {
+                return null;
+            }
+            const carto = Cesium.Cartographic.fromCartesian(hit);
+            return {
+                lon: Cesium.Math.toDegrees(carto.longitude),
+                lat: Cesium.Math.toDegrees(carto.latitude)
+            };
+        }
+        /*
+         * Whether the composited raster holds data at a lon/lat.
+         */
+        coveredAt(lon, lat) {
+            if (!this.source) {
+                return false;
+            }
+            const cols = this.source.width;
+            const rows = this.source.height;
+            const col = Math.floor((lon - this.extent.West) / (this.extent.East - this.extent.West) * cols);
+            const row = Math.floor((this.extent.North - lat) / (this.extent.North - this.extent.South) * rows);
+            if (col < 0 || row < 0 || col >= cols || row >= rows) {
+                return false;
+            }
+            const at = (row * cols + col) * 4 + 3;
+            // Painted, not merely covered: a dry cell holds a reading the ramp deliberately hides, and
+            // ruling a grid over it draws detail where the picture shows none.
+            if (this.painted && this.painted.length === cols * rows * 4) {
+                return this.painted[at] > 0;
+            }
+            return this.source.data[at] >= 128;
+        }
+        isCovered(col, row, cols) {
+            return Boolean(this.source && this.source.data[(row * cols + col) * 4 + 3] >= 128);
+        }
+        /*
+         * Width of the widest label this overlay could draw, in pixels.
+         */
+        widestLabel(parts) {
+            const sample = [];
+            if (parts.indexOf("value") >= 0) {
+                sample.push("-000.00");
+            }
+            const range = [];
+            if (parts.indexOf("floor") >= 0) {
+                range.push("min: -000.00");
+            }
+            if (parts.indexOf("ceiling") >= 0) {
+                range.push("max: -000.00");
+            }
+            if (range.length) {
+                sample.push(range.join(" - "));
+            }
+            if (!sample.length) {
+                return 0;
+            }
+            const widest = Math.max(...sample.map((line) => this.ctx.measureText(line).width));
+            return widest + LABEL_GAP_PIXELS;
+        }
+        /*
+         * The four screen corners of one cell, or null if any of them will not project.
+         */
+        cellOutline(col, row, cols, rows) {
+            // On a pyramid the composited texel is not a cell. Outlining it would draw a second,
+            // uniform lattice over the tile grid, misaligned with it everywhere.
+            if (this.tiles && this.tiles.length) {
+                return this.tileCellOutline(this.lonAt(col, cols), this.latAt(row, rows));
+            }
+            const corners = [
+                this.project(this.lonAt(col - 0.5, cols), this.latAt(row - 0.5, rows)),
+                this.project(this.lonAt(col + 0.5, cols), this.latAt(row - 0.5, rows)),
+                this.project(this.lonAt(col + 0.5, cols), this.latAt(row + 0.5, rows)),
+                this.project(this.lonAt(col - 0.5, cols), this.latAt(row + 0.5, rows))
+            ];
+            return corners.every((c) => c) ? corners : null;
+        }
+        drawLabel(point, reading, parts, outline) {
+            var _a;
+            const dp = (_a = this.settings.decimals) !== null && _a !== void 0 ? _a : (Math.abs(reading.value) < 10 ? 2 : 1);
+            const lines = [];
+            if (parts.indexOf("value") >= 0) {
+                lines.push(reading.value.toFixed(dp));
+            }
+            // Named rather than a bare pair: two numbers under a third say nothing about which is
+            // the series low and which is its high.
+            const range = [];
+            if (parts.indexOf("floor") >= 0 && reading.floor !== undefined) {
+                range.push(`min: ${reading.floor.toFixed(dp)}`);
+            }
+            if (parts.indexOf("ceiling") >= 0 && reading.ceiling !== undefined) {
+                range.push(`max: ${reading.ceiling.toFixed(dp)}`);
+            }
+            if (range.length) {
+                lines.push(range.join(" - "));
+            }
+            if (!lines.length) {
+                return;
+            }
+            if (outline) {
+                this.ctx.strokeStyle = LABEL_ANCHOR_COLOR;
+                this.ctx.lineWidth = 1.5;
+                this.ctx.beginPath();
+                this.ctx.moveTo(outline[0].x, outline[0].y);
+                for (let i = 1; i < outline.length; i++) {
+                    this.ctx.lineTo(outline[i].x, outline[i].y);
+                }
+                this.ctx.closePath();
+                this.ctx.stroke();
+            }
+            const width = Math.max(...lines.map((l) => this.ctx.measureText(l).width)) + 10;
+            const height = lines.length * LINE_HEIGHT + 6;
+            const top = point.y - height / 2;
+            this.ctx.fillStyle = "rgba(16,16,14,0.72)";
+            this.ctx.beginPath();
+            this.ctx.roundRect(point.x - width / 2, top, width, height, LABEL_RADIUS);
+            this.ctx.fill();
+            lines.forEach((line, i) => {
+                this.ctx.fillStyle = i === 0 ? "#ffffff" : "#a8a89f";
+                this.ctx.fillText(line, point.x, top + LINE_HEIGHT * (i + 1) - 1);
+            });
+            this.drawn++;
+        }
+        /*
+         * The first cell with a reading at or near a lattice point, searched within its own block.
+         */
+        readNear(col, row, cols, rows, stride) {
+            const direct = this.readAt(col, row, cols);
+            if (direct && this.paintedAt(col, row, cols)) {
+                return { col, row, reading: direct };
+            }
+            if (stride <= 1) {
+                return null;
+            }
+            // Bounded, and stepped rather than exhaustive, so a large stride cannot make this the
+            // expensive part of a frame.
+            const step = Math.max(1, Math.floor(stride / MAX_LABEL_PROBES_PER_SIDE));
+            for (let r = row; r < Math.min(rows, row + stride); r += step) {
+                for (let c = col; c < Math.min(cols, col + stride); c += step) {
+                    const reading = this.readAt(c, r, cols);
+                    if (reading && this.paintedAt(c, r, cols)) {
+                        return { col: c, row: r, reading };
+                    }
+                }
+            }
+            return null;
+        }
+        paintedAt(col, row, cols) {
+            if (!this.painted) {
+                return true;
+            }
+            const at = (row * cols + col) * 4 + 3;
+            return this.painted[at] > 0;
+        }
+        // Decodes one cell, skipping anything the texture marks as having no data.
+        readAt(col, row, cols) {
+            var _a, _b;
+            const i = (row * cols + col) * 4;
+            if (!this.source || this.source.data[i + 3] < 128) {
+                return null;
+            }
+            const lo = this.metadata && typeof this.metadata.ValueMin === "number" ? this.metadata.ValueMin : 0;
+            const hi = this.metadata && typeof this.metadata.ValueMax === "number" ? this.metadata.ValueMax : 1;
+            const value = lo + (this.source.data[i] / 255) * (hi - lo);
+            const reading = { value };
+            const eLo = (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.ExtremesValueMin;
+            const eHi = (_b = this.metadata) === null || _b === void 0 ? void 0 : _b.ExtremesValueMax;
+            if (this.floor && typeof eLo === "number" && typeof eHi === "number") {
+                reading.floor = eLo + decode16(this.floor.data, i) * (eHi - eLo);
+                // An anomaly archive's frames are already floor-relative, so the reading a user
+                // wants is the absolute one. This is the whole reason the floor is published.
+                if (texture_frame_series_animator_1.TextureFrameSeriesAnimator.IsAnomalyMeasure(this.metadata)) {
+                    reading.value += reading.floor;
+                }
+            }
+            if (this.ceiling && typeof eLo === "number" && typeof eHi === "number") {
+                reading.ceiling = eLo + decode16(this.ceiling.data, i) * (eHi - eLo);
+            }
+            return reading;
+        }
+        lonAt(col, cols) {
+            return this.extent.West + ((col + 0.5) / cols) * (this.extent.East - this.extent.West);
+        }
+        latAt(row, rows) {
+            return this.extent.North - ((row + 0.5) / rows) * (this.extent.North - this.extent.South);
+        }
+        // The texel range overlapping the camera's view, so an off-screen texture costs nothing.
+        visibleTexels(cols, rows) {
+            const view = this.viewer.camera.computeViewRectangle(Cesium.Ellipsoid.WGS84);
+            if (!view) {
+                return null;
+            }
+            const west = Math.max(this.extent.West, Cesium.Math.toDegrees(view.west));
+            const east = Math.min(this.extent.East, Cesium.Math.toDegrees(view.east));
+            const south = Math.max(this.extent.South, Cesium.Math.toDegrees(view.south));
+            const north = Math.min(this.extent.North, Cesium.Math.toDegrees(view.north));
+            if (west >= east || south >= north) {
+                return null;
+            }
+            const spanLon = this.extent.East - this.extent.West;
+            const spanLat = this.extent.North - this.extent.South;
+            return {
+                col0: Math.max(0, Math.floor((west - this.extent.West) / spanLon * cols) - 1),
+                col1: Math.min(cols - 1, Math.ceil((east - this.extent.West) / spanLon * cols) + 1),
+                row0: Math.max(0, Math.floor((this.extent.North - north) / spanLat * rows) - 1),
+                row1: Math.min(rows - 1, Math.ceil((this.extent.North - south) / spanLat * rows) + 1)
+            };
+        }
+        project(lon, lat) {
+            const world = Cesium.Cartesian3.fromDegrees(lon, lat, 0);
+            const transforms = Cesium.SceneTransforms;
+            // Renamed in newer Cesium, and this library runs on whatever the host app supplies.
+            const fn = transforms.worldToWindowCoordinates || transforms.wgs84ToWindowCoordinates;
+            return fn ? fn.call(transforms, this.viewer.scene, world) : null;
+        }
+    }
+    TextureValueLabels.Labels = Labels;
+    function decode16(data, i) {
+        return (data[i] * 256 + data[i + 1]) / 65535;
+    }
+})(TextureValueLabels = exports.TextureValueLabels || (exports.TextureValueLabels = {}));
+//# sourceMappingURL=texture-value-labels.js.map