@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/heatwave/isobar/plugin.js

@@ -0,0 +1,362 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsobarRasterToVector = void 0;
+var util_1 = require("../../util");
+var quadtreecontours_1 = __importStar(require("./quadtreecontours"));
+var objectarraylabels_1 = __importDefault(require("./objectarraylabels"));
+var typecheck_1 = require("../../util/check/typecheck");
+var IsobarRasterToVector = /** @class */ (function () {
+    /**
+     * @typedef {Object} IsobarData
+     * @property {number} threshold
+     * @property {[number, number, number]} color | rgb color
+     * @property {string} label
+     *
+     * @param {*} id
+     * @param {Array<IsobarData>} isabors
+     * @param {number} width
+     * @param {number} height
+     * @param {Object} options
+     * @param {boolean} options.xFlip
+     * @param {boolean} options.yFlip
+     * @param {boolean} options.isOn
+     * @param {boolean} options.isLabelsOn
+     * @param {Object} options.labelStyle
+     */
+    function IsobarRasterToVector(id, dataManager, isobars, width, height, _a, _b) {
+        var _c = _a === void 0 ? [-180, -90, 180, 90] : _a, minLon = _c[0], minLat = _c[1], maxLon = _c[2], maxLat = _c[3];
+        var _d = _b === void 0 ? {} : _b, _e = _d.xFlip, xFlip = _e === void 0 ? false : _e, _f = _d.yFlip, yFlip = _f === void 0 ? true : _f, _g = _d.isOn, isOn = _g === void 0 ? true : _g, _h = _d.isLabelsOn, isLabelsOn = _h === void 0 ? true : _h, _j = _d.labelStyle, labelStyle = _j === void 0 ? null : _j, _k = _d.maxMipmapLevel, maxMipmapLevel = _k === void 0 ? null : _k;
+        this.id = id;
+        this._isobarsCheckAndComplete(isobars);
+        this.isobars = isobars;
+        this.contourMipmap = null;
+        this.width = width;
+        this.height = height;
+        this.xFlip = xFlip;
+        this.yFlip = yFlip;
+        this.bbox = [minLon, minLat, maxLon, maxLat];
+        this.dataManager = dataManager;
+        this._transformationMethod = getTransformationMethod(xFlip, yFlip, width, height, minLon, minLat, maxLon, maxLat);
+        this._isOn = isOn;
+        this._isLabelsOn = isLabelsOn;
+        this._labelsLayer = null;
+        this._labelsLayerId = id + '_isobar-labels';
+        this._lineStrignRanges = [];
+        this._transpos = new Float32Array(3);
+        this._maxMipmapLevel = maxMipmapLevel;
+        this._labelStyle = labelStyle;
+        // this._transformationMethod = null;
+    }
+    // API
+    IsobarRasterToVector.prototype.setData = function (data, on) {
+        if (on === void 0) { on = false; }
+        if (!data)
+            return;
+        this._data = data;
+        if (on)
+            this._isOn = true;
+        if (this._isOn)
+            this._calculateAll(data);
+    };
+    IsobarRasterToVector.prototype.on = function () {
+        this._isOn = true;
+        if (this._data)
+            this._calculateAll(this._data);
+    };
+    IsobarRasterToVector.prototype.off = function () {
+        this._isOn = false;
+        this.clean();
+    };
+    IsobarRasterToVector.prototype.clean = function () {
+        this.flush();
+        this.globe.DrawRender();
+    };
+    IsobarRasterToVector.prototype.setFlip = function (xFlip, yFlip) {
+        (0, typecheck_1.isBoolean)(xFlip);
+        (0, typecheck_1.isBoolean)(yFlip);
+        if (this.xFlip === xFlip && this.yFlip === yFlip)
+            return;
+        this.xFlip = xFlip;
+        this.yFlip = yFlip;
+        var _a = this.bbox, minLon = _a[0], minLat = _a[1], maxLon = _a[2], maxLat = _a[3];
+        var _b = this, width = _b.width, height = _b.height;
+        this._transformationMethod = getTransformationMethod(xFlip, yFlip, width, height, minLon, minLat, maxLon, maxLat);
+        this._calculateLines();
+        this.globe.DrawRender();
+    };
+    IsobarRasterToVector.prototype.setBoundingBox = function (_a) {
+        var minLon = _a[0], minLat = _a[1], maxLon = _a[2], maxLat = _a[3];
+        this.bbox = [minLon, minLat, maxLon, maxLat];
+        var _b = this, width = _b.width, height = _b.height, xFlip = _b.xFlip, yFlip = _b.yFlip;
+        this._transformationMethod = getTransformationMethod(xFlip, yFlip, width, height, minLon, minLat, maxLon, maxLat);
+        this._calculateLines();
+        this.globe.DrawRender();
+    };
+    IsobarRasterToVector.prototype.setIsLabelsOn = function (isLabelsOn) {
+        (0, typecheck_1.isBoolean)(isLabelsOn);
+        if (this._isLabelsOn === isLabelsOn)
+            return;
+        this._isLabelsOn = isLabelsOn;
+        if (!isLabelsOn) {
+            this._labelsLayer.removeFromMap();
+        }
+        else {
+            if (this._labelsLayer === null)
+                this._createLabelsLayer();
+            this._labelsLayer.addToMap();
+            this._createBufferData();
+        }
+    };
+    IsobarRasterToVector.prototype.getIsobars = function () {
+        return this.isobars;
+    };
+    IsobarRasterToVector.prototype.setIsobars = function (isobars) {
+        this._isobarsCheckAndComplete(isobars);
+        this.isobars = isobars;
+        this._calculateLines();
+        this.globe.DrawRender();
+    };
+    IsobarRasterToVector.prototype.setWidthHeight = function (width, height) {
+        this.width = width;
+        this.height = height;
+        var _a = this, xFlip = _a.xFlip, yFlip = _a.yFlip;
+        var _b = this.bbox, minLon = _b[0], minLat = _b[1], maxLon = _b[2], maxLat = _b[3];
+        this._transformationMethod = getTransformationMethod(xFlip, yFlip, width, height, minLon, minLat, maxLon, maxLat);
+        this._calculateLines();
+        this.globe.DrawRender();
+    };
+    IsobarRasterToVector.prototype.getLabelStyle = function () {
+        return this._labelsLayer.getLabelStyle();
+    };
+    IsobarRasterToVector.prototype.setOpacity = function (opacity) {
+        (0, typecheck_1.opacityCheck)(opacity);
+        this.program.setOpacity(opacity);
+    };
+    IsobarRasterToVector.prototype.setLabelStyle = function (style) {
+        this._labelStyle = style;
+        if (this._labelsLayer)
+            this._labelsLayer.setLabelStyle(style);
+        var lastState = this._isLabelsOn;
+        this.setIsLabelsOn(false);
+        this.setIsLabelsOn(lastState);
+        if (lastState)
+            this._createBufferData();
+    };
+    IsobarRasterToVector.prototype.setMaxMipmapLevel = function (maxMipmapLevel) {
+        if (maxMipmapLevel === void 0) { maxMipmapLevel = null; }
+        this._maxMipmapLevel = maxMipmapLevel;
+        this._calculateLines();
+        this.globe.DrawRender();
+    };
+    IsobarRasterToVector.prototype.flush = function () {
+        this.program.setBufferData(new Float32Array(0));
+        this._lineStrignRanges = [];
+        if (this._isLabelsOn)
+            this._labelsLayer.flush();
+    };
+    // 
+    // implicit methods
+    IsobarRasterToVector.prototype.init = function (globe, gl) {
+        var _this = this;
+        this.gl = gl;
+        this.globe = globe;
+        this.program = new util_1.ShapesOnGlobeProgram(gl, globe, 'line_strip');
+        if (this._isLabelsOn) {
+            this._createLabelsLayer();
+            this._labelsLayer.addToMap();
+        }
+        this.dataManager.register(this.id, function (ratio, t1, t2) {
+            if (!t1 || !t2) {
+                _this.clean();
+                return;
+            }
+            var data = dataMixer(t1, t2, ratio);
+            if (_this._isOn)
+                _this.setData(data);
+        });
+    };
+    IsobarRasterToVector.prototype.resize = function (width, height) {
+        this.program.resize(width, height);
+    };
+    IsobarRasterToVector.prototype.draw3D = function (projMatrix, modelviewMatrix, transPos) {
+        if (!this._ready)
+            return;
+        this._drawContour(projMatrix, modelviewMatrix, transPos);
+    };
+    IsobarRasterToVector.prototype._calculateLines = function () {
+        this._calculateContours();
+        this._bufferData = this._createBufferData();
+        this.program.setBufferData(this._bufferData);
+    };
+    IsobarRasterToVector.prototype._drawContour = function (projMatrix, modelviewMatrix, transPos) {
+        this.program.draw(projMatrix, modelviewMatrix, transPos, this._lineStrignRanges);
+    };
+    IsobarRasterToVector.prototype._calculateIntersections = function (threshold) {
+        var _transformationMethod = this._transformationMethod;
+        var lines = this.contourMipmap.contour([threshold], { maxMipmapLevel: this._maxMipmapLevel }).map(function (coords) {
+            return coords.map(function (_a) {
+                var x = _a[0], y = _a[1];
+                return _transformationMethod(x, y);
+            });
+        });
+        return lines;
+    };
+    IsobarRasterToVector.prototype._calculateAll = function (data) {
+        this.contourMipmap = new quadtreecontours_1.default(data, this.width, this.height);
+        this._calculateContours();
+        this._bufferData = this._createBufferData();
+        this.program.setBufferData(this._bufferData);
+        this.globe.DrawRender();
+        this._ready = true;
+    };
+    IsobarRasterToVector.prototype._calculateContours = function () {
+        var isobars = this.isobars;
+        for (var _i = 0, isobars_1 = isobars; _i < isobars_1.length; _i++) {
+            var isobar = isobars_1[_i];
+            var threshold = isobar.threshold;
+            var lines = this._calculateIntersections(threshold);
+            isobar.lines = lines;
+        }
+    };
+    IsobarRasterToVector.prototype._isobarsCheckAndComplete = function (isobars) {
+        window.isobars = isobars;
+        if (!Array.isArray(isobars))
+            throw new Error("isobars must be an array");
+        if (isobars.length === 0)
+            throw new Error("isobars must contain at least one element");
+        for (var _i = 0, isobars_2 = isobars; _i < isobars_2.length; _i++) {
+            var isobar = isobars_2[_i];
+            if (!isobar || typeof isobar !== 'object')
+                throw new Error("isobar must be an object");
+            if (typeof isobar.threshold !== 'number')
+                throw new Error("isobar.threshold must be a number");
+            if (isobar.color) {
+                if (!Array.isArray(isobar.color) || isobar.color.length !== 3)
+                    throw new Error("isobar.color must be an array with 3 elements");
+                for (var _a = 0, _b = isobar.color; _a < _b.length; _a++) {
+                    var color = _b[_a];
+                    if (color < 0 || color > 1)
+                        throw new Error("isobar.color elements must be between 0 and 1");
+                }
+            }
+            if (!isobar.color)
+                isobar.color = [1, 1, 1];
+        }
+    };
+    IsobarRasterToVector.prototype._createBufferData = function () {
+        var isobars = this.isobars;
+        var pointCount = isobars.reduce(function (acc, _a) {
+            var lines = _a.lines;
+            return acc + lines.reduce(function (acc, line) { return acc + line.length; }, 0);
+        }, 0);
+        var bufferData = new Float32Array(pointCount * 6);
+        var index = 0;
+        var pointCounter = 0;
+        this._lineStrignRanges = [];
+        // gather label data label
+        var labelPoints = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        var coords = labelPoints.coords, coordsZ = labelPoints.coordsZ, attribs = labelPoints.attribs;
+        var fidCounter = 0;
+        for (var _i = 0, isobars_3 = isobars; _i < isobars_3.length; _i++) {
+            var _a = isobars_3[_i], lines = _a.lines, color = _a.color, threshold = _a.threshold;
+            for (var _b = 0, lines_1 = lines; _b < lines_1.length; _b++) {
+                var line = lines_1[_b];
+                var startIndex = pointCounter;
+                for (var _c = 0, line_1 = line; _c < line_1.length; _c++) {
+                    var _d = line_1[_c], x = _d[0], y = _d[1];
+                    var pixXY = (0, util_1.latLongToPixelXY)(y, x);
+                    bufferData[index++] = pixXY.x;
+                    bufferData[index++] = pixXY.y;
+                    bufferData[index++] = color[0];
+                    bufferData[index++] = color[1];
+                    bufferData[index++] = color[2];
+                    bufferData[index++] = 1.0;
+                    pointCounter++;
+                }
+                coords.push(line[0][0], line[0][1]);
+                coordsZ.push(0);
+                attribs.push({ value: threshold, fid: fidCounter++ });
+                this._lineStrignRanges.push([startIndex, pointCounter - startIndex]);
+            }
+        }
+        if (this._isLabelsOn)
+            this._labelsLayer.setData(labelPoints);
+        return bufferData;
+    };
+    IsobarRasterToVector.prototype._createLabelsLayer = function () {
+        this._labelsLayer = new objectarraylabels_1.default(this._labelsLayerId, this.globe, this._labelStyle);
+    };
+    IsobarRasterToVector.prototype.setGeometry = function () {
+        this.program.setGeometry();
+    };
+    IsobarRasterToVector.prototype.free = function () {
+        this.flush();
+        this.program.free();
+        if (this._isLabelsOn)
+            this._labelsLayer.removeFromMap();
+        this.dataManager.unregister(this.id);
+    };
+    return IsobarRasterToVector;
+}());
+exports.IsobarRasterToVector = IsobarRasterToVector;
+var getTransformationMethod = function (xFlip, yFlip, width, height, minX, minY, maxX, maxY) {
+    var _a = (0, quadtreecontours_1.scaleParameters)(minX, minY, maxX, maxY, width, height), scaleX = _a.scaleX, scaleY = _a.scaleY;
+    if (xFlip && yFlip)
+        return function (x, y) { return [maxX - x * scaleX, maxY - y * scaleY]; };
+    if (xFlip && !yFlip)
+        return function (x, y) { return [maxX - x * scaleX, minY + y * scaleY]; };
+    if (!xFlip && yFlip)
+        return function (x, y) { return [minX + x * scaleX, maxY - y * scaleY]; };
+    return function (x, y) { return [minX + x * scaleX, minY + y * scaleY]; };
+};
+function dataMixer(data1, data2, ratio) {
+    if (!data1 || !data2)
+        return null;
+    if (data1.length !== data2.length)
+        throw new Error("Data length mismatch");
+    var data = new Float32Array(data1.length);
+    for (var i = 0; i < data1.length; i++) {
+        data[i] = data1[i] * (1 - ratio) + data2[i] * ratio;
+    }
+    return data;
+}

package/heatwave/isobar/quadtreecontours.js

@@ -0,0 +1,316 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaleParameters = scaleParameters;
+// © 2019 3D Robotics. License: Apache-2.0
+/* eslint no-plusplus: "off", prefer-rest-params: "off" */
+var OUTSIDE = 0;
+var ABOVE = 1;
+var BELOW = 2;
+var WITHIN = 3;
+// Build mipmap layer N from layer N+1
+function mipmapReduce(_a) {
+    var min = _a.min, max = _a.max, width = _a.width, height = _a.height, scale = _a.scale;
+    var outWidth = Math.ceil(width / 2);
+    var outHeight = Math.ceil(height / 2);
+    function reduceWith(data, reduce) {
+        var out = new Float32Array(outWidth * outHeight);
+        var x;
+        var y;
+        for (y = 0; y < Math.floor(height / 2); y++) {
+            for (x = 0; x < Math.floor(width / 2); x++) {
+                out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 0) * width + (x * 2 + 1)], data[(y * 2 + 1) * width + (x * 2 + 0)], data[(y * 2 + 1) * width + (x * 2 + 1)]);
+            }
+            if (x < outWidth) {
+                out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 1) * width + (x * 2 + 0)]);
+            }
+        }
+        if (y < outHeight) {
+            for (x = 0; x < Math.floor(width / 2); x++) {
+                out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 0) * width + (x * 2 + 1)]);
+            }
+        }
+        if (x < outWidth && y < outHeight) {
+            out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)]);
+        }
+        return out;
+    }
+    function minFinite() {
+        var r = Infinity;
+        for (var i = 0; i < arguments.length; i++) { // significantly faster than the code Babel generates for ...args
+            var v = arguments[i];
+            if (v < r)
+                r = v;
+        }
+        return r;
+    }
+    function maxFinite() {
+        var r = -Infinity;
+        for (var i = 0; i < arguments.length; i++) {
+            var v = arguments[i];
+            if (v > r)
+                r = v;
+        }
+        return r;
+    }
+    return {
+        min: reduceWith(min, minFinite),
+        max: reduceWith(max, maxFinite),
+        width: outWidth,
+        height: outHeight,
+        scale: scale * 2,
+    };
+}
+var ContourMipmap = /** @class */ (function () {
+    function ContourMipmap(raster, width, height) {
+        // Bottom mipmap layer is just the raster: at each pixel the minimum and maximum are the same
+        this.levels = [{ min: raster, max: raster, width: width, height: height, scale: 1 }];
+        while (this.levels[0].width > 1 || this.levels[0].height > 1) {
+            this.levels.unshift(mipmapReduce(this.levels[0]));
+        }
+    }
+    // Get the minimum elevation in the mipmap
+    ContourMipmap.prototype.min = function () { return this.levels[0].min[0]; };
+    // Get the maximum elevation in the mipmap
+    ContourMipmap.prototype.max = function () { return this.levels[0].max[0]; };
+    // Get an array of contour levels for a specified contour interval
+    ContourMipmap.prototype.intervals = function (interval) {
+        if (interval <= 0)
+            throw new Error('Contour interval must be positive');
+        var min = this.min();
+        var max = this.max();
+        var levels = [];
+        var level = Math.ceil(min / interval) * interval;
+        while (level < max) {
+            levels.push(level);
+            level += interval;
+        }
+        return levels;
+    };
+    // Walk the quadtree for a specified contour level, and pass quadtree nodes
+    // and contour line segments to the callbacks. This is used for visualizing
+    // the quadtree; in most cases you should use .contour() instead, which
+    // assembles the line segments into lines and rings.
+    ContourMipmap.prototype.evaluateContour = function (contourLevel, _a, addLine, addNode) {
+        var _this = this;
+        var maxMipmapLevel = _a.maxMipmapLevel;
+        maxMipmapLevel = maxMipmapLevel || this.levels.length - 1;
+        // Test the mipmap at the given coordinate and level, returning whether the contour line is ABOVE, BELOW, or WITHIN this mipmap cell
+        // If the mipmap is out of bounds or NaN at that point, OUTSIDE is returned.
+        var evaluate = function (l, x, y) {
+            var ml = _this.levels[l];
+            var i = ml.width * y + x;
+            if (x >= ml.width || y >= ml.height || !Number.isFinite(ml.min[i]) || !Number.isFinite(ml.max[i]))
+                return OUTSIDE;
+            if (ml.min[i] >= contourLevel)
+                return ABOVE;
+            if (ml.max[i] < contourLevel)
+                return BELOW;
+            // If we've reached the maximum mipmap level, arbitrarily decide that cells that contain
+            // the contour elevation go inside the contour line.
+            if (l >= maxMipmapLevel)
+                return ABOVE;
+            return WITHIN;
+        };
+        // Add any vertical contour lines that exist between passed mipmap cell and
+        // its horizontal neighbor to the right. If the line exists at this mipmap
+        // level, it is added directly, otherwise split the edge and recurse at a
+        // more detailed mipmap level.
+        function edgeH(l, x, y) {
+            var e1 = evaluate(l, x, y);
+            var e2 = evaluate(l, x + 1, y);
+            if (e1 === ABOVE && e2 === BELOW) {
+                addLine(l, x + 1, y + 1, x + 1, y);
+            }
+            else if (e2 === ABOVE && e1 === BELOW) {
+                // reverse order of coordinates compared to case above so that lines
+                // go counterclockwise around the region above the contour value
+                addLine(l, x + 1, y, x + 1, y + 1);
+            }
+            else if (e1 === WITHIN || e2 === WITHIN) {
+                edgeH(l + 1, x * 2 + 1, y * 2 + 0);
+                edgeH(l + 1, x * 2 + 1, y * 2 + 1);
+            }
+        }
+        // Like edgeH, but for horizontal contour lines between the passed cell
+        // and its vertical neighbor below.
+        function edgeV(l, x, y) {
+            var e1 = evaluate(l, x, y);
+            var e2 = evaluate(l, x, y + 1);
+            if (e1 === ABOVE && e2 === BELOW) {
+                addLine(l, x, y + 1, x + 1, y + 1);
+            }
+            else if (e2 === ABOVE && e1 === BELOW) {
+                addLine(l, x + 1, y + 1, x, y + 1);
+            }
+            else if (e1 === WITHIN || e2 === WITHIN) {
+                edgeV(l + 1, x * 2 + 0, y * 2 + 1);
+                edgeV(l + 1, x * 2 + 1, y * 2 + 1);
+            }
+        }
+        // Add all contour lines within a mipmap cell.
+        // It recurses into the four quadrants of the cell, and also uses edgeH and
+        // edgeV to add the contour lines that exist between quadrants.
+        function node(l, x, y) {
+            var e = evaluate(l, x, y);
+            if (e === WITHIN) {
+                node(l + 1, x * 2 + 0, y * 2 + 0);
+                node(l + 1, x * 2 + 1, y * 2 + 0);
+                node(l + 1, x * 2 + 0, y * 2 + 1);
+                node(l + 1, x * 2 + 1, y * 2 + 1);
+                edgeH(l + 1, x * 2 + 0, y * 2 + 0);
+                edgeV(l + 1, x * 2 + 0, y * 2 + 0);
+                edgeH(l + 1, x * 2 + 0, y * 2 + 1);
+                edgeV(l + 1, x * 2 + 1, y * 2 + 0);
+            }
+            else {
+                if (addNode)
+                    addNode(l, x, y, e);
+            }
+        }
+        node(0, 0, 0);
+    };
+    // Generate a contour line for a specified value
+    //
+    // level: Value in the input array at which to draw a contour line
+    // opts: {
+    //   maxMipmapLevel: Maximum recursion depth in the mipmap. As if you rescaled
+    //                   the input to a maximum dimension of 2^n pixels.
+    //                   (default unlimited)
+    //   minPoints: Lines and rings with fewer points are removed. (default 0)
+    //   smoothKernelWidth: Width of the rectangular filter for smoothing (default 2)
+    //   smoothCycles: Number of iterations of smoothing (default 2)
+    // }
+    //
+    // Returns an array of lines, where each line is an array of [x, y] pairs.
+    ContourMipmap.prototype.contour = function (level, _a) {
+        var _this = this;
+        var _b = _a === void 0 ? {} : _a, maxMipmapLevel = _b.maxMipmapLevel, _c = _b.smoothKernelWidth, smoothKernelWidth = _c === void 0 ? 2 : _c, _d = _b.smoothCycles, smoothCycles = _d === void 0 ? 2 : _d, _e = _b.minPoints, minPoints = _e === void 0 ? 0 : _e;
+        // Use the quadtree algorithm to generate line segments that make up the contour
+        var segments = [];
+        this.evaluateContour(level, { maxMipmapLevel: maxMipmapLevel }, function (l, x1, y1, x2, y2) {
+            var scale = _this.levels[l].scale;
+            var start = [scale * x1, scale * y1];
+            var end = [scale * x2, scale * y2];
+            segments.push({ start: start, end: end });
+        });
+        segments.sort(function (a, b) { return key(a.start) - key(b.start); });
+        // .. and then join them together into rings
+        // An arbitrary function to use a 2D point as a Map key
+        function key(a) { return a[0] + a[1] * 65536; }
+        var fragmentStart = new Map();
+        var fragmentEnd = new Map();
+        var rings = [];
+        segments.forEach(function (_a) {
+            var start = _a.start, end = _a.end;
+            var a = fragmentEnd.get(key(start));
+            var b = fragmentStart.get(key(end));
+            if (a && b) {
+                fragmentEnd.delete(key(start));
+                fragmentStart.delete(key(end));
+                if (a === b) {
+                    // Close a ring
+                    a.push(end);
+                    rings.push(a);
+                }
+                else {
+                    // Join two lines together
+                    var c = a.concat(b);
+                    fragmentStart.set(key(c[0]), c);
+                    fragmentEnd.set(key(c[c.length - 1]), c);
+                }
+            }
+            else if (a) {
+                // Extend an existing line from the end
+                fragmentEnd.delete(key(start));
+                a.push(end);
+                fragmentEnd.set(key(end), a);
+            }
+            else if (b) {
+                // Extend an existing line from the start
+                fragmentStart.delete(key(end));
+                b.unshift(start);
+                fragmentStart.set(key(start), b);
+            }
+            else {
+                // New line doesn't connect to any existing line
+                var c = [start, end];
+                fragmentStart.set(key(start), c);
+                fragmentEnd.set(key(end), c);
+            }
+            if (fragmentStart.size !== fragmentEnd.size) {
+                console.error("Contour remaining fragment size mismatch ".concat(fragmentStart.size, " ").concat(fragmentEnd.size));
+            }
+        });
+        var smoothOpts = {
+            kernelWidth: smoothKernelWidth,
+            cycles: smoothCycles,
+        };
+        // Closed rings and any unclosed line strings
+        return __spreadArray(__spreadArray([], rings, true), fragmentStart.values(), true).filter(function (l) { return l.length >= minPoints && l.length >= smoothKernelWidth * 2; })
+            .map(function (l) { return smooth(l, smoothOpts); });
+    };
+    return ContourMipmap;
+}());
+// Smooth a line by repeatedly applying a rectangular filter to approximate
+// a gaussian filter. It detects closed loops and preserves them.
+// The line is passed as an array of `[x, y]` pairs.
+//
+// kernelWidth: Width of the rectangular filter kernel
+// cycles: Number of times to apply the kernel
+function smooth(line, _a) {
+    var _b = _a.kernelWidth, kernelWidth = _b === void 0 ? 2 : _b, _c = _a.cycles, cycles = _c === void 0 ? 2 : _c;
+    var isLoop = line[0][0] === line[line.length - 1][0] && line[0][1] === line[line.length - 1][1];
+    var pointAt;
+    if (isLoop) {
+        pointAt = function (i) { return line[(i + line.length) % line.length]; };
+    }
+    else {
+        pointAt = function (i) { return line[Math.min(Math.max(i, 0), line.length - 1)]; };
+    }
+    var sc = 1.0 / (kernelWidth * 2);
+    for (var cycle = 0; cycle < cycles; cycle++) {
+        var px = 0;
+        var py = 0;
+        if (isLoop) {
+            for (var i = line.length - kernelWidth; i < line.length; i++) {
+                px += line[i][0];
+                py += line[i][1];
+            }
+        }
+        else {
+            px = line[0][0] * kernelWidth;
+            py = line[0][1] * kernelWidth;
+        }
+        for (var i = 0; i < kernelWidth; i++) {
+            px += line[i][0];
+            py += line[i][1];
+        }
+        var res = line.slice();
+        for (var i = 0; i < line.length; i++) {
+            res[i] = [px * sc, py * sc];
+            px += pointAt(i + kernelWidth)[0] - pointAt(i - kernelWidth)[0];
+            py += pointAt(i + kernelWidth)[1] - pointAt(i - kernelWidth)[1];
+        }
+        if (isLoop) {
+            // Keep the loop closed
+            res[res.length - 1] = res[0].slice();
+        }
+        line = res;
+    }
+    return line;
+}
+function scaleParameters(minLongitude, minLatitude, maxLongitude, maxLatitude, width, height) {
+    var scaleX = (maxLongitude - minLongitude) / width;
+    var scaleY = (maxLatitude - minLatitude) / height;
+    return { scaleX: scaleX, scaleY: scaleY };
+}
+exports.default = ContourMipmap;