@pirireis/webglobeplugins 0.9.10 → 0.9.11

package/heatwave/isobar/quadtreecontours.js

@@ -1,20 +1,30 @@
 "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" */
-const OUTSIDE = 0;
-const ABOVE = 1;
-const BELOW = 2;
-const WITHIN = 3;
+var OUTSIDE = 0;
+var ABOVE = 1;
+var BELOW = 2;
+var WITHIN = 3;
 // Build mipmap layer N from layer N+1
-function mipmapReduce({ min, max, width, height, scale }) {
-    const outWidth = Math.ceil(width / 2);
-    const outHeight = Math.ceil(height / 2);
+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) {
-        const out = new Float32Array(outWidth * outHeight);
-        let x;
-        let y;
+        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)]);
@@ -34,18 +44,18 @@ function mipmapReduce({ min, max, width, height, scale }) {
         return out;
     }
     function minFinite() {
-        let r = Infinity;
-        for (let i = 0; i < arguments.length; i++) { // significantly faster than the code Babel generates for ...args
-            const v = arguments[i];
+        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() {
-        let r = -Infinity;
-        for (let i = 0; i < arguments.length; i++) {
-            const v = arguments[i];
+        var r = -Infinity;
+        for (var i = 0; i < arguments.length; i++) {
+            var v = arguments[i];
             if (v > r)
                 r = v;
         }
@@ -59,43 +69,45 @@ function mipmapReduce({ min, max, width, height, scale }) {
         scale: scale * 2,
     };
 }
-class ContourMipmap {
-    constructor(raster, width, height) {
+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, height, scale: 1 }];
+        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
-    min() { return this.levels[0].min[0]; }
+    ContourMipmap.prototype.min = function () { return this.levels[0].min[0]; };
     // Get the maximum elevation in the mipmap
-    max() { return this.levels[0].max[0]; }
+    ContourMipmap.prototype.max = function () { return this.levels[0].max[0]; };
     // Get an array of contour levels for a specified contour interval
-    intervals(interval) {
+    ContourMipmap.prototype.intervals = function (interval) {
         if (interval <= 0)
             throw new Error('Contour interval must be positive');
-        const min = this.min();
-        const max = this.max();
-        const levels = [];
-        let level = Math.ceil(min / interval) * interval;
+        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.
-    evaluateContour(contourLevel, { maxMipmapLevel }, addLine, addNode) {
+    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.
-        const evaluate = (l, x, y) => {
-            const ml = this.levels[l];
-            const i = ml.width * y + x;
+        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)
@@ -113,8 +125,8 @@ class ContourMipmap {
         // level, it is added directly, otherwise split the edge and recurse at a
         // more detailed mipmap level.
         function edgeH(l, x, y) {
-            const e1 = evaluate(l, x, y);
-            const e2 = evaluate(l, x + 1, 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);
             }
@@ -131,8 +143,8 @@ class ContourMipmap {
         // Like edgeH, but for horizontal contour lines between the passed cell
         // and its vertical neighbor below.
         function edgeV(l, x, y) {
-            const e1 = evaluate(l, x, y);
-            const e2 = evaluate(l, x, y + 1);
+            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);
             }
@@ -148,7 +160,7 @@ class ContourMipmap {
         // 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) {
-            let e = evaluate(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);
@@ -165,7 +177,7 @@ class ContourMipmap {
             }
         }
         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
@@ -179,25 +191,28 @@ class ContourMipmap {
     // }
     //
     // Returns an array of lines, where each line is an array of [x, y] pairs.
-    contour(level, { maxMipmapLevel, smoothKernelWidth = 2, smoothCycles = 2, minPoints = 0 } = {}) {
+    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
-        const segments = [];
-        this.evaluateContour(level, { maxMipmapLevel }, (l, x1, y1, x2, y2) => {
-            const scale = this.levels[l].scale;
-            const start = [scale * x1, scale * y1];
-            const end = [scale * x2, scale * y2];
-            segments.push({ start, end });
+        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((a, b) => key(a.start) - key(b.start));
+        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; }
-        const fragmentStart = new Map();
-        const fragmentEnd = new Map();
-        const rings = [];
-        segments.forEach(({ start, end }) => {
-            const a = fragmentEnd.get(key(start));
-            const b = fragmentStart.get(key(end));
+        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));
@@ -208,7 +223,7 @@ class ContourMipmap {
                 }
                 else {
                     // Join two lines together
-                    const c = a.concat(b);
+                    var c = a.concat(b);
                     fragmentStart.set(key(c[0]), c);
                     fragmentEnd.set(key(c[c.length - 1]), c);
                 }
@@ -227,45 +242,46 @@ class ContourMipmap {
             }
             else {
                 // New line doesn't connect to any existing line
-                const c = [start, end];
+                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 ${fragmentStart.size} ${fragmentEnd.size}`);
+                console.error("Contour remaining fragment size mismatch ".concat(fragmentStart.size, " ").concat(fragmentEnd.size));
             }
         });
-        const smoothOpts = {
+        var smoothOpts = {
             kernelWidth: smoothKernelWidth,
             cycles: smoothCycles,
         };
         // Closed rings and any unclosed line strings
-        return [...rings, ...fragmentStart.values()]
-            .filter(l => l.length >= minPoints && l.length >= smoothKernelWidth * 2)
-            .map(l => smooth(l, smoothOpts));
-    }
-}
+        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, { kernelWidth = 2, cycles = 2 }) {
-    const isLoop = line[0][0] === line[line.length - 1][0] && line[0][1] === line[line.length - 1][1];
-    let pointAt;
+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 = i => line[(i + line.length) % line.length];
+        pointAt = function (i) { return line[(i + line.length) % line.length]; };
     }
     else {
-        pointAt = i => line[Math.min(Math.max(i, 0), line.length - 1)];
+        pointAt = function (i) { return line[Math.min(Math.max(i, 0), line.length - 1)]; };
     }
-    const sc = 1.0 / (kernelWidth * 2);
-    for (let cycle = 0; cycle < cycles; cycle++) {
-        let px = 0;
-        let py = 0;
+    var sc = 1.0 / (kernelWidth * 2);
+    for (var cycle = 0; cycle < cycles; cycle++) {
+        var px = 0;
+        var py = 0;
         if (isLoop) {
-            for (let i = line.length - kernelWidth; i < line.length; i++) {
+            for (var i = line.length - kernelWidth; i < line.length; i++) {
                 px += line[i][0];
                 py += line[i][1];
             }
@@ -274,12 +290,12 @@ function smooth(line, { kernelWidth = 2, cycles = 2 }) {
             px = line[0][0] * kernelWidth;
             py = line[0][1] * kernelWidth;
         }
-        for (let i = 0; i < kernelWidth; i++) {
+        for (var i = 0; i < kernelWidth; i++) {
             px += line[i][0];
             py += line[i][1];
         }
-        const res = line.slice();
-        for (let i = 0; i < line.length; i++) {
+        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];
@@ -293,8 +309,8 @@ function smooth(line, { kernelWidth = 2, cycles = 2 }) {
     return line;
 }
 function scaleParameters(minLongitude, minLatitude, maxLongitude, maxLatitude, width, height) {
-    const scaleX = (maxLongitude - minLongitude) / width;
-    const scaleY = (maxLatitude - minLatitude) / height;
-    return { scaleX, scaleY };
+    var scaleX = (maxLongitude - minLongitude) / width;
+    var scaleY = (maxLatitude - minLatitude) / height;
+    return { scaleX: scaleX, scaleY: scaleY };
 }
 exports.default = ContourMipmap;

package/heatwave/plugins/heatwaveglobeshell.js

@@ -1,8 +1,17 @@
 "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 });
-const util_1 = require("../../util");
-const programs_1 = require("../../programs");
-const typecheck_1 = require("../../util/check/typecheck");
+var util_1 = require("../../util");
+var programs_1 = require("../../programs");
+var typecheck_1 = require("../../util/check/typecheck");
 /**
  * @param id : string
  * @param dataManager : DataManager
@@ -10,8 +19,9 @@ const typecheck_1 = require("../../util/check/typecheck");
  * @param dataWidthHeight : {width: number, height: number}
  * @param options : {bbox: number[], minMaxEdges: {min: number, max: number}, escapeValue: number, resolution: number[], meshPartition: number[]}
  */
-class HeatWaveGlobeShellPlugin {
-    constructor(id, dataManager, colorRampData, dataWidthHeight, { bbox = [-180, -90, 180, 90], minMaxEdges = { min: -99999, max: 99999 }, escapeValue = 99999, resolution = [2056, 2056], yFlip = true, } = {}) {
+var HeatWaveGlobeShellPlugin = /** @class */ (function () {
+    function HeatWaveGlobeShellPlugin(id, dataManager, colorRampData, dataWidthHeight, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.bbox, bbox = _c === void 0 ? [-180, -90, 180, 90] : _c, _d = _b.minMaxEdges, minMaxEdges = _d === void 0 ? { min: -99999, max: 99999 } : _d, _e = _b.escapeValue, escapeValue = _e === void 0 ? 99999 : _e, _f = _b.resolution, resolution = _f === void 0 ? [2056, 2056] : _f, _g = _b.yFlip, yFlip = _g === void 0 ? true : _g;
         this.id = id;
         this.dataManager = dataManager;
         this._dataWidthHeight = dataWidthHeight;
@@ -30,60 +40,63 @@ class HeatWaveGlobeShellPlugin {
         this.enabled = false;
         this.isAble = false;
     }
-    setHeight(height) {
+    HeatWaveGlobeShellPlugin.prototype.setHeight = function (height) {
         this.globeShell.setHeight(height);
-    }
-    drawHeat() {
-        const gl = this.gl;
+    };
+    HeatWaveGlobeShellPlugin.prototype.drawHeat = function () {
+        var gl = this.gl;
         gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
         gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._coloredHeatTexture, 0);
         gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        const currentWidth = gl.canvas.width;
-        const currentHeight = gl.canvas.height;
-        gl.viewport(0, 0, ...this._resolution);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentWidth = gl.canvas.width;
+        var currentHeight = gl.canvas.height;
+        gl.viewport.apply(gl, __spreadArray([0, 0], this._resolution, false));
         this.heatProgram.draw();
         gl.viewport(0, 0, currentWidth, currentHeight);
         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
         gl.useProgram(currentProgram);
         this.globe.DrawRender();
-    }
-    setEscapeValue(escapeValue) {
+    };
+    HeatWaveGlobeShellPlugin.prototype.setEscapeValue = function (escapeValue) {
         this._escapeValue = escapeValue;
         this.heatProgram.setEscapeValue(escapeValue);
-    }
-    _createPointCoordinatesDataCalculator() {
+    };
+    HeatWaveGlobeShellPlugin.prototype._createPointCoordinatesDataCalculator = function () {
         this.coordinatesDataCalculator = new util_1.PointCoordinatesDataCalculator(this._bbox, this._dataWidthHeight.width, this._dataWidthHeight.height);
         this.dataManager.register(this._coordinatesDataCalculatorID(), this.coordinatesDataCalculator.updateData.bind(this.coordinatesDataCalculator));
-    }
-    _coordinatesDataCalculatorID() {
+    };
+    HeatWaveGlobeShellPlugin.prototype._coordinatesDataCalculatorID = function () {
         return this.id + "_coordinatesDataCalculator";
-    }
-    updateTime(time) {
+    };
+    HeatWaveGlobeShellPlugin.prototype.updateTime = function (time) {
         this.dataManager.updateTime(time);
         this.globe.DrawRender();
-    }
-    setWiggle({ wiggleInKm = null, wiggleSpeed = null } = {}) {
-        this.globeShell.setWiggle({ wiggleInKm, wiggleSpeed });
-    }
-    setMinMaxEdges(min = null, max = null) {
+    };
+    HeatWaveGlobeShellPlugin.prototype.setWiggle = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.wiggleInKm, wiggleInKm = _c === void 0 ? null : _c, _d = _b.wiggleSpeed, wiggleSpeed = _d === void 0 ? null : _d;
+        this.globeShell.setWiggle({ wiggleInKm: wiggleInKm, wiggleSpeed: wiggleSpeed });
+    };
+    HeatWaveGlobeShellPlugin.prototype.setMinMaxEdges = function (min, max) {
+        if (min === void 0) { min = null; }
+        if (max === void 0) { max = null; }
         if (min)
             this._minMaxEdges.min = min;
         if (max)
             this._minMaxEdges.max = max;
         this.heatProgram.setMinMaxEdges(this._minMaxEdges.min, this._minMaxEdges.max);
         this.drawHeat();
-    }
-    setBBox(minLon, minLat, maxLon, maxLat) {
+    };
+    HeatWaveGlobeShellPlugin.prototype.setBBox = function (minLon, minLat, maxLon, maxLat) {
         this._bbox = [minLon, minLat, maxLon, maxLat];
-        this.globeShell.setBBox({ minLon, minLat, maxLon, maxLat });
+        this.globeShell.setBBox({ minLon: minLon, minLat: minLat, maxLon: maxLon, maxLat: maxLat });
         this.drawHeat();
-    }
-    getPointCoordinatesDataCalculator() {
+    };
+    HeatWaveGlobeShellPlugin.prototype.getPointCoordinatesDataCalculator = function () {
         if (!this.coordinatesDataCalculator)
             this._createPointCoordinatesDataCalculator();
         return this.coordinatesDataCalculator;
-    }
+    };
     /**
      * @param {*} values n + 1 number of color hex values without alpha channel. Ex: ["#ff0000", "#00ff00", "#0000ff"]
      * @param {*} thresholds n number of thresholds. Ex: [0, 10, 20]
@@ -92,23 +105,26 @@ class HeatWaveGlobeShellPlugin {
      * There are maximum 256 pixels in the color ramp.
      * The first values array is minimum edge value which is the first pixel, the second comes one pixel after the first.
      */
-    setColorRamp(values, thresholds, mode = "interpolated") {
-        const lowest = thresholds[0];
-        const highest = thresholds[thresholds.length - 1];
-        const range = highest - lowest;
-        const clampedThresholds = thresholds.map((t) => (t - lowest) / range);
-        const colors = (0, util_1.getColorRampModed)(values, clampedThresholds, mode);
+    HeatWaveGlobeShellPlugin.prototype.setColorRamp = function (values, thresholds, mode) {
+        if (mode === void 0) { mode = "interpolated"; }
+        var lowest = thresholds[0];
+        var highest = thresholds[thresholds.length - 1];
+        var range = highest - lowest;
+        var clampedThresholds = thresholds.map(function (t) { return (t - lowest) / range; });
+        var colors = (0, util_1.getColorRampModed)(values, clampedThresholds, mode);
         this.heatProgram.setColorRampTextureData(colors, 256);
         this.heatProgram.setColorRampRange(lowest, highest);
         this.drawHeat();
-    }
-    off() {
+    };
+    HeatWaveGlobeShellPlugin.prototype.off = function () {
         this._isOn = false;
-    }
-    on() {
+    };
+    HeatWaveGlobeShellPlugin.prototype.on = function () {
         this._isOn = true;
-    }
-    _updateData(ratio, textureData0 = null, textureData1 = null) {
+    };
+    HeatWaveGlobeShellPlugin.prototype._updateData = function (ratio, textureData0, textureData1) {
+        if (textureData0 === void 0) { textureData0 = null; }
+        if (textureData1 === void 0) { textureData1 = null; }
         if (!textureData0 || !textureData1) {
             if (this._disCarded)
                 return;
@@ -126,33 +142,34 @@ class HeatWaveGlobeShellPlugin {
             this.heatProgram.setFloatTextureData(textureData0, textureData1, this._dataWidthHeight.width, this._dataWidthHeight.height, this._yFlip);
         }
         this.drawHeat();
-    }
-    setDataWidthHeight(width, height) {
-        this._dataWidthHeight = { width, height };
+    };
+    HeatWaveGlobeShellPlugin.prototype.setDataWidthHeight = function (width, height) {
+        this._dataWidthHeight = { width: width, height: height };
         this.heatProgram.setDataWidthHeight(width, height);
         this.setGeometry();
-    }
-    draw3D() {
+    };
+    HeatWaveGlobeShellPlugin.prototype.draw3D = function () {
         if (!this._isOn)
             return;
         // if (!this.isAble) return;
         this.gl.disable(this.gl.DEPTH_TEST);
         this.globeShell.draw();
         this.gl.enable(this.gl.DEPTH_TEST);
-    }
-    setOpacity(opacity) {
+    };
+    HeatWaveGlobeShellPlugin.prototype.setOpacity = function (opacity) {
         (0, typecheck_1.opacityCheck)(opacity);
         this.globeShell.setOpacity(opacity);
-    }
-    _setAfterInit() {
-        const [minLon, minLat, maxLon, maxLat] = this._bbox;
-        this.globeShell.setBBox({ minLon, minLat, maxLon, maxLat });
+    };
+    HeatWaveGlobeShellPlugin.prototype._setAfterInit = function () {
+        var _a = this._bbox, minLon = _a[0], minLat = _a[1], maxLon = _a[2], maxLat = _a[3];
+        this.globeShell.setBBox({ minLon: minLon, minLat: minLat, maxLon: maxLon, maxLat: maxLat });
         this.setColorRamp(this._colorRampData.values, this._colorRampData.thresholds, this._colorRampData.mode);
         delete this._colorRampData;
         this.setMinMaxEdges(this._minMaxEdges.min, this._minMaxEdges.max);
         this.setEscapeValue(this._escapeValue);
-    }
-    _init(globe, gl) {
+    };
+    HeatWaveGlobeShellPlugin.prototype._init = function (globe, gl) {
+        var _this = this;
         this.globeShell = new programs_1.GlobeShellWiggle(gl, globe, {
             minLon: this._bbox[0],
             minLat: this._bbox[1],
@@ -166,22 +183,22 @@ class HeatWaveGlobeShellPlugin {
         });
         this.heatProgram = new programs_1.Float2LegendWithRatio(gl);
         this._frameBuffer = gl.createFramebuffer();
-        this.dataManager.register(this.id, (ratio, t1, t2) => this._updateData(ratio, t1, t2));
+        this.dataManager.register(this.id, function (ratio, t1, t2) { return _this._updateData(ratio, t1, t2); });
         this.setResolution(this._resolution[0], this._resolution[1]);
-    }
-    init(globe, gl) {
+    };
+    HeatWaveGlobeShellPlugin.prototype.init = function (globe, gl) {
         this.globe = globe;
         this.gl = gl;
         this._init(globe, gl);
         this._setAfterInit();
-    }
-    setGeometry() {
+    };
+    HeatWaveGlobeShellPlugin.prototype.setGeometry = function () {
         // globeShell has an implicit program, registered and sets its own geometry.
         return;
-    }
+    };
     // sets Density of middle texture which is used with framebuffers
-    setResolution(width, height) {
-        const gl = this.gl;
+    HeatWaveGlobeShellPlugin.prototype.setResolution = function (width, height) {
+        var gl = this.gl;
         this._resolution = [width, height];
         this._coloredHeatTexture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, this._coloredHeatTexture);
@@ -192,8 +209,8 @@ class HeatWaveGlobeShellPlugin {
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
         gl.bindTexture(gl.TEXTURE_2D, null);
         this.globeShell.setTexture(this._coloredHeatTexture);
-    }
-    free() {
+    };
+    HeatWaveGlobeShellPlugin.prototype.free = function () {
         if (this.coordinatesDataCalculator) {
             this.dataManager.unregister(this._coordinatesDataCalculatorID());
             this.coordinatesDataCalculator = null;
@@ -201,6 +218,7 @@ class HeatWaveGlobeShellPlugin {
         this.dataManager.unregister(this.id);
         this.globeShell.free();
         this.heatProgram.free();
-    }
-}
+    };
+    return HeatWaveGlobeShellPlugin;
+}());
 exports.default = HeatWaveGlobeShellPlugin;

package/index.js

@@ -34,25 +34,25 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pointheatmap = exports.partialring = exports.arrowfield = exports.programs = exports.util = exports.heatwave = exports.compassrose = exports.rangerings = exports.timetracks = exports.waveparticles = exports.wind = void 0;
-const wind = __importStar(require("./wind"));
+var wind = __importStar(require("./wind"));
 exports.wind = wind;
-const waveparticles = __importStar(require("./waveparticles"));
+var waveparticles = __importStar(require("./waveparticles"));
 exports.waveparticles = waveparticles;
-const timetracks = __importStar(require("./timetracks"));
+var timetracks = __importStar(require("./timetracks"));
 exports.timetracks = timetracks;
-const arrowfield = __importStar(require("./arrowfield"));
+var arrowfield = __importStar(require("./arrowfield"));
 exports.arrowfield = arrowfield;
-const rangerings = __importStar(require("./rangerings"));
+var rangerings = __importStar(require("./rangerings"));
 exports.rangerings = rangerings;
-const partialring = __importStar(require("./partialrings"));
+var partialring = __importStar(require("./partialrings"));
 exports.partialring = partialring;
-const compassrose = __importStar(require("./compassrose"));
+var compassrose = __importStar(require("./compassrose"));
 exports.compassrose = compassrose;
-const heatwave = __importStar(require("./heatwave"));
+var heatwave = __importStar(require("./heatwave"));
 exports.heatwave = heatwave;
-const util = __importStar(require("./util"));
+var util = __importStar(require("./util"));
 exports.util = util;
-const programs = __importStar(require("./programs"));
+var programs = __importStar(require("./programs"));
 exports.programs = programs;
-const pointheatmap = __importStar(require("./point-heat-map"));
+var pointheatmap = __importStar(require("./point-heat-map"));
 exports.pointheatmap = pointheatmap;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.9.10",
+    "version": "0.9.11",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT",