@pirireis/webglobeplugins 0.6.12 → 0.6.14

package/circle-line-chain/chain-list-map.js

@@ -174,8 +174,8 @@ export class ChainListMap {
      */
     textUpdate(chainKey, textWriterObjs, dataPreAdaptor) {
         const chain = this._chainMap.get(chainKey);
-        const data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
         if (!chain) return;
+        const data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
         const properties = this._chainSideProperties.get(chainKey);
         textWriterObjs.forEach((writer) => {
             writer.insertTextBulk(data, properties);

package/circle-line-chain/plugin.js

@@ -1,5 +1,6 @@
 import { LineOnGlobeCache } from '../programs/line-on-globe/naive';
 import { CircleCache } from '../programs/line-on-globe/circle';
+import { LineToTheOriginCache } from "../programs/line-on-globe/to-the-origin"
 import { BufferOrchestrator, BufferManager } from "../util/account";
 import { ChainListMap } from "./chain-list-map";
 import { mapGetOrThrow } from "../util/check/get";
@@ -76,6 +77,7 @@ export class CircleLineChainPlugin {
         const { gl, globe } = this;
         this.lineProgram = LineOnGlobeCache.get(globe);
         this.circleProgram = CircleCache.get(globe);
+        this.lineToTheOriginProgram = LineToTheOriginCache.get(globe);
         {
             // createBuffers
             const bufferType = "DYNAMIC_DRAW";
@@ -134,14 +136,14 @@ export class CircleLineChainPlugin {
                 ...['centerCoords', 'targetCoords', 'dashRatio', 'dashOpacity', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
             this.circleVao = this.circleProgram.createVAO(
                 ...["centerCoords", "bigRadius", "rgbaCircle", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key))));
+            this.toOriginVao = this.lineToTheOriginProgram.createVAO(
+                ...["targetCoords", "rgba"].map(key => obj(this.bufferManagersCompMap.get(key))));
         }
 
     }
 
 
     // API
-
-
     setDrawCircleOn(bool) {
         if (typeof bool !== 'boolean') throw new Error("setDrawCircleOn parameter must be a boolean");
         this._drawCircleOn = bool;
@@ -377,12 +379,13 @@ export class CircleLineChainPlugin {
     }
 
     draw3D() {
-        const { gl } = this;
+        const { gl, globe } = this;
         gl.disable(gl.DEPTH_TEST);
         this.lineProgram.draw(this.lineVao, this.bufferOrchestrator.length, this._opacity);
         if (this._drawCircleOn) this.circleProgram.draw(this.circleVao, this.bufferOrchestrator.length, this._opacity);
         this._textContextWriterInjectionMap.forEach((writer) => writer.draw());
         gl.enable(gl.DEPTH_TEST);
+        this.lineToTheOriginProgram.draw(this.toOriginVao, this.bufferOrchestrator.length, this._opacity);
     }
 }
 

package/compass-rose/compass-rose-padding-flat.js

@@ -57,14 +57,27 @@ export class PixelPaddingCompassPlugin {
         this._initOrchestrations()
     }
 
+
+    /**
+     * @param {string} key
+     * @param {number} long
+     * @param {number} lat
+     * @typedef properties
+     * @property {number} pixelRadiusBig
+     * @property {number} pixelRadiusSmall
+     * @property {[4 numbers between 0-1]} rgba 
+     */
     insert(key, long, lat, properties = null) {
         this.__insertText(key, null, null, { properties, update: true });
         this.compassMap.insert(key, long, lat, properties);
         this.globe.DrawRender();
-
     }
 
 
+    /**
+     * 
+     * @param {string} key 
+     */
     delete(key) {
         this.compassMap.delete(key);
         this.globe.DrawRender();

package/heatwave/plugins/heatwaveglobeshell.js

@@ -140,8 +140,6 @@ export default class Plugin {
     }
 
 
-
-
     _updateData(ratio, textureData0 = null, textureData1 = null) {
         if (!textureData0 || !textureData1) {
             this.isAble = false;

package/package.json

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

package/{heatwavemaps/isobar/objectarraylabels.js → pin/pin-object-array.js}

@@ -1,9 +1,30 @@
+
+/**
+ * IconData;
+ *  iconMap, iconCoords for objectArray
+ * 
+ * Pin data:
+ *  long, lat, payload
+ * 
+ * methods insertPin pin and its data
+ * methods deletePin
+ * 
+ * Behaviur injection:
+ * hover
+ * move
+ * pick drop
+ * mouseclicks
+ * keyboard clicks
+ * mouse curser changes ( this can be implemented inside above methods)
+ */
+
 import {
     CSGlobe,
     CSIconTypes,
     CSObjectTypes,
     CSObjectArrayUpdateTypes,
 } from "@pirireis/webglobe";
+import AlarmTimeLineFadeInFadeOut from "../../plugins/alarms/alarmFadeInFadeOutPlugin/AlarmTimeLineFadeInFadeOutPlugin";
 
 /**
  * @typedef {Object} IconPayload
@@ -30,6 +51,118 @@ import {
  * @property {PointPayload[]} attribs
  */
 
+function addIconMap(globe, mapName = "IconMapName", ICON_MAP_URL, ICON_MAP_JSON_URL) {
+    globe.api_AddIconMap('IconMapName', ICON_MAP_URL, ICON_MAP_JSON_URL);
+}
+
+class ObjectArray {
+    constructor(symbolSet, style) {
+        this.symbolSet = symbolSet;
+        this.style = style;
+    }
+
+    setSymbolSet(symbolSet) {
+        this.symbolSet = symbolSet;
+    }
+
+
+}
+
+
+class PinPointObjectArray {
+    constructor(id,
+        globe,
+        symbolSet, // iconMapName
+        style,
+        callBacks = {
+            mouseDown: (pinItem, event) => { },
+            mouseMove: (pinItem, event) => { },
+            mouseUp: (pinItem, event) => { },
+            mouseClick: (pinItem, event) => { },
+            mouseDblClick: (pinItem, event) => { },
+
+        } = {}) {
+        this.id = id
+        this.globe = globe;
+        this.symbolSet = symbolSet;
+        this.style = style;
+        this.iconMapName = iconMapName;
+        this.callBacks = callBacks;
+
+        // this item will be used
+
+        this.currentItem = null
+    }
+
+
+    insertPins(pins) {
+
+    }
+
+    deletePins(pinsIDs) {
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        }
+    }
+
+
+    _queryByScreenFindFirst() {
+        const { clientX, clientY } = this.globe.api_GetMousePos();
+        const allObjects = this.globe.queryByScreen(clientX, clientY);
+        for (let i = 0; i < allObjects.length; i++) {
+            const { obj, owner } = allObjects[i];
+            if (owner === this.objectArray) {
+                return obj;
+            }
+        }
+    }
+
+    // mouseDown(x, y, event) {
+    //     return false
+    // }
+
+
+    // // mouse'a basılıp hareket ettirildiğinde, mouseDown'dan true dönmüşse çağrılır
+    // mouseMove(x, y, event) {
+
+    // }
+
+    // // mouse bırakıldığında çağrılır
+    // mouseUp(x, y, event) {
+
+    // }
+
+    // // harita üzerinde tıklandığında çağrılır
+    // mouseClick() {
+    //     return false
+    // }
+
+    // // harita üzerinde çift tıklandığında çağrılır
+    // mouseDblClick() {
+    //     return false
+    // }
+
+
+    free() {
+        this.globe.api_ClearMouseEvents() // TODO
+    }
+
+    _setMouseEvent() {
+        const { globe } = this;
+        globe.api_SetMouseEvents()
+    }
+
+    _getIdForGlobe() {
+        const { globe, objectArray } = this;
+        const callback = () => {
+            const allObjects = globe.api_queryByScreen()
+        }
+        return `${this.id}_pinObjectArrayMouseEvent`;
+    }
+}
+
 class ObjectArrayLabels {
     /**
      * @param {number | string} id
@@ -244,4 +377,5 @@ class ObjectArrayLabels {
     }
 }
 
-export default ObjectArrayLabels;
+export default ObjectArrayLabels;
+

package/programs/line-on-globe/naive.js

@@ -4,7 +4,7 @@ import { createProgram } from "../../util";
 import { noRegisterGlobeProgramCache, globeProgramCache } from "../programcache";
 import BufferOffsetManger from "../../util/account/bufferoffsetmanager";
 import { programCache } from "../rings/distancering/circleflatprogram";
-const Radian = Math.PI / 180.0;
+
 const GLOBE_MIDPOINT_COUNT = 100;
 const ITEM_SIZE = 9;
 

package/programs/line-on-globe/to-the-origin.js

@@ -0,0 +1,165 @@
+import { createProgram } from "../../util";
+import { longLatRadToCartesian3DWithR, cartesian3DToGLPosition, R_3D } from "../../util/shaderfunctions/geometrytransformations";
+import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems";
+import { noRegisterGlobeProgramCache } from "../programcache";
+
+/**
+ * Creates beams from long, lat, radian coordinates to origin on global view.
+ * Ojects with hight, float over terrain and does not propose information of their actual coordinates.
+ * You start drawing after zoom level 9-10
+ * Does not work on mercator.
+ */
+
+
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${CameraUniformBlockString}
+${R_3D}
+${longLatRadToCartesian3DWithR}
+${cartesian3DToGLPosition}
+
+in vec2 position2d;
+in vec4 rgba;
+uniform float origin_r;
+flat out vec4 v_rgba;
+out float interpolation_value;
+
+void main() {
+    if (!is3D) {return;} 
+    vec3 cartesian;
+    if(gl_VertexID == 0) {
+        cartesian = longLatRadToCartesian3DWithR(position2d, R_3D);
+        interpolation_value = 1.0;
+    } else {
+        cartesian = longLatRadToCartesian3DWithR(position2d, origin_r);
+        interpolation_value = 0.0;
+    }
+    gl_Position = cartesian3DToGLPosition(cartesian);
+    v_rgba = rgba;
+    gl_PointSize = 10.0; // for testing
+}
+`;
+
+const fragmentShaderSource = `#version 300 es
+precision highp float;
+
+uniform float plugin_opacity;
+in float interpolation_value;
+flat in vec4 v_rgba;
+out vec4 color;
+void main(){
+    if ( fract( interpolation_value * 100.0) < 0.5) {discard;}
+    color = vec4( 
+        v_rgba.rgb,
+        v_rgba.a * plugin_opacity * interpolation_value * 0.9
+    );
+}`;
+
+
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        this._lastOpacity = 1.0;
+        this._lastOriginR = 6378.137 - 1;
+        const { gl, program } = this;
+        {
+            gl.bindAttribLocation(program, 0, "position2d");
+            gl.bindAttribLocation(program, 1, "rgba");
+
+        }
+        {
+            this._opacityLocation = gl.getUniformLocation(program, "plugin_opacity");
+            this._originRLocation = gl.getUniformLocation(program, "origin_r")
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this._opacityLocation, this._lastOpacity);
+            gl.uniform1f(this._originRLocation, this._lastOriginR);
+            gl.useProgram(currentProgram);
+        }
+        {
+            this.cameraBlockBindingPoint = 0;
+            const cameraBlockIndex = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
+            this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+            gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
+        }
+    }
+
+    draw(vao, length, opacity, originR = null) {
+        const { gl, program, globe, cameraBlockTotem, cameraBlockBindingPoint } = this;
+        const is3D = globe.api_GetCurrentGeometry() == 0;
+        if (!is3D) return;
+        const lod = globe.api_GetCurrentLODWithDecimal()
+        if (lod < 12) return;
+        gl.useProgram(program);
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        gl.bindVertexArray(vao);
+        if (opacity !== this._lastOpacity) {
+            gl.uniform1f(this._opacityLocation, opacity);
+            this._checkOpacity(opacity);
+            this._lastOpacity = opacity;
+        }
+        if (originR !== null && originR !== this._lastOriginR) {
+            this._checkOriginR(originR);
+            gl.uniform1f(this._originRLocation, originR);
+            this._lastOriginR = originR;
+        }
+
+        // gl.disable(gl.DEPTH_TEST);
+        gl.drawArraysInstanced(gl.LINE_STRIP, 0, 2, length);
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+        // gl.enable(gl.DEPTH_TEST);
+    }
+
+    _checkOpacity(opacity) {
+        if (opacity < 0.0 || opacity > 1) throw RangeError("Opacity should be between 0 and 1");
+
+    }
+
+    _checkOriginR(r) {
+        if (r < 0.0 || r > 6378.137 - 0.3) throw RangeError("r should be between 0 and 6378.137 - 0.3");
+    }
+
+    createVAO(potisionBufferObj, colorBufferObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {
+            const { buffer, stride = 0, offset = 0 } = potisionBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(0, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = colorBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 4, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+
+    }
+
+
+    free() {
+        if (this.isFreed) return;
+        CameraUniformBlockTotemCache.release(this.globe);
+        this.isFreed = true;
+    }
+}
+
+const LineToTheOriginCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+})
+
+export {
+    LineToTheOriginCache
+}

package/util/shaderfunctions/geometrytransformations.js

@@ -93,6 +93,14 @@ vec3 longLatRadToCartesian3D( vec2 longLat) {
 }
 `;
 
+export const longLatRadToCartesian3DWithR = `
+vec3 longLatRadToCartesian3DWithR( vec2 longLat, float radius) {
+    float x = radius * cos(longLat.y) * cos(longLat.x);
+    float y = radius * cos(longLat.y) * sin(longLat.x);
+    float z = radius * sin(longLat.y);
+    return vec3(x, y, z);
+}
+`;
 
 // TODO: Make it precise. It doesnt use haversine formula. If this changes, change the formmula which calculates text position. 
 export const circleLimpFromLongLatRadCenterCartesian3D = R + `

package/heatwavemaps/index.js

@@ -1,4 +0,0 @@
-import HeatWavePlugin from './plugins/heatwaveglobeshell';
-import { IsobarRasterToVector } from './isobar/plugin';
-export { HeatWavePlugin, IsobarRasterToVector };
-

package/heatwavemaps/isobar/plugin.js

@@ -1,337 +0,0 @@
-import { ShapesOnGlobeProgram, latLongToPixelXY } from "../../util";
-
-import ContourMipmap, { scaleParameters } from "./quadtreecontours";
-
-import ObjectArrayLabels from "./objectarraylabels";
-
-
-
-export class IsobarRasterToVector {
-
-
-    /**
-     * @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
-     */
-    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 } = {}) {
-        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
-
-    setData(data, on = false) {
-        if (!data) return;
-        this._data = data;
-        if (on) this._isOn = true;
-        if (this._isOn) this._calculateAll(data);
-    }
-
-    on() {
-        this._isOn = true;
-        if (this._data) this._calculateAll(this._data);
-    }
-
-    off() {
-        this._isOn = false;
-        this.clean();
-    }
-
-
-    clean() {
-        this.flush();
-        this.globe.DrawRender();
-    }
-
-    setFlip(xFlip, 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
-        this._transformationMethod = getTransformationMethod(xFlip, yFlip, width, height, minLon, minLat, maxLon, maxLat);
-        this._calculateLines();
-        this.globe.DrawRender();
-    }
-
-    setBoundingBox([minLon, minLat, maxLon, maxLat]) {
-        this.bbox = [minLon, minLat, maxLon, maxLat];
-        const { width, height, xFlip, yFlip } = this;
-        this._transformationMethod = getTransformationMethod(xFlip, yFlip, width, height, minLon, minLat, maxLon, maxLat);
-        this._calculateLines();
-        this.globe.DrawRender();
-    }
-
-
-    setIsLabelsOn(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();
-        }
-    }
-
-    getIsobars() {
-        return this.isobars;
-    }
-
-    setIsobars(isobars) {
-        this._isobarsCheckAndComplete(isobars);
-        this.isobars = isobars;
-        this._calculateLines();
-        this.globe.DrawRender();
-    }
-
-    setWidthHeight(width, height) {
-        this.width = width;
-        this.height = height;
-        const { xFlip, yFlip } = this;
-        const [minLon, minLat, maxLon, maxLat] = this.bbox;
-        this._transformationMethod = getTransformationMethod(xFlip, yFlip, width, height, minLon, minLat, maxLon, maxLat);
-        this._calculateLines();
-        this.globe.DrawRender();
-    }
-
-
-    getLabelStyle() {
-        return this._labelsLayer.getLabelStyle();
-    }
-
-    setOpacity(opacity) {
-        if (opacity < 0 || opacity > 1) throw new Error("Opacity must be between 0 and 1");
-        this.program.setOpacity(opacity);
-    }
-
-
-    setLabelStyle(style) {
-        this._labelStyle = style;
-        if (this._labelsLayer) this._labelsLayer.setLabelStyle(style);
-        const lastState = this._isLabelsOn;
-        this.setIsLabelsOn(false);
-        this.setIsLabelsOn(lastState);
-        if (lastState) this._createBufferData();
-    }
-
-    setMaxMipmapLevel(maxMipmapLevel = null) {
-        this._maxMipmapLevel = maxMipmapLevel;
-        this._calculateLines();
-        this.globe.DrawRender();
-    }
-
-
-    flush() {
-        this.program.setBufferData(new Float32Array(0));
-        this._lineStrignRanges = [];
-        if (this._isLabelsOn) this._labelsLayer.flush();
-    }
-
-    // 
-    // implicit methods
-
-    init(globe, gl) {
-        this.gl = gl
-        this.globe = globe
-
-        this.program = new ShapesOnGlobeProgram(gl, globe, 'line_strip');
-        if (this._isLabelsOn) {
-            this._createLabelsLayer();
-            this._labelsLayer.addToMap();
-        }
-
-        this.dataManager.register(this.id, (ratio, t1, t2) => {
-            if (!t1 || !t2) {
-                this.clean();
-                return;
-            }
-            const data = dataMixer(t1, t2, ratio);
-            if (this._isOn) this.setData(data);
-        });
-    }
-
-
-    resize(width, height) {
-        this.program.resize(width, height);
-    }
-
-    draw3D(projMatrix, modelviewMatrix, transPos) {
-        if (!this._ready) return;
-        this._drawContour(projMatrix, modelviewMatrix, transPos);
-    }
-
-    _calculateLines() {
-        this._calculateContours();
-        this._bufferData = this._createBufferData();
-        this.program.setBufferData(this._bufferData);
-    }
-
-    _drawContour(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))
-        }
-        );
-        return lines;
-    }
-
-
-    _calculateAll(data) {
-        this.contourMipmap = new ContourMipmap(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);
-            isobar.lines = lines;
-        }
-    }
-
-
-    _isobarsCheckAndComplete(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) {
-            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 (const color of isobar.color) {
-                    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];
-        }
-    }
-
-    _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;
-        this._lineStrignRanges = [];
-
-        // gather label data label
-        const 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 = 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;
-    }
-
-
-
-    _createLabelsLayer() {
-        this._labelsLayer = new ObjectArrayLabels(this._labelsLayerId, this.globe, this._labelStyle);
-    }
-
-    setGeometry() {
-        this.program.setGeometry();
-    }
-
-
-    free() {
-        this.flush();
-        this.program.free();
-        if (this._isLabelsOn) this._labelsLayer.removeFromMap();
-        this.dataManager.unregister(this.id);
-    }
-
-
-
-}
-
-const getTransformationMethod = (xFlip, yFlip, width, height, minX, minY, maxX, maxY) => {
-    const { scaleX, scaleY } = scaleParameters(minX, minY, maxX, maxY, width, height);
-    if (xFlip && yFlip) return (x, y) => [maxX - x * scaleX, maxY - y * scaleY];
-    if (xFlip && !yFlip) return (x, y) => [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];
-}
-
-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++) {
-        data[i] = data1[i] * (1 - ratio) + data2[i] * ratio;
-    }
-    return data;
-}

package/heatwavemaps/isobar/quadtreecontours.js

@@ -1,338 +0,0 @@
-// © 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;
-
-// 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 reduceWith(data, reduce) {
-        const out = new Float32Array(outWidth * outHeight);
-        let x;
-        let 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() {
-        let r = Infinity;
-        for (let i = 0; i < arguments.length; i++) { // significantly faster than the code Babel generates for ...args
-            const 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];
-            if (v > r) r = v;
-        }
-        return r;
-    }
-
-    return {
-        min: reduceWith(min, minFinite),
-        max: reduceWith(max, maxFinite),
-        width: outWidth,
-        height: outHeight,
-        scale: scale * 2,
-    };
-}
-
-class ContourMipmap {
-    constructor(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 }];
-
-        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] }
-
-    // Get the maximum elevation in the mipmap
-    max() { return this.levels[0].max[0] }
-
-    // Get an array of contour levels for a specified contour interval
-    intervals(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;
-        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) {
-        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;
-            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) {
-            const e1 = evaluate(l, x, y);
-            const 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) {
-            const e1 = evaluate(l, x, y);
-            const 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) {
-            let 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.
-    contour(level, { maxMipmapLevel, smoothKernelWidth = 2, smoothCycles = 2, minPoints = 0 } = {}) {
-        // 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 });
-        });
-
-        segments.sort((a, b) => 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));
-
-            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
-                    const 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
-                const c = [start, end];
-                fragmentStart.set(key(start), c);
-                fragmentEnd.set(key(end), c);
-            }
-
-            if (fragmentStart.size !== fragmentEnd.size) {
-                // TODO: is there a better assert function to use?
-                // eslint-disable-next-line
-                console.error(`Contour remaining fragment size mismatch ${fragmentStart.size} ${fragmentEnd.size}`);
-            }
-        });
-
-        const 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))
-    }
-}
-
-// 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;
-    if (isLoop) {
-        pointAt = i => line[(i + line.length) % line.length];
-    } else {
-        pointAt = i => 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;
-
-        if (isLoop) {
-            for (let 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 (let 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++) {
-            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) {
-    const scaleX = (maxLongitude - minLongitude) / width;
-    const scaleY = (maxLatitude - minLatitude) / height;
-    return { scaleX, scaleY };
-}
-
-
-export default ContourMipmap;
-export { scaleParameters };

package/heatwavemaps/plugins/heatwaveglobeshell.js

@@ -1,257 +0,0 @@
-import { getColorRampModed, DataManager, PointCoordinatesDataCalculator } from "../../util";
-
-import { GlobeShellWiggle, Float2LegendWithRatio } from "../../programs";
-
-
-/**
- * @param id : string
- * @param dataManager : DataManager
- * @param colorRampData : {values: string[], thresholds: number[], mode: string}
- * @param dataWidthHeight : {width: number, height: number}
- * @param options : {bbox: number[], minMaxEdges: {min: number, max: number}, escapeValue: number, resolution: number[], meshPartition: number[]}
- */
-export default class Plugin {
-    constructor(id, dataManager, colorRampData, dataWidthHeight,
-        {
-            bbox = [-180, -90, 180, 90],
-            minMaxEdges = { min: -99999, max: 99999 },
-            escapeValue = 99999,
-            resolution = [2056, 2056],
-        } = {}) {
-        this.id = id;
-        this.dataManager = dataManager;
-        this._dataWidthHeight = dataWidthHeight;
-
-        this._isOn = true;
-        this._bbox = bbox
-        this._minMaxEdges = minMaxEdges;
-        this._escapeValue = escapeValue
-        this._resolution = resolution;
-
-        this._colorRampData = colorRampData; // holds until init
-
-        this._lastTexture0data = null;
-        this._lastTexture1data = null;
-
-        // output of heatProgram is written to ._coloredHeatTexture
-        this._frameBuffer = null
-        this._coloredHeatTexture = null;
-
-        this.isAble = false;
-    }
-
-
-    setHeight(height) {
-        this.globeShell.setHeight(height);
-    }
-
-
-    drawHeat() {
-        const gl = this.gl;
-        gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
-        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._coloredHeatTexture, 0);
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        const currentWidth = gl.canvas.width;
-        const currentHeight = gl.canvas.height;
-        gl.viewport(0, 0, ...this._resolution);
-        this.heatProgram.draw()
-        gl.viewport(0, 0, currentWidth, currentHeight);
-        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        gl.useProgram(currentProgram);
-        this.globe.DrawRender();
-    }
-
-
-    setEscapeValue(escapeValue) {
-        this._escapeValue = escapeValue;
-        this.heatProgram.setEscapeValue(escapeValue);
-    }
-
-
-    _createPointCoordinatesDataCalculator() {
-        this.coordinatesDataCalculator = new PointCoordinatesDataCalculator(this._bbox, this._dataWidthHeight.width, this._dataWidthHeight.height);
-        this.dataManager.register(this._coordinatesDataCalculatorID(), this.coordinatesDataCalculator.updateData.bind(this.coordinatesDataCalculator));
-    }
-
-
-    _coordinatesDataCalculatorID() {
-        return this.id + "_coordinatesDataCalculator";
-    }
-
-
-    updateTime(time) {
-        this.dataManager.updateTime(time);
-        this.globe.DrawRender();
-    }
-
-    setWiggle({ wiggleInKm = null, wiggleSpeed = null } = {}) {
-        this.globeShell.setWiggle({ wiggleInKm, wiggleSpeed });
-    }
-
-
-    setMinMaxEdges(min = null, 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) {
-        this._bbox = [minLon, minLat, maxLon, maxLat];
-        this.globeShell.setBBox({ minLon, minLat, maxLon, maxLat });
-        this.drawHeat();
-    }
-
-
-    getPointCoordinatesDataCalculator() {
-        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]
-     * @param {*} mode "discrete" or "interpolated"
-     * 
-     * 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 = getColorRampModed(values, clampedThresholds, mode);
-        this.heatProgram.setColorRampTextureData(colors, 256);
-        this.heatProgram.setColorRampRange(lowest, highest);
-        this.drawHeat();
-    }
-
-
-    off() {
-        this._isOn = false;
-    }
-
-
-    on() {
-        this._isOn = true;
-    }
-
-
-
-
-    _updateData(ratio, textureData0 = null, textureData1 = null) {
-        if (!textureData0 || !textureData1) {
-            this.isAble = false;
-            return;
-        };
-        this.heatProgram.setBlendRatio(ratio);
-        if (this._lastTexture0data !== textureData0 || this._lastTexture1data !== textureData1) {
-            this.isAble = true;
-            this._lastTexture0data = textureData0;
-            this._lastTexture1data = textureData1;
-            this.heatProgram.setFloatTextureData(textureData0, textureData1, this._dataWidthHeight.width, this._dataWidthHeight.height);
-        }
-        this.drawHeat();
-    }
-
-
-    setDataWidthHeight(width, height) {
-        this._dataWidthHeight = { width, height };
-        this.heatProgram.setDataWidthHeight(width, height);
-        this.setGeometry();
-    }
-
-
-    draw3D() {
-        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) {
-        this.globeShell.setOpacity(opacity);
-    }
-
-
-    _setAfterInit() {
-        {
-            const [minLon, minLat, maxLon, maxLat] = this._bbox;
-            this.globeShell.setBBox({ minLon, minLat, maxLon, 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) {
-        this.globeShell = new GlobeShellWiggle(gl, globe, {
-            minLon: this._bbox[0],
-            minLat: this._bbox[1],
-            maxLon: this._bbox[2],
-            maxLat: this._bbox[3],
-            color: [1.0, 0.1, 0.4, 0.2],
-            height: 0,
-            wiggleInKM: 2,
-            eastWestTied: false,
-            displayMesh: false
-        });
-        this.heatProgram = new Float2LegendWithRatio(gl);
-        this._frameBuffer = gl.createFramebuffer();
-
-        this.dataManager.register(this.id, (ratio, t1, t2) => this._updateData(ratio, t1, t2));
-        this.setResolution(this._resolution[0], this._resolution[1]);
-    }
-
-
-
-    init(globe, gl) {
-        this.globe = globe;
-        this.gl = gl;
-        this._init(globe, gl);
-        this._setAfterInit();
-    }
-
-    setGeometry() {
-        // 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;
-        this._resolution = [width, height];
-        this._coloredHeatTexture = gl.createTexture();
-        gl.bindTexture(gl.TEXTURE_2D, this._coloredHeatTexture);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-        gl.bindTexture(gl.TEXTURE_2D, null);
-        this.globeShell.setTexture(this._coloredHeatTexture);
-    }
-
-
-    free() {
-        if (this.coordinatesDataCalculator) {
-            this.dataManager.unregister(this._coordinatesDataCalculatorID());
-            this.coordinatesDataCalculator = null;
-        }
-        this.dataManager.unregister(this.id);
-        this.globeShell.free();
-        this.heatProgram.free();
-    }
-
-
-}