bruce-models 7.1.87 → 7.1.89

package/dist/lib/client-file/value-map-reader.js

@@ -0,0 +1,1547 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueMapReader = void 0;
+const bounds_1 = require("../common/bounds");
+const geometry_1 = require("../common/geometry");
+const client_file_1 = require("./client-file");
+const value_map_metadata_1 = require("./value-map-metadata");
+const value_map_grid_1 = require("./value-map-grid");
+/**
+ * Reads a generated value map: its frames, the values in them, and the shapes those values make.
+ */
+var ValueMapReader;
+(function (ValueMapReader) {
+    /*
+        Texels an area needs before it counts as one.
+        A texel is a mesh sample rather than a measurement of ground, so a handful of them
+        touching is usually the edge of the model flickering over the threshold.
+        Pass 1 to keep every one of them.
+    */
+    ValueMapReader.MIN_TEXELS = 8;
+    // How far a reduced outline may move from the traced one, in texels.
+    ValueMapReader.SIMPLIFY_TOLERANCE = 0.25;
+    // Fraction of the busiest frame that counts as the event being under way, used when picking
+    // which frames are worth looking at.
+    ValueMapReader.ONSET_FRACTION = 0.5;
+    // Candidate levels walked when a threshold has to be read off the series.
+    ValueMapReader.LEVELS = 256;
+    // Longest edge of the grid tiles are composited onto. A pyramid's finest tile can imply a
+    // raster far larger than the analysis needs, and every frame pays for it.
+    ValueMapReader.MAX_COMPOSITE_TEXELS = 2048;
+    // Decoded frames kept, since compositing a tiled frame costs one image decode per tile and the
+    // passes over a series each walk the whole thing again.
+    ValueMapReader.FRAME_CACHE = 16;
+    // Single tile rasters kept, which is what a point sample reads instead of a whole composite.
+    ValueMapReader.TILE_CACHE = 32;
+    // How far apart two slices can sit and still be read together, from the format.
+    ValueMapReader.MAX_READ_GAP = value_map_metadata_1.ValueMapMetadata.MAX_READ_GAP;
+    class Reader {
+        constructor(params) {
+            this.frames = new Map();
+            this.tileLayers = new Map();
+            this.statistics = new Map();
+            this.thresholds = new Map();
+            this.baseline = undefined;
+            this.unchanging = undefined;
+            this.File = params.file;
+            this.Metadata = value_map_metadata_1.ValueMapMetadata.Of(params.file);
+            const refused = value_map_metadata_1.ValueMapMetadata.Unreadable(this.Metadata);
+            if (refused) {
+                // An unknown shape decodes into plausible numbers rather than failing, which is why
+                // it is refused here instead of half read.
+                throw new Error(refused);
+            }
+            this.Tiles = value_map_metadata_1.ValueMapMetadata.TilesOf(this.Metadata);
+            this.bytes = params.bytes;
+            this.decoder = params.decoder || ValueMapReader.DefaultDecoder;
+            this.Extent = params.extent || value_map_metadata_1.ValueMapMetadata.ExtentOf(this.Metadata);
+            if (!this.Extent) {
+                throw new Error("The value map's Geometry block does not place its raster on the"
+                    + " world, so there is nowhere to read it onto.");
+            }
+            const size = value_map_grid_1.ValueMapGrid.CompositeSize(this.Tiles, this.Extent, params.maxCompositeTexels || ValueMapReader.MAX_COMPOSITE_TEXELS);
+            this.Grid = new value_map_grid_1.ValueMapGrid.Grid(this.Metadata.Geometry, size.Width, size.Height, this.Extent);
+        }
+        /**
+         * The attribute this value map was generated from.
+         */
+        get Attribute() {
+            return this.identity().Attribute || null;
+        }
+        /**
+         * What the attribute is called for a reader, where the source names it.
+         */
+        get Label() {
+            return this.identity().Label || null;
+        }
+        /**
+         * The dataset the values came from, since one account holds several over the same mesh.
+         */
+        get Dataset() {
+            return this.identity().Dataset || null;
+        }
+        /**
+         * The Entity Type Source this was generated from.
+         */
+        get EntityTypeSourceID() {
+            const at = this.identity().EntityTypeSourceID;
+            return at == null ? null : Number(at);
+        }
+        /**
+         * When the archive was written, which is what tells two generations of it apart.
+         */
+        get Generated() {
+            return this.identity().Generated || null;
+        }
+        get Revision() {
+            const at = this.identity().Revision;
+            return at == null ? null : Number(at);
+        }
+        /**
+         * The units a reading is in, where the source states them.
+         */
+        get Units() {
+            return (this.Metadata.Value || {}).Units || null;
+        }
+        /**
+         * How a frame's number is packed: one channel or two.
+         */
+        get Format() {
+            return (this.Metadata.Value || {}).Format || value_map_metadata_1.ValueMapMetadata.FORMAT_U8;
+        }
+        /**
+         * The values a reading out of this value map falls between, in its own units.
+         */
+        get ValueRange() {
+            return value_map_metadata_1.ValueMapMetadata.ValueRange(this.Metadata);
+        }
+        /**
+         * The values the source's own numbers fall between, or null where nothing was transformed.
+         */
+        get SourceRange() {
+            return value_map_metadata_1.ValueMapMetadata.SourceRange(this.Metadata);
+        }
+        /**
+         * What the source's own heights are measured from, when the archive says.
+         * A thickness declares none, and an untransformed elevation declares one with no transform.
+         */
+        get VerticalDatum() {
+            return (this.Metadata.ValueSource || {}).VerticalDatum || null;
+        }
+        /**
+         * What was applied to the source's numbers to get the delivered ones, empty for nothing.
+         */
+        get Transform() {
+            return value_map_metadata_1.ValueMapMetadata.TransformOf(this.Metadata);
+        }
+        /**
+         * Whether a reading differs from what the source's own data said.
+         */
+        get IsTransformed() {
+            return value_map_metadata_1.ValueMapMetadata.IsTransformed(this.Metadata);
+        }
+        /**
+         * What the source suggests a picture be ramped over, which is not a bound on the data.
+         */
+        get ColorBarRange() {
+            return value_map_metadata_1.ValueMapMetadata.ColorBarRange(this.Metadata);
+        }
+        /**
+         * The largest movement any one texel made over the series.
+         */
+        get MovingRangeMax() {
+            const stats = this.Metadata.Stats || {};
+            return typeof stats.MovingRangeMax === "number" ? stats.MovingRangeMax : null;
+        }
+        /**
+         * How many timesteps the generator set out to write.
+         */
+        get RequestedFrames() {
+            return (this.Metadata.Series || {}).Requested || 0;
+        }
+        /**
+         * How many it actually wrote.
+         */
+        get WrittenFrames() {
+            const series = this.Metadata.Series || {};
+            return typeof series.Written === "number" ? series.Written : this.Times.length;
+        }
+        /**
+         * Whether the archive holds every timestep that was asked for.
+         */
+        get IsComplete() {
+            return value_map_metadata_1.ValueMapMetadata.IsComplete(this.Metadata);
+        }
+        /**
+         * When each frame was sampled. Authoritative, unlike the series increment.
+         */
+        get Times() {
+            return value_map_metadata_1.ValueMapMetadata.TimesOf(this.Metadata);
+        }
+        /**
+         * How many frames the archive holds.
+         */
+        get Length() {
+            return this.Times.length;
+        }
+        /**
+         * Says so when the archive's heights are not on the ellipsoid, or null when they are.
+         */
+        Warning() {
+            return value_map_metadata_1.ValueMapMetadata.UnshiftedWarning(this.Metadata);
+        }
+        /**
+         * One layer's declaration, or undefined when the archive does not carry it.
+         */
+        Layer(name) {
+            return value_map_metadata_1.ValueMapMetadata.LayerOf(this.Metadata, name);
+        }
+        /**
+         * One frame's values and a mask of which texels were sampled.
+         */
+        Frame(index = 0, source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const position = this.position(index);
+                const key = position + ":" + source;
+                const held = this.frames.get(key);
+                if (held) {
+                    this.frames.delete(key);
+                    this.frames.set(key, held);
+                    return held;
+                }
+                let field = yield this.composite(value_map_metadata_1.ValueMapMetadata.LAYER_VALUE, position);
+                if (!field) {
+                    throw new Error("Frame " + index + " has no image in any of this value map's "
+                        + this.Tiles.length + " tiles.");
+                }
+                if (source) {
+                    field = yield this.toSource(field);
+                }
+                this.frames.set(key, field);
+                Trim(this.frames, ValueMapReader.FRAME_CACHE);
+                return field;
+            });
+        }
+        /**
+         * Each texel's lowest value over the series and where that is known, or null.
+         */
+        ValueMin() {
+            return this.statistic(value_map_metadata_1.ValueMapMetadata.LAYER_VALUE_MIN);
+        }
+        /**
+         * Each texel's highest value over the series and where that is known, or null.
+         */
+        ValueMax() {
+            return this.statistic(value_map_metadata_1.ValueMapMetadata.LAYER_VALUE_MAX);
+        }
+        /**
+         * The per-texel correction applied to the source's own numbers, or null where none was.
+         *
+         * sourceValue = value - shift, which is what makes the transform reversible per texel rather
+         * than only describable in prose.
+         */
+        ValueShift() {
+            return this.statistic(value_map_metadata_1.ValueMapMetadata.LAYER_VALUE_SHIFT);
+        }
+        /**
+         * The texels flagged as permanently at their own minimum, or null when none were published.
+         *
+         * A caller measuring change subtracts these rather than reporting ground that never moved.
+         */
+        Baseline() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.baseline !== undefined) {
+                    return this.baseline;
+                }
+                this.baseline = null;
+                if (this.Layer(value_map_metadata_1.ValueMapMetadata.LAYER_BASELINE)) {
+                    const field = yield this.composite(value_map_metadata_1.ValueMapMetadata.LAYER_BASELINE);
+                    if (field) {
+                        this.baseline = { Width: field.Width, Height: field.Height, Bits: field.Covered };
+                    }
+                }
+                return this.baseline;
+            });
+        }
+        /**
+         * The texels holding one value for the whole series, or null for a single frame archive.
+         */
+        Unchanging() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.unchanging !== undefined) {
+                    return this.unchanging;
+                }
+                this.unchanging = null;
+                if (this.Length < 2) {
+                    return this.unchanging;
+                }
+                let lowest = null;
+                let highest = null;
+                let always = null;
+                let width = 0;
+                let height = 0;
+                for (let index = 0; index < this.Length; index++) {
+                    const frame = yield this.Frame(index);
+                    width = frame.Width;
+                    height = frame.Height;
+                    if (!lowest) {
+                        lowest = frame.Values.slice();
+                        highest = frame.Values.slice();
+                        always = frame.Covered.slice();
+                        continue;
+                    }
+                    for (let at = 0; at < lowest.length; at++) {
+                        lowest[at] = Math.min(lowest[at], frame.Values[at]);
+                        highest[at] = Math.max(highest[at], frame.Values[at]);
+                        // A texel sampled in only some frames is changing, whatever its values did.
+                        always[at] = always[at] && frame.Covered[at] ? 1 : 0;
+                    }
+                }
+                const bits = new Uint8Array(always.length);
+                for (let at = 0; at < bits.length; at++) {
+                    bits[at] = always[at] && lowest[at] === highest[at] ? 1 : 0;
+                }
+                this.unchanging = { Width: width, Height: height, Bits: bits };
+                return this.unchanging;
+            });
+        }
+        /**
+         * Every texel a change in the series cannot be read from, or null when there are none.
+         *
+         * The published baseline and the texels measured as unchanging, since neither describes
+         * anything the series does and a caller asking what moved wants both gone.
+         */
+        Ignored() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const baseline = yield this.Baseline();
+                const unchanging = yield this.Unchanging();
+                if (!baseline) {
+                    return unchanging;
+                }
+                if (!unchanging) {
+                    return baseline;
+                }
+                return Combine(baseline, unchanging, (left, right) => left || right);
+            });
+        }
+        /**
+         * The level the series itself separates on, for a caller who cannot name one.
+         */
+        NaturalThreshold(source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.thresholds.has(source)) {
+                    return this.thresholds.get(source);
+                }
+                const range = (source && this.SourceRange) || this.ValueRange;
+                this.thresholds.set(source, range.Min);
+                if (this.Length < 2) {
+                    return range.Min;
+                }
+                const step = (range.Max - range.Min) / (ValueMapReader.LEVELS - 1);
+                if (step <= 0) {
+                    return range.Min;
+                }
+                const ignored = yield this.Ignored();
+                const above = [];
+                for (let index = 0; index < this.Length; index++) {
+                    const frame = yield this.Frame(index, source);
+                    const counts = new Float64Array(ValueMapReader.LEVELS);
+                    for (let at = 0; at < frame.Values.length; at++) {
+                        if (!frame.Covered[at] || (ignored && ignored.Bits[at])) {
+                            continue;
+                        }
+                        const level = Math.max(0, Math.min(ValueMapReader.LEVELS - 1, Math.round((frame.Values[at] - range.Min) / step)));
+                        counts[level]++;
+                    }
+                    // Texels strictly above each level, which is what a mask at that level would hold.
+                    const holding = new Array(ValueMapReader.LEVELS);
+                    let running = 0;
+                    for (let level = ValueMapReader.LEVELS - 1; level >= 0; level--) {
+                        holding[level] = running;
+                        running += counts[level];
+                    }
+                    above.push(holding);
+                }
+                let best = 0;
+                let widest = 0;
+                for (let level = 0; level < ValueMapReader.LEVELS; level++) {
+                    const spread = Deviation(above.map((counts) => counts[level]));
+                    if (spread > widest) {
+                        widest = spread;
+                        best = level;
+                    }
+                }
+                if (widest <= 0) {
+                    return range.Min;
+                }
+                this.thresholds.set(source, range.Min + best * step);
+                return this.thresholds.get(source);
+            });
+        }
+        /**
+         * The level to measure against, read off the series when the caller names none.
+         */
+        Resolve(threshold, source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return threshold == null ? this.NaturalThreshold(source) : threshold;
+            });
+        }
+        /**
+         * The texels in one frame whose value is over a threshold.
+         *
+         * Ask for source to compare against the customer's own numbers, so a level stated against
+         * their data means what they think it means.
+         */
+        MaskAbove(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const source = !!options.source;
+                const frame = yield this.Frame(options.frame || 0, source);
+                const level = yield this.Resolve(options.threshold, source);
+                const bits = new Uint8Array(frame.Values.length);
+                for (let at = 0; at < bits.length; at++) {
+                    bits[at] = frame.Covered[at] && frame.Values[at] > level ? 1 : 0;
+                }
+                const mask = { Width: frame.Width, Height: frame.Height, Bits: bits };
+                if (options.excludeBaseline === false) {
+                    return mask;
+                }
+                const ignored = yield this.Ignored();
+                return ignored ? Combine(mask, ignored, (left, right) => left && !right) : mask;
+            });
+        }
+        /**
+         * The texels over a threshold in every frame, or null for an archive with no frames.
+         *
+         * Measured rather than read off the first frame, so a tide that is out at the start does
+         * not get counted as ground the event flooded.
+         */
+        AlwaysAbove(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                let always = null;
+                for (let index = 0; index < this.Length; index++) {
+                    const mask = yield this.MaskAbove({
+                        threshold: options.threshold,
+                        frame: index,
+                        excludeBaseline: options.excludeBaseline,
+                        source: options.source
+                    });
+                    always = always ? Combine(always, mask, (left, right) => left && right) : mask;
+                }
+                return always;
+            });
+        }
+        /**
+         * One frame's mask with anything below the noise floor already removed.
+         *
+         * Built from the components so the floor is applied once, which is what lets two frames be
+         * compared as sets that already agree on what counts.
+         */
+        CoveredMask(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const mask = yield this.MaskAbove(options);
+                const floor = options.minTexels == null ? ValueMapReader.MIN_TEXELS : options.minTexels;
+                if (floor <= 1) {
+                    return mask;
+                }
+                const keep = new Uint8Array(mask.Bits.length);
+                for (const members of Components(mask, floor)) {
+                    for (const texel of members) {
+                        keep[texel.Row * mask.Width + texel.Column] = 1;
+                    }
+                }
+                return { Width: mask.Width, Height: mask.Height, Bits: keep };
+            });
+        }
+        /**
+         * How many texels are over the threshold in each frame.
+         *
+         * Decoding is local, so the whole series is read without a request and the frames worth
+         * querying can be found rather than guessed at.
+         */
+        Profile(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const floor = options.minTexels == null ? 1 : options.minTexels;
+                const counts = [];
+                for (let index = 0; index < this.Length; index++) {
+                    const mask = floor <= 1
+                        ? yield this.MaskAbove({
+                            threshold: options.threshold,
+                            frame: index,
+                            excludeBaseline: options.excludeBaseline,
+                            source: options.source
+                        })
+                        : yield this.CoveredMask({
+                            threshold: options.threshold,
+                            frame: index,
+                            minTexels: floor,
+                            excludeBaseline: options.excludeBaseline,
+                            source: options.source
+                        });
+                    counts.push(Count(mask));
+                }
+                return counts;
+            });
+        }
+        /**
+         * The frames that characterise an event: it arriving, its worst, and it passing.
+         *
+         * Read off the series rather than named by the caller, since a frame number that suits one
+         * archive is quietly wrong for the next and finding the worst is usually the question.
+         */
+        FramesOfInterest(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const counts = yield this.Profile(options);
+                if (!counts.length) {
+                    return [];
+                }
+                let peak = 0;
+                for (let index = 1; index < counts.length; index++) {
+                    if (counts[index] > counts[peak]) {
+                        peak = index;
+                    }
+                }
+                if (!counts[peak]) {
+                    return [];
+                }
+                const limit = counts[peak] * (options.fraction == null ? ValueMapReader.ONSET_FRACTION : options.fraction);
+                const over = [];
+                counts.forEach((count, index) => {
+                    if (count >= limit) {
+                        over.push(index);
+                    }
+                });
+                // De-duplicated, since a short event can put all three on one frame.
+                const picked = [over[0], peak, over[over.length - 1]];
+                return picked.filter((at, index) => picked.indexOf(at) === index).sort((a, b) => a - b);
+            });
+        }
+        /**
+         * Each area of one frame over a threshold, as a Bruce geometry ready to query with.
+         * Holes are dropped unless asked for.
+         */
+        ShapesAbove(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const mask = yield this.MaskAbove({
+                    threshold: options.threshold,
+                    frame: options.frame,
+                    excludeBaseline: options.excludeBaseline,
+                    source: options.source
+                });
+                return this.ShapesOf(mask, {
+                    minTexels: options.minTexels,
+                    keepHoles: options.keepHoles,
+                    tolerance: options.tolerance
+                });
+            });
+        }
+        /**
+         * Each area of any mask as a Bruce geometry, for a caller who built the mask itself.
+         */
+        ShapesOf(mask, params) {
+            const options = params || {};
+            const floor = options.minTexels == null ? ValueMapReader.MIN_TEXELS : options.minTexels;
+            const shapes = [];
+            for (const members of Components(mask, floor)) {
+                const rings = this.RingsOf(members, options.tolerance);
+                if (rings.Outer.length < ValueMapReader.MIN_RING_POINTS) {
+                    continue;
+                }
+                shapes.push(Polygon(rings.Outer, options.keepHoles ? rings.Holes : []));
+            }
+            return shapes;
+        }
+        /**
+         * One area's outer ring and its holes, as positions.
+         *
+         * The longest ring is the outer one, since a hole is enclosed by what surrounds it. Pass a
+         * tolerance of 0 to keep every traced vertex.
+         */
+        RingsOf(members, tolerance) {
+            const traced = Trace(members);
+            if (!traced.length) {
+                return { Outer: [], Holes: [] };
+            }
+            traced.sort((left, right) => right.length - left.length);
+            const reduce = tolerance == null ? ValueMapReader.SIMPLIFY_TOLERANCE : tolerance;
+            const outer = reduce ? Simplify(traced[0], reduce) : traced[0];
+            const holes = traced.slice(1)
+                .map((hole) => (reduce ? Simplify(hole, reduce) : hole))
+                .filter((hole) => hole.length >= 4);
+            return {
+                Outer: this.Grid.RingToPoints(outer),
+                Holes: holes.map((hole) => this.Grid.RingToPoints(hole))
+            };
+        }
+        /**
+         * Walks the series in order, reporting only the ground each frame adds.
+         * Most frames add nothing, so onProgress is called for every frame while only the ones that grew come back.
+         */
+        NewAreas(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const options = params || {};
+                const times = this.Times;
+                const added = [];
+                let seen = null;
+                for (let index = 0; index < this.Length; index++) {
+                    const mask = yield this.CoveredMask({
+                        threshold: options.threshold,
+                        frame: index,
+                        minTexels: options.minTexels,
+                        excludeBaseline: options.excludeBaseline,
+                        source: options.source
+                    });
+                    const fresh = seen ? Combine(mask, seen, (left, right) => left && !right) : mask;
+                    seen = seen ? Combine(seen, mask, (left, right) => left || right) : mask;
+                    // Each area here sits inside one that already cleared the floor, so applying the
+                    // floor again would drop the thin edge that makes this frame new.
+                    const shapes = Count(fresh)
+                        ? this.ShapesOf(fresh, { minTexels: 1, tolerance: options.tolerance })
+                        : [];
+                    if (options.onProgress) {
+                        options.onProgress({
+                            Frame: index,
+                            Frames: this.Length,
+                            Time: times[index] || null,
+                            NewTexels: Count(fresh),
+                            Added: !!shapes.length
+                        });
+                    }
+                    if (shapes.length) {
+                        added.push({
+                            Frame: index,
+                            Time: times[index] || null,
+                            NewTexels: Count(fresh),
+                            Shapes: shapes,
+                            New: fresh,
+                            Cumulative: { Width: seen.Width, Height: seen.Height, Bits: seen.Bits.slice() }
+                        });
+                    }
+                }
+                return added;
+            });
+        }
+        /**
+         * The texels an Entity covers, from where its record says it is.
+         *
+         * The raster does not move, so this holds for the whole series and a caller reading every
+         * frame works it out once.
+         *
+         * Ask for geometry to use the Entity's own outline rather than the box around it.
+         */
+        TexelsOf(entity, useGeometry = false) {
+            if (useGeometry) {
+                const rings = RingsOfEntity(entity);
+                if (rings.length) {
+                    const hits = new Map();
+                    for (const ring of rings) {
+                        for (const texel of this.Grid.TexelsUnder(ring)) {
+                            hits.set(texel.Row + ":" + texel.Column, texel);
+                        }
+                    }
+                    const found = [];
+                    hits.forEach((texel) => found.push(texel));
+                    return found.sort((left, right) => left.Row - right.Row || left.Column - right.Column);
+                }
+            }
+            return this.Grid.TexelsIn(bounds_1.Bounds.FromEntity(entity));
+        }
+        /**
+         * Every value a frame holds over a set of texels, skipping the texels it never sampled.
+         *
+         * An unsampled texel decodes to the bottom of the archive's range, which reads as a real
+         * measurement rather than as an absence, so the coverage mask decides what is reported.
+         */
+        ReadingsAt(texels, frame) {
+            const readings = [];
+            for (const texel of texels || []) {
+                const at = texel.Row * frame.Width + texel.Column;
+                if (at < 0 || at >= frame.Covered.length || !frame.Covered[at]) {
+                    continue;
+                }
+                readings.push(frame.Values[at]);
+            }
+            return readings;
+        }
+        /**
+         * The highest value a frame holds over a set of texels, or null where it holds nothing.
+         *
+         * The highest rather than the middle one, because something spanning more than one texel is
+         * described by its worst part.
+         */
+        PeakAt(texels, frame = 0, source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const readings = this.ReadingsAt(texels, yield this.Frame(frame, source));
+                return readings.length ? Math.max.apply(null, readings) : null;
+            });
+        }
+        /**
+         * The average value a frame holds over a set of texels, or null where it holds nothing.
+         * What something spanning several texels experienced overall, as against the worst part.
+         */
+        MeanAt(texels, frame = 0, source = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const readings = this.ReadingsAt(texels, yield this.Frame(frame, source));
+                return readings.length ? Sum(readings) / readings.length : null;
+            });
+        }
+        /**
+         * How the values over a mask are spread, for a caller reporting on an area.
+         */
+        ValuesAt(mask, frame) {
+            const selected = [];
+            for (let at = 0; at < mask.Bits.length; at++) {
+                if (mask.Bits[at] && frame.Covered[at]) {
+                    selected.push(frame.Values[at]);
+                }
+            }
+            if (!selected.length) {
+                return { Texels: 0 };
+            }
+            selected.sort((left, right) => left - right);
+            const middle = Math.floor(selected.length / 2);
+            return {
+                Texels: selected.length,
+                Peak: selected[selected.length - 1],
+                Mean: Sum(selected) / selected.length,
+                Median: selected.length % 2
+                    ? selected[middle]
+                    : (selected[middle - 1] + selected[middle]) / 2
+            };
+        }
+        /**
+         * The finest tile covering a position, or null when it falls outside every one of them.
+         *
+         * Tiles overlap, and the finer one is the better answer, so the last match wins over a list
+         * that is already sorted coarse first.
+         */
+        TileAt(longitude, latitude) {
+            let found = null;
+            for (const tile of this.Tiles) {
+                if (longitude >= tile.West && longitude <= tile.East
+                    && latitude >= tile.South && latitude <= tile.North) {
+                    found = tile;
+                }
+            }
+            return found;
+        }
+        /**
+         * One reading at one place, in both the delivered numbers and the source's own.
+         *
+         * Reads the single tile the position falls in rather than compositing the whole grid, which
+         * is what makes charting one point over a long series cheap.
+         */
+        SampleAt(longitude, latitude, frame = 0) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const tile = this.TileAt(longitude, latitude);
+                if (!tile) {
+                    return null;
+                }
+                const position = this.position(frame);
+                const times = this.Times;
+                const reading = {
+                    Longitude: longitude,
+                    Latitude: latitude,
+                    Frame: position,
+                    Time: times[position] || null,
+                    Units: this.Units,
+                    Texel: this.Grid.TexelAt(longitude, latitude),
+                    Covered: false,
+                    Value: null,
+                    SourceValue: null
+                };
+                const at = TexelIn(tile, longitude, latitude);
+                if (!at) {
+                    return reading;
+                }
+                const index = this.Tiles.indexOf(tile);
+                const values = yield this.tileLayer(index, value_map_metadata_1.ValueMapMetadata.LAYER_VALUE, position);
+                if (!values || !values.Values) {
+                    return reading;
+                }
+                const cell = at.Row * values.Width + at.Column;
+                if (!values.Covered[cell]) {
+                    return reading;
+                }
+                const value = values.Values[cell];
+                reading.Covered = true;
+                reading.Value = value;
+                reading.SourceValue = value;
+                if (this.Transform) {
+                    const shift = yield this.tileLayer(index, value_map_metadata_1.ValueMapMetadata.LAYER_VALUE_SHIFT);
+                    if (!shift || !shift.Values) {
+                        throw new Error(this.missingShift());
+                    }
+                    reading.SourceValue = shift.Covered[cell] ? value - shift.Values[cell] : null;
+                }
+                return reading;
+            });
+        }
+        /**
+         * Everything the archive knows about one place, for a caller inspecting a single point.
+         */
+        DetailsAt(longitude, latitude, frame = 0) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const reading = yield this.SampleAt(longitude, latitude, frame);
+                if (!reading) {
+                    return null;
+                }
+                const tile = this.TileAt(longitude, latitude);
+                const at = TexelIn(tile, longitude, latitude);
+                const position = this.Tiles.indexOf(tile);
+                return Object.assign({}, reading, {
+                    Attribute: this.Attribute,
+                    Label: this.Label,
+                    Dataset: this.Dataset,
+                    Frames: this.Length,
+                    Transform: this.Transform || null,
+                    VerticalDatum: this.VerticalDatum,
+                    Tile: {
+                        Level: tile.Level,
+                        TexelMetres: tile.TexelMetres,
+                        ResolutionX: tile.ResolutionX,
+                        ResolutionY: tile.ResolutionY,
+                        West: tile.West,
+                        East: tile.East,
+                        South: tile.South,
+                        North: tile.North
+                    },
+                    TileTexel: at,
+                    ValueMin: yield this.tileReading(position, value_map_metadata_1.ValueMapMetadata.LAYER_VALUE_MIN, at),
+                    ValueMax: yield this.tileReading(position, value_map_metadata_1.ValueMapMetadata.LAYER_VALUE_MAX, at),
+                    Shift: yield this.tileReading(position, value_map_metadata_1.ValueMapMetadata.LAYER_VALUE_SHIFT, at),
+                    Baseline: yield this.tileFlag(position, value_map_metadata_1.ValueMapMetadata.LAYER_BASELINE, at)
+                });
+            });
+        }
+        /**
+         * Every reading at one place over the whole series, in the order the times run.
+         */
+        SeriesAt(longitude, latitude) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const tile = this.TileAt(longitude, latitude);
+                if (!tile) {
+                    return [];
+                }
+                const at = TexelIn(tile, longitude, latitude);
+                const times = this.Times;
+                const position = this.Tiles.indexOf(tile);
+                const frames = yield this.tileSeries(position, value_map_metadata_1.ValueMapMetadata.LAYER_VALUE);
+                const shift = this.Transform
+                    ? yield this.tileLayer(position, value_map_metadata_1.ValueMapMetadata.LAYER_VALUE_SHIFT)
+                    : null;
+                if (this.Transform && (!shift || !shift.Values)) {
+                    throw new Error(this.missingShift());
+                }
+                return times.map((time, index) => {
+                    const reading = {
+                        Longitude: longitude,
+                        Latitude: latitude,
+                        Frame: index,
+                        Time: time,
+                        Units: this.Units,
+                        Texel: this.Grid.TexelAt(longitude, latitude),
+                        Covered: false,
+                        Value: null,
+                        SourceValue: null
+                    };
+                    const field = frames[index];
+                    if (!at || !field || !field.Values) {
+                        return reading;
+                    }
+                    const cell = at.Row * field.Width + at.Column;
+                    if (!field.Covered[cell]) {
+                        return reading;
+                    }
+                    reading.Covered = true;
+                    reading.Value = field.Values[cell];
+                    reading.SourceValue = field.Values[cell];
+                    if (shift) {
+                        reading.SourceValue = shift.Covered[cell]
+                            ? field.Values[cell] - shift.Values[cell]
+                            : null;
+                    }
+                    return reading;
+                });
+            });
+        }
+        /**
+         * What one frame holds over an Entity, in both the delivered numbers and the source's own.
+         */
+        SampleOf(entity, frame = 0, useGeometry = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const texels = this.TexelsOf(entity, useGeometry);
+                const times = this.Times;
+                const position = frame >= 0 ? frame : times.length + frame;
+                const summary = {
+                    Frame: position,
+                    Time: times[position] || null,
+                    Units: this.Units,
+                    Texels: texels.length,
+                    Covered: 0,
+                    Peak: null,
+                    Mean: null,
+                    SourcePeak: null,
+                    SourceMean: null
+                };
+                if (!texels.length) {
+                    return summary;
+                }
+                const readings = this.ReadingsAt(texels, yield this.Frame(position));
+                summary.Covered = readings.length;
+                if (readings.length) {
+                    summary.Peak = Math.max.apply(null, readings);
+                    summary.Mean = Sum(readings) / readings.length;
+                }
+                if (!this.Transform) {
+                    summary.SourcePeak = summary.Peak;
+                    summary.SourceMean = summary.Mean;
+                    return summary;
+                }
+                const sourceReadings = this.ReadingsAt(texels, yield this.Frame(position, true));
+                if (sourceReadings.length) {
+                    summary.SourcePeak = Math.max.apply(null, sourceReadings);
+                    summary.SourceMean = Sum(sourceReadings) / sourceReadings.length;
+                }
+                return summary;
+            });
+        }
+        /**
+         * What every frame holds over one Entity, for a caller charting a record through an event.
+         */
+        SeriesOf(entity, useGeometry = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const summaries = [];
+                for (let index = 0; index < this.Length; index++) {
+                    summaries.push(yield this.SampleOf(entity, index, useGeometry));
+                }
+                return summaries;
+            });
+        }
+        identity() {
+            return this.Metadata.Identity || {};
+        }
+        /*
+         * A frame index checked against the series, with a negative one counted from the end.
+         */
+        position(index) {
+            const frames = this.Length;
+            if (!frames) {
+                throw new Error("This value map has no frames.");
+            }
+            const at = index >= 0 ? index : frames + index;
+            if (at < 0 || at >= frames) {
+                throw new Error("Frame " + index + " is outside the " + frames
+                    + " this value map holds.");
+            }
+            return at;
+        }
+        /*
+         * One per-texel statistic over the whole series, in the archive's own units, or null.
+         */
+        statistic(name) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.statistics.has(name)) {
+                    return this.statistics.get(name);
+                }
+                const field = this.Layer(name) ? yield this.composite(name) : null;
+                this.statistics.set(name, field);
+                return field;
+            });
+        }
+        /*
+         * One layer drawn onto the composite grid from every tile that carries it.
+         *
+         * Nearest neighbour throughout: a texel is one mesh sample, and interpolating it with its
+         * neighbour produces a reading no cell ever reported.
+         */
+        composite(name, index) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const width = this.Grid.Width;
+                const height = this.Grid.Height;
+                const isMask = this.packing(name) === value_map_metadata_1.ValueMapMetadata.FORMAT_MASK;
+                const values = isMask ? null : new Float64Array(width * height);
+                const covered = new Uint8Array(width * height);
+                const ranges = this.Tiles.map((tile) => value_map_metadata_1.ValueMapMetadata.BytesOf(tile, name, index));
+                const rasters = yield this.decodeAll(ranges);
+                let drawn = false;
+                for (let at = 0; at < this.Tiles.length; at++) {
+                    const raster = rasters[at];
+                    if (!raster) {
+                        continue;
+                    }
+                    drawn = true;
+                    this.paste(this.Tiles[at], raster, name, values, covered);
+                }
+                if (!drawn) {
+                    return null;
+                }
+                return { Width: width, Height: height, Values: values, Covered: covered };
+            });
+        }
+        /*
+         * One tile's pixels written onto the composite grid, unpacked as they land.
+         */
+        paste(tile, raster, name, values, covered) {
+            const rect = value_map_grid_1.ValueMapGrid.TileRect(tile, this.Extent, { Width: this.Grid.Width, Height: this.Grid.Height });
+            const range = this.range(name);
+            const format = this.packing(name);
+            const width = this.Grid.Width;
+            const height = this.Grid.Height;
+            for (let row = 0; row < rect.Height; row++) {
+                const target = rect.Top + row;
+                if (target < 0 || target >= height) {
+                    continue;
+                }
+                const sourceRow = Math.min(raster.Height - 1, Math.floor((row + 0.5) * raster.Height / rect.Height));
+                for (let column = 0; column < rect.Width; column++) {
+                    const across = rect.Left + column;
+                    if (across < 0 || across >= width) {
+                        continue;
+                    }
+                    const sourceColumn = Math.min(raster.Width - 1, Math.floor((column + 0.5) * raster.Width / rect.Width));
+                    const from = (sourceRow * raster.Width + sourceColumn) * 4;
+                    const to = target * width + across;
+                    if (raster.Data[from + 3] <= value_map_metadata_1.ValueMapMetadata.NO_DATA) {
+                        covered[to] = 0;
+                        if (values) {
+                            values[to] = 0;
+                        }
+                        continue;
+                    }
+                    covered[to] = 1;
+                    if (values) {
+                        values[to] = value_map_metadata_1.ValueMapMetadata.Decode(value_map_metadata_1.ValueMapMetadata.PackedAt(raster.Data, from, format), format, range);
+                    }
+                }
+            }
+        }
+        /*
+         * One tile's copy of a layer, unpacked, or null when that tile does not carry it.
+         *
+         * Kept per tile rather than composited, since a point sits in one tile and building the
+         * whole grid to read a single texel costs one image decode per tile in the archive.
+         */
+        tileLayer(position, name, index) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const key = position + ":" + name + ":" + (index == null ? "" : index);
+                if (this.tileLayers.has(key)) {
+                    const held = this.tileLayers.get(key);
+                    this.tileLayers.delete(key);
+                    this.tileLayers.set(key, held);
+                    return held;
+                }
+                const at = value_map_metadata_1.ValueMapMetadata.BytesOf(this.Tiles[position], name, index);
+                const rasters = yield this.decodeAll([at]);
+                const raster = rasters[0];
+                const field = raster
+                    ? Unpack(raster, this.packing(name), this.range(name))
+                    : null;
+                this.tileLayers.set(key, field);
+                Trim(this.tileLayers, ValueMapReader.TILE_CACHE);
+                return field;
+            });
+        }
+        /*
+         * One texel's number in a named layer of one tile, or null where the layer does not cover it.
+         */
+        tileReading(position, name, at) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!at || !this.Layer(name)) {
+                    return null;
+                }
+                const field = yield this.tileLayer(position, name);
+                if (!field || !field.Values) {
+                    return null;
+                }
+                const cell = at.Row * field.Width + at.Column;
+                return field.Covered[cell] ? field.Values[cell] : null;
+            });
+        }
+        /*
+         * Whether a mask layer flags one texel of one tile.
+         */
+        tileFlag(position, name, at) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!at || !this.Layer(name)) {
+                    return false;
+                }
+                const field = yield this.tileLayer(position, name);
+                if (!field) {
+                    return false;
+                }
+                return !!field.Covered[at.Row * field.Width + at.Column];
+            });
+        }
+        /*
+         * One tile's whole per-time series, unpacked, in one read of the blob.
+         *
+         * Kept out of the tile cache on purpose: a long series would evict everything else in it,
+         * and the caller walking a chart holds the result anyway.
+         */
+        tileSeries(position, name) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const tile = this.Tiles[position];
+                const ranges = this.Times.map((_time, index) => value_map_metadata_1.ValueMapMetadata.BytesOf(tile, name, index));
+                const rasters = yield this.decodeAll(ranges);
+                const format = this.packing(name);
+                const range = this.range(name);
+                return rasters.map((raster) => raster ? Unpack(raster, format, range) : null);
+            });
+        }
+        /*
+         * Every named slice decoded, over as few reads of the blob as the layout allows.
+         */
+        decodeAll(ranges) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const reads = value_map_metadata_1.ValueMapMetadata.PlanReads(ranges);
+                if (!reads.length) {
+                    return ranges.map(() => null);
+                }
+                const blocks = yield Promise.all(reads.map((read) => this.bytes(read.Offset, read.Length)));
+                return Promise.all(ranges.map((at) => {
+                    if (!at || !at.Length) {
+                        return Promise.resolve(null);
+                    }
+                    for (let index = 0; index < reads.length; index++) {
+                        const read = reads[index];
+                        if (at.Offset < read.Offset || at.Offset + at.Length > read.Offset + read.Length) {
+                            continue;
+                        }
+                        const from = at.Offset - read.Offset;
+                        return this.decoder(blocks[index].subarray(from, from + at.Length))
+                            .catch(() => null);
+                    }
+                    return Promise.resolve(null);
+                }));
+            });
+        }
+        /*
+         * How a named layer is packed, since a statistics layer can differ from the frames.
+         */
+        packing(name) {
+            const layer = this.Layer(name);
+            return (layer && layer.Format) || this.Format;
+        }
+        /*
+         * The range a named layer was quantised over, falling back to the frames' own.
+         */
+        range(name) {
+            return value_map_metadata_1.ValueMapMetadata.LayerRange(this.Metadata, name) || this.ValueRange;
+        }
+        /*
+         * A frame's delivered values as the source's own numbers.
+         *
+         * Nothing to undo is the common case and is not an error: an archive that declares no
+         * transform delivered the source's numbers untouched.
+         */
+        toSource(frame) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.Transform) {
+                    return frame;
+                }
+                const shift = yield this.ValueShift();
+                if (!shift || !shift.Values) {
+                    throw new Error(this.missingShift());
+                }
+                const values = new Float64Array(frame.Values.length);
+                const covered = new Uint8Array(frame.Covered.length);
+                for (let at = 0; at < values.length; at++) {
+                    // A texel the shift never sampled has no source reading to report, whatever the
+                    // frame holds.
+                    covered[at] = frame.Covered[at] && shift.Covered[at] ? 1 : 0;
+                    values[at] = frame.Values[at] - (shift.Covered[at] ? shift.Values[at] : 0);
+                }
+                return { Width: frame.Width, Height: frame.Height, Values: values, Covered: covered };
+            });
+        }
+        missingShift() {
+            return "This value map declares a " + this.Transform + " transform but publishes no "
+                + value_map_metadata_1.ValueMapMetadata.LAYER_VALUE_SHIFT + " layer, so the source's own numbers cannot be"
+                + " recovered.";
+        }
+    }
+    ValueMapReader.Reader = Reader;
+    function Open(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let file = params.file;
+            if (!file) {
+                if (!params.fileId) {
+                    throw new Error("A Client File, or a Client File ID, is required.");
+                }
+                const found = yield client_file_1.ClientFile.Get({ api: params.api, fileId: params.fileId });
+                file = found ? found.clientFile : null;
+            }
+            if (!file) {
+                throw new Error("Client File " + params.fileId + " was not found.");
+            }
+            return new Reader({
+                file: file,
+                bytes: params.bytes || SourceFor(file, params.blob, params.api),
+                decoder: params.decoder,
+                maxCompositeTexels: params.maxCompositeTexels,
+                extent: params.extent
+            });
+        });
+    }
+    ValueMapReader.Open = Open;
+    /**
+     * Where an archive's bytes come from: a blob already held, or ranged reads of the file's URL.
+     */
+    function SourceFor(file, blob, api) {
+        if (blob) {
+            const held = blob instanceof Uint8Array ? blob : new Uint8Array(blob);
+            return (offset, length) => Promise.resolve(held.subarray(offset, offset + length));
+        }
+        // The record's own URL where it carries one, since it may be a signed or CDN address that
+        // a reconstructed one would not match.
+        const url = file.URL || client_file_1.ClientFile.GetUrl({ api: api, fileId: file.ID });
+        return (offset, length) => __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(url, {
+                headers: { Range: "bytes=" + offset + "-" + (offset + length - 1) }
+            });
+            return new Uint8Array(yield response.arrayBuffer());
+        });
+    }
+    ValueMapReader.SourceFor = SourceFor;
+    /**
+     * Decodes a PNG where the runtime has an image decoder of its own.
+     *
+     * A browser has one. Node does not, and rather than pull an image library into a client library
+     * that mostly does not decode anything, a caller there passes their own.
+     */
+    ValueMapReader.DefaultDecoder = (bytes) => __awaiter(this, void 0, void 0, function* () {
+        const globals = typeof globalThis !== "undefined" ? globalThis : {};
+        if (typeof globals.createImageBitmap !== "function" || typeof globals.OffscreenCanvas !== "function") {
+            throw new Error("This runtime has no image decoder, so a value map's pixels cannot be"
+                + " read here. Pass Decoder to read them, or use the metadata surface, which needs"
+                + " no decoding.");
+        }
+        const blob = new globals.Blob([bytes], { type: "image/png" });
+        const bitmap = yield globals.createImageBitmap(blob);
+        try {
+            const canvas = new globals.OffscreenCanvas(bitmap.width, bitmap.height);
+            const context = canvas.getContext("2d");
+            context.drawImage(bitmap, 0, 0);
+            const pixels = context.getImageData(0, 0, bitmap.width, bitmap.height);
+            return { Width: bitmap.width, Height: bitmap.height, Data: pixels.data };
+        }
+        finally {
+            if (bitmap.close) {
+                bitmap.close();
+            }
+        }
+    });
+    // A ring needs three distinct corners and the repeat that closes it.
+    ValueMapReader.MIN_RING_POINTS = 4;
+    /**
+     * The disconnected areas in a mask, as 4-connected groups of texels.
+     */
+    function Components(mask, minTexels = 1) {
+        const width = mask.Width;
+        const height = mask.Height;
+        const seen = new Uint8Array(mask.Bits.length);
+        const found = [];
+        for (let start = 0; start < mask.Bits.length; start++) {
+            if (!mask.Bits[start] || seen[start]) {
+                continue;
+            }
+            seen[start] = 1;
+            const pending = [start];
+            const members = [];
+            while (pending.length) {
+                const at = pending.pop();
+                const row = Math.floor(at / width);
+                const column = at - row * width;
+                members.push({ Row: row, Column: column });
+                if (row > 0) {
+                    Visit(mask, seen, pending, at - width);
+                }
+                if (row < height - 1) {
+                    Visit(mask, seen, pending, at + width);
+                }
+                if (column > 0) {
+                    Visit(mask, seen, pending, at - 1);
+                }
+                if (column < width - 1) {
+                    Visit(mask, seen, pending, at + 1);
+                }
+            }
+            if (members.length >= minTexels) {
+                found.push(members);
+            }
+        }
+        return found;
+    }
+    ValueMapReader.Components = Components;
+    /**
+     * The closed rings bounding a group of texels, in texel corner coordinates.
+     */
+    function Trace(members) {
+        const held = new Set();
+        for (const texel of members) {
+            held.add(texel.Row + ":" + texel.Column);
+        }
+        const edges = new Map();
+        const emit = (from, to) => {
+            const outgoing = edges.get(from);
+            if (outgoing) {
+                outgoing.push(to);
+            }
+            else {
+                edges.set(from, [to]);
+            }
+        };
+        const corner = (x, y) => x + ":" + y;
+        for (const texel of members) {
+            const row = texel.Row;
+            const column = texel.Column;
+            if (!held.has((row - 1) + ":" + column)) {
+                emit(corner(column, row), corner(column + 1, row));
+            }
+            if (!held.has(row + ":" + (column + 1))) {
+                emit(corner(column + 1, row), corner(column + 1, row + 1));
+            }
+            if (!held.has((row + 1) + ":" + column)) {
+                emit(corner(column + 1, row + 1), corner(column, row + 1));
+            }
+            if (!held.has(row + ":" + (column - 1))) {
+                emit(corner(column, row + 1), corner(column, row));
+            }
+        }
+        const rings = [];
+        const starts = [];
+        edges.forEach((_outgoing, from) => starts.push(from));
+        for (const start of starts) {
+            while ((edges.get(start) || []).length) {
+                const ring = [start];
+                let node = edges.get(start).pop();
+                let closed = true;
+                while (node !== start) {
+                    ring.push(node);
+                    const outgoing = edges.get(node);
+                    if (!outgoing || !outgoing.length) {
+                        closed = false;
+                        break;
+                    }
+                    node = outgoing.pop();
+                }
+                if (closed) {
+                    ring.push(start);
+                    rings.push(ring.map(ToCorner));
+                }
+            }
+        }
+        return rings;
+    }
+    ValueMapReader.Trace = Trace;
+    /**
+     * A ring with its texel staircase reduced, by Ramer-Douglas-Peucker.
+     */
+    function Simplify(ring, tolerance) {
+        const points = ring.slice();
+        if (tolerance <= 0 || points.length < 4) {
+            return points;
+        }
+        // Split before reducing: the algorithm anchors on the endpoints, and a closed ring's two
+        // endpoints are the same point, which would anchor on nothing.
+        const half = Math.floor(points.length / 2);
+        const front = Reduce(points.slice(0, half + 1), tolerance);
+        const back = Reduce(points.slice(half), tolerance);
+        const reduced = front.slice(0, front.length - 1).concat(back);
+        return reduced.length >= 4 ? reduced : points;
+    }
+    ValueMapReader.Simplify = Simplify;
+    /**
+     * How many texels a mask holds.
+     */
+    function Count(mask) {
+        let total = 0;
+        for (let at = 0; at < mask.Bits.length; at++) {
+            total += mask.Bits[at] ? 1 : 0;
+        }
+        return total;
+    }
+    ValueMapReader.Count = Count;
+    /**
+     * Two masks merged texel by texel.
+     */
+    function Combine(left, right, rule) {
+        const bits = new Uint8Array(left.Bits.length);
+        for (let at = 0; at < bits.length; at++) {
+            bits[at] = rule(!!left.Bits[at], !!right.Bits[at]) ? 1 : 0;
+        }
+        return { Width: left.Width, Height: left.Height, Bits: bits };
+    }
+    ValueMapReader.Combine = Combine;
+    /**
+     * A polygon geometry from an outer ring and its holes, ready to query Bruce with.
+     */
+    function Polygon(outer, holes) {
+        const toCartos = (ring) => ring.map((point) => ({
+            longitude: point.Longitude,
+            latitude: point.Latitude,
+            altitude: 0
+        }));
+        const rings = [{
+                LinearRing: geometry_1.Geometry.LineStrFromPoints(toCartos(outer)),
+                Facing: geometry_1.Geometry.EPolygonRingType.Boundaries
+            }];
+        for (const hole of holes || []) {
+            rings.push({
+                LinearRing: geometry_1.Geometry.LineStrFromPoints(toCartos(hole)),
+                Facing: geometry_1.Geometry.EPolygonRingType.Hole
+            });
+        }
+        return { Polygon: rings };
+    }
+    ValueMapReader.Polygon = Polygon;
+    /**
+     * An Entity's polygon rings, or nothing when its record carries no outline.
+     */
+    function RingsOfEntity(entity) {
+        const source = entity && entity.Bruce ? entity.Bruce : entity;
+        const geometry = (source && source.VectorGeometry) || {};
+        const rings = [];
+        for (const face of geometry.Polygon || []) {
+            if (!face || !face.LinearRing) {
+                continue;
+            }
+            const points = geometry_1.Geometry.ParsePoints(face.LinearRing);
+            if (points.length >= 3) {
+                rings.push(points.map((point) => ({
+                    Longitude: point.longitude,
+                    Latitude: point.latitude
+                })));
+            }
+        }
+        return rings;
+    }
+    ValueMapReader.RingsOfEntity = RingsOfEntity;
+    /*
+     * One decoded raster as its numbers and its own coverage, at the raster's own size.
+     */
+    function Unpack(raster, format, range) {
+        const isMask = format === value_map_metadata_1.ValueMapMetadata.FORMAT_MASK;
+        const values = isMask ? null : new Float64Array(raster.Width * raster.Height);
+        const covered = new Uint8Array(raster.Width * raster.Height);
+        for (let cell = 0; cell < covered.length; cell++) {
+            const from = cell * 4;
+            if (raster.Data[from + 3] <= value_map_metadata_1.ValueMapMetadata.NO_DATA) {
+                continue;
+            }
+            covered[cell] = 1;
+            if (values) {
+                values[cell] = value_map_metadata_1.ValueMapMetadata.Decode(value_map_metadata_1.ValueMapMetadata.PackedAt(raster.Data, from, format), format, range);
+            }
+        }
+        return { Width: raster.Width, Height: raster.Height, Values: values, Covered: covered };
+    }
+    /*
+     * One neighbour queued, when it is in the mask and has not been reached yet.
+     */
+    function Visit(mask, seen, pending, at) {
+        if (mask.Bits[at] && !seen[at]) {
+            seen[at] = 1;
+            pending.push(at);
+        }
+    }
+    /*
+     * One run of a ring reduced against the line between its ends.
+     */
+    function Reduce(run, tolerance) {
+        if (run.length < 3) {
+            return run;
+        }
+        const first = run[0];
+        const last = run[run.length - 1];
+        const dx = last.X - first.X;
+        const dy = last.Y - first.Y;
+        const span = Math.sqrt(dx * dx + dy * dy);
+        let worstIndex = 0;
+        let worst = -1;
+        for (let index = 1; index < run.length - 1; index++) {
+            const point = run[index];
+            const distance = span === 0
+                ? Math.sqrt(Math.pow(point.X - first.X, 2) + Math.pow(point.Y - first.Y, 2))
+                : Math.abs(dy * point.X - dx * point.Y + last.X * first.Y - last.Y * first.X) / span;
+            if (distance > worst) {
+                worst = distance;
+                worstIndex = index;
+            }
+        }
+        if (worst <= tolerance) {
+            return [first, last];
+        }
+        const front = Reduce(run.slice(0, worstIndex + 1), tolerance);
+        return front.slice(0, front.length - 1).concat(Reduce(run.slice(worstIndex), tolerance));
+    }
+    /*
+     * A corner key back as its coordinates.
+     */
+    function ToCorner(key) {
+        const parts = key.split(":");
+        return { X: Number(parts[0]), Y: Number(parts[1]) };
+    }
+    /*
+     * The population standard deviation of a set of counts.
+     */
+    function Deviation(counts) {
+        if (!counts.length) {
+            return 0;
+        }
+        const mean = Sum(counts) / counts.length;
+        let total = 0;
+        for (const count of counts) {
+            total += Math.pow(count - mean, 2);
+        }
+        return Math.sqrt(total / counts.length);
+    }
+    function Sum(values) {
+        let total = 0;
+        for (const value of values) {
+            total += value;
+        }
+        return total;
+    }
+    /*
+     * Where a position lands inside one tile's own raster.
+     */
+    function TexelIn(tile, longitude, latitude) {
+        if (tile.East <= tile.West || tile.North <= tile.South) {
+            return null;
+        }
+        const width = tile.ResolutionX;
+        const height = tile.ResolutionY;
+        const column = Math.max(0, Math.min(width - 1, Math.floor((longitude - tile.West) / (tile.East - tile.West) * width)));
+        const row = Math.max(0, Math.min(height - 1, Math.floor((tile.North - latitude) / (tile.North - tile.South) * height)));
+        return { Row: row, Column: column };
+    }
+    /*
+     * The oldest entries dropped once a cache is over its limit.
+     */
+    function Trim(cache, limit) {
+        while (cache.size > limit) {
+            const oldest = cache.keys().next();
+            if (oldest.done) {
+                return;
+            }
+            cache.delete(oldest.value);
+        }
+    }
+})(ValueMapReader = exports.ValueMapReader || (exports.ValueMapReader = {}));
+//# sourceMappingURL=value-map-reader.js.map