@pirireis/webglobeplugins 0.9.10 → 0.9.11

package/heatwave/isobar/plugin.js

@@ -37,11 +37,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsobarRasterToVector = void 0;
-const util_1 = require("../../util");
-const quadtreecontours_1 = __importStar(require("./quadtreecontours"));
-const objectarraylabels_1 = __importDefault(require("./objectarraylabels"));
-const typecheck_1 = require("../../util/check/typecheck");
-class IsobarRasterToVector {
+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
@@ -59,7 +59,9 @@ class IsobarRasterToVector {
      * @param {boolean} options.isLabelsOn
      * @param {Object} options.labelStyle
      */
-    constructor(id, dataManager, isobars, width, height, [minLon, minLat, maxLon, maxLat] = [-180, -90, 180, 90], { xFlip = false, yFlip = true, isOn = true, isLabelsOn = true, labelStyle = null, maxMipmapLevel = null } = {}) {
+    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;
@@ -82,7 +84,8 @@ class IsobarRasterToVector {
         // this._transformationMethod = null;
     }
     // API
-    setData(data, on = false) {
+    IsobarRasterToVector.prototype.setData = function (data, on) {
+        if (on === void 0) { on = false; }
         if (!data)
             return;
         this._data = data;
@@ -90,41 +93,42 @@ class IsobarRasterToVector {
             this._isOn = true;
         if (this._isOn)
             this._calculateAll(data);
-    }
-    on() {
+    };
+    IsobarRasterToVector.prototype.on = function () {
         this._isOn = true;
         if (this._data)
             this._calculateAll(this._data);
-    }
-    off() {
+    };
+    IsobarRasterToVector.prototype.off = function () {
         this._isOn = false;
         this.clean();
-    }
-    clean() {
+    };
+    IsobarRasterToVector.prototype.clean = function () {
         this.flush();
         this.globe.DrawRender();
-    }
-    setFlip(xFlip, yFlip) {
+    };
+    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;
-        const [minLon, minLat, maxLon, maxLat] = this.bbox;
-        const { width, height } = this;
+        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();
-    }
-    setBoundingBox([minLon, minLat, maxLon, maxLat]) {
+    };
+    IsobarRasterToVector.prototype.setBoundingBox = function (_a) {
+        var minLon = _a[0], minLat = _a[1], maxLon = _a[2], maxLat = _a[3];
         this.bbox = [minLon, minLat, maxLon, maxLat];
-        const { width, height, xFlip, yFlip } = this;
+        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();
-    }
-    setIsLabelsOn(isLabelsOn) {
+    };
+    IsobarRasterToVector.prototype.setIsLabelsOn = function (isLabelsOn) {
         (0, typecheck_1.isBoolean)(isLabelsOn);
         if (this._isLabelsOn === isLabelsOn)
             return;
@@ -138,56 +142,58 @@ class IsobarRasterToVector {
             this._labelsLayer.addToMap();
             this._createBufferData();
         }
-    }
-    getIsobars() {
+    };
+    IsobarRasterToVector.prototype.getIsobars = function () {
         return this.isobars;
-    }
-    setIsobars(isobars) {
+    };
+    IsobarRasterToVector.prototype.setIsobars = function (isobars) {
         this._isobarsCheckAndComplete(isobars);
         this.isobars = isobars;
         this._calculateLines();
         this.globe.DrawRender();
-    }
-    setWidthHeight(width, height) {
+    };
+    IsobarRasterToVector.prototype.setWidthHeight = function (width, height) {
         this.width = width;
         this.height = height;
-        const { xFlip, yFlip } = this;
-        const [minLon, minLat, maxLon, maxLat] = this.bbox;
+        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();
-    }
-    getLabelStyle() {
+    };
+    IsobarRasterToVector.prototype.getLabelStyle = function () {
         return this._labelsLayer.getLabelStyle();
-    }
-    setOpacity(opacity) {
+    };
+    IsobarRasterToVector.prototype.setOpacity = function (opacity) {
         (0, typecheck_1.opacityCheck)(opacity);
         this.program.setOpacity(opacity);
-    }
-    setLabelStyle(style) {
+    };
+    IsobarRasterToVector.prototype.setLabelStyle = function (style) {
         this._labelStyle = style;
         if (this._labelsLayer)
             this._labelsLayer.setLabelStyle(style);
-        const lastState = this._isLabelsOn;
+        var lastState = this._isLabelsOn;
         this.setIsLabelsOn(false);
         this.setIsLabelsOn(lastState);
         if (lastState)
             this._createBufferData();
-    }
-    setMaxMipmapLevel(maxMipmapLevel = null) {
+    };
+    IsobarRasterToVector.prototype.setMaxMipmapLevel = function (maxMipmapLevel) {
+        if (maxMipmapLevel === void 0) { maxMipmapLevel = null; }
         this._maxMipmapLevel = maxMipmapLevel;
         this._calculateLines();
         this.globe.DrawRender();
-    }
-    flush() {
+    };
+    IsobarRasterToVector.prototype.flush = function () {
         this.program.setBufferData(new Float32Array(0));
         this._lineStrignRanges = [];
         if (this._isLabelsOn)
             this._labelsLayer.flush();
-    }
+    };
     // 
     // implicit methods
-    init(globe, gl) {
+    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');
@@ -195,62 +201,67 @@ class IsobarRasterToVector {
             this._createLabelsLayer();
             this._labelsLayer.addToMap();
         }
-        this.dataManager.register(this.id, (ratio, t1, t2) => {
+        this.dataManager.register(this.id, function (ratio, t1, t2) {
             if (!t1 || !t2) {
-                this.clean();
+                _this.clean();
                 return;
             }
-            const data = dataMixer(t1, t2, ratio);
-            if (this._isOn)
-                this.setData(data);
+            var data = dataMixer(t1, t2, ratio);
+            if (_this._isOn)
+                _this.setData(data);
         });
-    }
-    resize(width, height) {
+    };
+    IsobarRasterToVector.prototype.resize = function (width, height) {
         this.program.resize(width, height);
-    }
-    draw3D(projMatrix, modelviewMatrix, transPos) {
+    };
+    IsobarRasterToVector.prototype.draw3D = function (projMatrix, modelviewMatrix, transPos) {
         if (!this._ready)
             return;
         this._drawContour(projMatrix, modelviewMatrix, transPos);
-    }
-    _calculateLines() {
+    };
+    IsobarRasterToVector.prototype._calculateLines = function () {
         this._calculateContours();
         this._bufferData = this._createBufferData();
         this.program.setBufferData(this._bufferData);
-    }
-    _drawContour(projMatrix, modelviewMatrix, transPos) {
+    };
+    IsobarRasterToVector.prototype._drawContour = function (projMatrix, modelviewMatrix, transPos) {
         this.program.draw(projMatrix, modelviewMatrix, transPos, this._lineStrignRanges);
-    }
-    _calculateIntersections(threshold) {
-        const { _transformationMethod } = this;
-        const lines = this.contourMipmap.contour([threshold], { maxMipmapLevel: this._maxMipmapLevel }).map(coords => {
-            return coords.map(([x, y]) => _transformationMethod(x, y));
+    };
+    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;
-    }
-    _calculateAll(data) {
+    };
+    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;
-    }
-    _calculateContours() {
-        const { isobars } = this;
-        for (const isobar of isobars) {
-            const { threshold } = isobar;
-            const lines = this._calculateIntersections(threshold);
+    };
+    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;
         }
-    }
-    _isobarsCheckAndComplete(isobars) {
+    };
+    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 (const isobar of isobars) {
+        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')
@@ -258,7 +269,8 @@ class IsobarRasterToVector {
             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 (const color of isobar.color) {
+                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");
                 }
@@ -266,27 +278,33 @@ class IsobarRasterToVector {
             if (!isobar.color)
                 isobar.color = [1, 1, 1];
         }
-    }
-    _createBufferData() {
-        const { isobars } = this;
-        const pointCount = isobars.reduce((acc, { lines }) => acc + lines.reduce((acc, line) => acc + line.length, 0), 0);
-        const bufferData = new Float32Array(pointCount * 6);
-        let index = 0;
-        let pointCounter = 0;
+    };
+    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
-        const labelPoints = {
+        var labelPoints = {
             coords: [],
             coordsZ: [],
             attribs: []
         };
-        const { coords, coordsZ, attribs } = labelPoints;
-        let fidCounter = 0;
-        for (const { lines, color, threshold } of isobars) {
-            for (const line of lines) {
-                let startIndex = pointCounter;
-                for (const [x, y] of line) {
-                    const pixXY = (0, util_1.latLongToPixelXY)(y, x);
+        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];
@@ -304,39 +322,40 @@ class IsobarRasterToVector {
         if (this._isLabelsOn)
             this._labelsLayer.setData(labelPoints);
         return bufferData;
-    }
-    _createLabelsLayer() {
+    };
+    IsobarRasterToVector.prototype._createLabelsLayer = function () {
         this._labelsLayer = new objectarraylabels_1.default(this._labelsLayerId, this.globe, this._labelStyle);
-    }
-    setGeometry() {
+    };
+    IsobarRasterToVector.prototype.setGeometry = function () {
         this.program.setGeometry();
-    }
-    free() {
+    };
+    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;
-const getTransformationMethod = (xFlip, yFlip, width, height, minX, minY, maxX, maxY) => {
-    const { scaleX, scaleY } = (0, quadtreecontours_1.scaleParameters)(minX, minY, maxX, maxY, width, height);
+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 (x, y) => [maxX - x * scaleX, maxY - y * scaleY];
+        return function (x, y) { return [maxX - x * scaleX, maxY - y * scaleY]; };
     if (xFlip && !yFlip)
-        return (x, y) => [maxX - x * scaleX, minY + y * scaleY];
+        return function (x, y) { return [maxX - x * scaleX, minY + y * scaleY]; };
     if (!xFlip && yFlip)
-        return (x, y) => [minX + x * scaleX, maxY - y * scaleY];
-    return (x, y) => [minX + x * scaleX, minY + y * scaleY];
+        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");
-    const data = new Float32Array(data1.length);
-    for (let i = 0; i < data1.length; i++) {
+    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;