@pirireis/webglobeplugins 0.15.34 → 0.16.0

package/dist/wind/vectorfieldimage.js

@@ -0,0 +1,23 @@
+function getVectorField(u, v, width, height, vMin, vMax, uMin, uMax, flip) {
+    const data = new Uint8ClampedArray(width * height * 4);
+    for (let row = 0; row < height; row++) {
+        for (let col = 0; col < width; col++) {
+            let k = flip ? ((height - row - 1) * width + col) : row * width + col;
+            let idx = (width * row + col) << 2; // Multiply by 4 for RGBA
+            if (u[k] === null || v[k] === null || isNaN(u[k]) || !isFinite(u[k]) || isNaN(v[k]) || !isFinite(v[k])) {
+                data[idx] = 0; // R
+                data[idx + 1] = 0; // G
+                data[idx + 2] = 0; // B
+                data[idx + 3] = 0; // A
+            }
+            else {
+                data[idx] = Math.floor(255 * (u[k] - uMin) / (uMax - uMin)); // R
+                data[idx + 1] = Math.floor(255 * (v[k] - vMin) / (vMax - vMin)); // G
+                data[idx + 2] = 0; // B
+                data[idx + 3] = 255; // A
+            }
+        }
+    }
+    return data;
+}
+export default getVectorField;

package/dist/write-text/attached-text-writer.js

@@ -0,0 +1,87 @@
+import { CSZMode } from "@pirireis/webglobe";
+import { isTextFont, opacityCheck } from "../util/check/typecheck";
+/**
+ * Light wight version of context text writer.
+ * The parameters by text are calculated on user side and inserted as items. (ContextTextWriter3 constructs text data from items)
+ *
+ * Good side of ContextTextWriters pattern is that there is only one way to create text.
+ * The glue is inside the plugin.
+ * This makes the code more readable and maintainable.
+ *
+ * With AttachedTextWriter the glue is created by user.
+ * I observed that the users generally uses a wrapper around the plugin logic anyway. This wrapper can be used as the glue for plugin and attacked writer.
+ */
+export class AttachedTextWriter {
+    constructor(globe, { style = {
+        textFont: {
+            name: 'Arial',
+            textColor: '#FFFFFF', // beyaz
+            hollowColor: '#000000', // siyah
+            size: 12, // piksel
+            hollow: true,
+            bold: true,
+            italic: false,
+        },
+        opacity: 1.0,
+        zMode: CSZMode.Z_GROUND_PERVERTEX,
+    }, doDraw = true, angleOnSphere = false, zoomLevelAdaptor = (zoomLevel) => (item) => {
+        return {
+            opacityMultiplier: 1,
+            sizeMultiplier: 1
+        };
+    }, } = {}) {
+        this.globe = globe;
+        this._itemMap = new Map();
+        this.doDraw = doDraw;
+        this.angleOnSphere = angleOnSphere;
+        this.zoomLevelAdaptor = zoomLevelAdaptor;
+        this.setStyle(style);
+    }
+    setOpacity(opacity) {
+        opacityCheck(opacity);
+        this._style.opacity = opacity;
+        this.globe.DrawRender();
+    }
+    setStyle(style) {
+        isTextFont(style.textFont);
+        this._style = style;
+        this.globe.DrawRender();
+    }
+    /**
+     *
+     * @param {{text, long, lat, z = 0, xOffset = 0, yOffset = 0, isAngleOn = false, Angle = 0 }} item
+     * @returns
+     */
+    insertItem(item) {
+        const key = this.keyAdaptor ? this.keyAdaptor(item) : item;
+        this._itemMap.set(key, item);
+        this.globe.DrawRender();
+    }
+    // TODO: use item style 
+    draw() {
+        if (!this.doDraw) {
+            return;
+        }
+        const { globe, _itemMap, _style } = this;
+        const { zMode, textFont, opacity } = _style;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        const angleIsOn = is3D ? true : this.angleOnSphere;
+        const zoomLevel = globe.api_GetCurrentLODWithDecimal();
+        const zoomAdaptor = this.zoomLevelAdaptor(zoomLevel);
+        const theSize = textFont.size;
+        _itemMap.forEach((item, key) => {
+            const { text, long, lat, z = 0, xOffset = 0, yOffset = 0, isAngleOn = false, angle = 0 } = item;
+            const { x, y } = globe.api_GetScreenPointFromGeo({
+                long,
+                lat,
+                z
+            }, zMode);
+            const { opacityMultiplier, sizeMultiplier } = zoomAdaptor(item);
+            textFont.size = sizeMultiplier * theSize;
+            if (x !== null && y !== null) {
+                globe.api_DrawContextText(text, textFont, opacityMultiplier * opacity, { x: x + xOffset, y: y - yOffset }, (isAngleOn && angleIsOn), angle);
+            }
+        });
+        textFont.size = theSize;
+    }
+}

package/dist/write-text/context-text-bulk.js

@@ -0,0 +1,185 @@
+// @ts-ignore
+import { CSZMode } from "@pirireis/webglobe";
+import { isTextFont, opacityCheck } from "../util/check/typecheck";
+// @ts-ignore
+import RBush from 'rbush';
+/**
+ * TODOs:
+ * 1) update all if initials change (propably need a context and a callback to iterate over zPayload)
+ * 2) expose a mechanic to update text on zoom change
+ * 3) extend the mechanic on 2 to other events
+ *
+ * TODO: key check and raise error if doesnt exist
+ */
+const defaultStyle = {
+    textFont: {
+        name: 'Arial',
+        textColor: '#FFFFFF', // beyaz
+        hollowColor: '#000000', // siyah
+        size: 12, // piksel
+        hollow: true,
+        bold: false,
+        italic: false,
+    },
+    opacity: 1.0,
+    zMode: CSZMode.Z_GROUND_PERVERTEX,
+};
+// xOffset = 0,
+// yOffset = 0,
+// doDraw = true,
+// textAdapter = null,
+// coordinatesAdapter = null,
+// keyAdapter = null,
+// opacityAdapter = null,
+// angleAdapter = null,
+// angleOnSphere = false,
+// positionAdapter = (item: any, i: number, container: any[], properties?: any): string => "left",
+class MyRBush extends RBush {
+    toBBox({ long, lat, key }) { return { minX: long, minY: lat, maxX: long, maxY: lat }; }
+    compareMinX(a, b) { return a.long - b.long; }
+    compareMinY(a, b) { return a.lat - b.lat; }
+}
+export class ContextTexBulk {
+    globe;
+    dataMap;
+    style;
+    doDraw;
+    keyAdaptor;
+    textAdapter;
+    zoomLevelAdapter;
+    escapeAdaptor;
+    xOffset;
+    yOffset;
+    angleOptions;
+    constructor(globe, keyAdaptor, textAdapter, zoomLevelAdapter = (zoomLevel) => (item) => {
+        return {
+            opacityMultiplier: 1,
+            sizeMultiplier: 1
+        };
+    }, escapeAdapter = (input, zoomLevel) => false, style = defaultStyle, angleOptions = {
+        angleOnSphere: false,
+        angleIsOn: false
+    }, doDraw = true, offset = { x: 0, y: 0 }) {
+        this.globe = globe;
+        this.dataMap = new Map();
+        isTextFont(style.textFont);
+        opacityCheck(style.opacity);
+        this.style = { ...style, textFont: { ...style.textFont } };
+        this.angleOptions = angleOptions;
+        this.doDraw = doDraw;
+        this.angleOptions = angleOptions;
+        this.keyAdaptor = keyAdaptor;
+        this.textAdapter = textAdapter;
+        this.zoomLevelAdapter = zoomLevelAdapter;
+        this.escapeAdaptor = escapeAdapter;
+        this.xOffset = offset.x;
+        this.yOffset = offset.y;
+    }
+    setDoDraw(bool) {
+        this.doDraw = bool;
+        this.globe.DrawRender();
+    }
+    setStyle(style) {
+        isTextFont(style.textFont);
+        opacityCheck(style.opacity);
+        this.style = { ...style, textFont: { ...style.textFont } };
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        this.style.opacity = opacity;
+        this.globe.DrawRender();
+    }
+    draw() {
+        if (!this.doDraw)
+            return;
+        const { globe, style, dataMap, xOffset, yOffset } = this;
+        const { textFont, opacity: opacity_ } = style;
+        const textSize = textFont.size;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        const angleIsOn = is3D ? (this.angleOptions.angleIsOn && this.angleOptions.angleOnSphere) : (this.angleOptions.angleIsOn);
+        const bbox = globe.api_GetCurrentWorldLimit();
+        // @ts-ignore
+        const data = dataMap.values();
+        const zoomLevel = globe.api_GetCurrentLODWithDecimal();
+        const zoomAdapter = this.zoomLevelAdapter(zoomLevel);
+        for (const { input, tree } of data) {
+            if (this.escapeAdaptor({ input, tree }.input, zoomLevel))
+                return;
+            // @ts-ignore
+            const itemsInBBox = tree.search({ minX: bbox.ll.x, minY: bbox.ll.y, maxX: bbox.ur.x, maxY: bbox.ur.y });
+            for (const item of itemsInBBox) {
+                const { lat, long, text, opacity = null, angle = null, zPayload, position } = item;
+                const { x, y } = globe.api_GetScreenPointFromGeo({
+                    long: long,
+                    lat: lat,
+                    z: 0,
+                }, style.zMode === CSZMode.Z_MSL);
+                const { opacityMultiplier, sizeMultiplier } = zoomAdapter(zPayload);
+                const o = (opacity === null ? opacity_ : opacity * opacity_) * opacityMultiplier;
+                textFont.size = sizeMultiplier * textSize;
+                textFont.position = position;
+                if (x !== null && y !== null)
+                    globe.api_DrawContextTextMultiLine(text, textFont, o, { x: x + xOffset, y: y - yOffset }, angleIsOn, angle);
+            }
+            textFont.size = textSize;
+        }
+    }
+    insertText(data) {
+        const key = this.keyAdaptor(data);
+        const textDatas = this.textAdapter(data);
+        const tree = new MyRBush();
+        // @ts-ignore
+        tree.load(textDatas);
+        this.dataMap.set(key, { input: data, tree });
+        this.globe.DrawRender();
+    }
+    insertTextBulk(inputs) {
+        for (const input of inputs) {
+            const key = this.keyAdaptor(input);
+            const textDatas = this.textAdapter(input);
+            const tree = new MyRBush();
+            // @ts-ignore
+            tree.load(textDatas);
+            this.dataMap.set(key, { input, tree });
+        }
+        this.globe.DrawRender();
+    }
+    deleteText(data) {
+        const keys = this.keyAdaptor(data);
+        if (this.dataMap.has(keys)) {
+            this.dataMap.delete(keys);
+        }
+        this.globe.DrawRender();
+    }
+    deleteTextBulk(inputs) {
+        for (const input of inputs) {
+            const key = this.keyAdaptor(input);
+            this.dataMap.delete(key);
+        }
+        this.globe.DrawRender();
+    }
+    deleteTextByKey(key) {
+        if (this.dataMap.has(key)) {
+            this.dataMap.delete(key);
+        }
+        this.globe.DrawRender();
+    }
+    deleteTextBulkByKey(keys) {
+        for (const key of keys) {
+            this.dataMap.delete(key);
+        }
+        this.globe.DrawRender();
+    }
+    setOffsets(x, y) {
+        this.xOffset = x;
+        this.yOffset = y;
+    }
+    clear() {
+        // @ts-ignore
+        this.dataMap.clear();
+        this.globe.DrawRender();
+    }
+    free() {
+        this.dataMap.clear();
+    }
+}

package/dist/write-text/context-text.js

@@ -0,0 +1,94 @@
+import { CSZMode } from "@pirireis/webglobe";
+const defaultStyle = {
+    textFont: {
+        name: 'Arial',
+        textColor: '#FFFFFF', // beyaz
+        hollowColor: '#000000', // siyah
+        size: 12, // piksel
+        hollow: true,
+        bold: true,
+        italic: false,
+    },
+    opacity: 1.0,
+    zMode: CSZMode.Z_GROUND_PERVERTEX,
+};
+export class ContextTextWriter {
+    constructor(globe, { style = null, doDraw = true } = {}) {
+        this.globe = globe;
+        this.itemMap = new Map();
+        this.style = style || defaultStyle;
+        this.doDraw = doDraw;
+    }
+    setDoDraw(bool) {
+        this.doDraw = bool;
+    }
+    setStyle(style) {
+        this.style = style;
+    }
+    setOpacity(opacity) {
+        this.style.opacity = opacity;
+    }
+    // Clean this ask Front dev
+    doDraw(boolean) {
+        this.doDraw = boolean;
+    }
+    draw() {
+        if (!this.doDraw)
+            return;
+        const { globe, style, itemMap } = this;
+        const { textFont, opacity: opacity_ } = style;
+        for (const [key, { lat, long, text, opacity = null }] of itemMap) {
+            const { x, y } = globe.api_GetScreenPointFromGeo({
+                long: long,
+                lat: lat,
+                z: 0,
+            }, style.zMode === CSZMode.Z_MSL);
+            const o = opacity === null ? opacity_ : opacity * opacity_;
+            if (x !== null && y !== null)
+                globe.api_DrawContextTextMultiLine(text, textFont, o, { x, y });
+        }
+    }
+    insertText(key, lat, long, text) {
+        this.itemMap.set(key, { lat, long, text });
+    }
+    updateOpacityOfItem(key, opacity) {
+        this.itemMap.get(key).opacity = opacity;
+    }
+    updateOpacityBulk(items, keyAdaptor, valueAdaptor) {
+        for (const item of items) {
+            const key = keyAdaptor(item);
+            const opacity = valueAdaptor(item);
+            const data = this.itemMap.get(key);
+            data.opacity = opacity;
+        }
+    }
+    updateText(key, text) {
+        const item = this.itemMap.get(key);
+        item.text = text;
+    }
+    updateCoords(key, lat, long) {
+        const item = this.itemMap.get(key);
+        item.lat = lat;
+        item.long = long;
+    }
+    insertTextBulk(items) {
+        for (const item of items) {
+            this.itemMap.set(item.key, item);
+        }
+    }
+    updateTextCoordsBulk(items) {
+        for (const { key, lat, long } of items) {
+            const item = this.itemMap.get(key);
+            item.lat = lat;
+            item.long = long;
+        }
+    }
+    deleteTextBulk(keys) {
+        for (const key of keys) {
+            this.itemMap.delete(key);
+        }
+    }
+    clear() {
+        this.itemMap.clear();
+    }
+}

package/dist/write-text/context-text3old.js

@@ -0,0 +1,152 @@
+"use strict";
+// import { CSZMode } from "@pirireis/webglobe";
+// import { isTextFont, opacityCheck } from "../util/check/typecheck";
+// /**
+//  * TODOs:
+//  * 1) update all if initials change (propably need a context and a callback to iterate over zPayload)
+//  * 2) expose a mechanic to update text on zoom change
+//  * 3) extend the mechanic on 2 to other events
+//  *
+//  * TODO: key check and raise error if doesnt exist
+//  */
+// export class ContextTextWriter3 {
+//     constructor(globe, {
+//         style = {
+//             textFont: {
+//                 name: 'Arial',
+//                 textColor: '#FFFFFF', // beyaz
+//                 hollowColor: '#000000', // siyah
+//                 size: 12, // piksel
+//                 hollow: true,
+//                 bold: true,
+//                 italic: false,
+//             },
+//             opacity: 1.0,
+//             zMode: CSZMode.Z_GROUND_PERVERTEX,
+//         },
+//         xOffset = 0,
+//         yOffset = 0,
+//         doDraw = true,
+//         textAdaptor = null,
+//         coordinatesAdaptor = null,
+//         keyAdaptor = null,
+//         opacityAdaptor = null,
+//         angleAdaptor = null,
+//         angleOnSphere = false,
+//         positionAdaptor = (item, i, container, properties) => "left",
+//         zoomLevelAdaptor = (zoomLevel) => (item) => {
+//             return {
+//                 opacityMultiplier: 1,
+//                 sizeMultiplier: 1
+//             }
+//         }
+//     } = {}) {
+//         this.globe = globe;
+//         this.itemMap = new Map();
+//         this.setStyle(style);
+//         this.doDraw = doDraw;
+//         this._checkParameterTypes(textAdaptor, coordinatesAdaptor, keyAdaptor, opacityAdaptor, angleAdaptor, xOffset, yOffset);
+//         this.textAdaptor = textAdaptor;
+//         this.coordinatesAdaptor = coordinatesAdaptor;
+//         this.keyAdaptor = keyAdaptor;
+//         this.zoomLevelAdaptor = zoomLevelAdaptor;
+//         this.positionAdaptor = positionAdaptor;
+//         this.opacityAdaptor = opacityAdaptor ? opacityAdaptor : () => 1;
+//         this.angleOnSphere = angleOnSphere;
+//         if (angleAdaptor) {
+//             this.angleAdaptor = angleAdaptor
+//             this.angleAdaptorIsOn = true;
+//         } else {
+//             this.angleAdaptor = () => null
+//             this.angleAdaptorIsOn = false
+//         }
+//         this.xOffset = xOffset;
+//         this.yOffset = yOffset;
+//     }
+//     _checkParameterTypes(textAdaptor, coordinatesAdaptor, keyAdaptor, opacityAdaptor, angleAdaptor, xOffset, yOffset) {
+//         if (textAdaptor !== null) if (!(textAdaptor instanceof Function)) throw new Error("textAdaptor is not an instance of a Function");
+//         if (coordinatesAdaptor !== null) if (!(coordinatesAdaptor instanceof Function)) throw new Error("coordinatesAdaptor is not an instance of a Function");
+//         if (keyAdaptor !== null) if (!(keyAdaptor instanceof Function)) throw new Error("keyAdaptor is not an instance of a Function");
+//         if (opacityAdaptor !== null) if (!(opacityAdaptor instanceof Function)) throw new Error("opacityAdaptor is not an instance of a Function");
+//         if (angleAdaptor !== null) if (!(angleAdaptor instanceof Function)) throw new Error("angleAdaptor is not an instance of a Function");
+//         if (typeof xOffset !== "number") throw new Error("xOffset type is not a number");
+//         if (typeof yOffset !== "number") throw new Error("yOffset type is not a number");
+//     }
+//     setKeyAdaptor(adaptor) {
+//         this.keyAdaptor = adaptor;
+//     }
+//     setDoDraw(bool) {
+//         this.doDraw = bool;
+//         this.globe.DrawRender();
+//     }
+//     setStyle(style) {
+//         isTextFont(style.textFont);
+//         opacityCheck(style.opacity); //TODO: use shallow copy
+//         this.style = style;
+//         this.globe.DrawRender();
+//     }
+//     setOpacity(opacity) {
+//         this.style.opacity = opacity;
+//         this.globe.DrawRender();
+//     }
+//     draw() {
+//         if (!this.doDraw) return;
+//         const { globe, style, itemMap, xOffset, yOffset } = this;
+//         const { textFont, opacity: opacity_ } = style;
+//         const textSize = textFont.size;
+//         const is3D = globe.api_GetCurrentGeometry() === 0;
+//         const angleIsOn = is3D ? (this.angleAdaptorIsOn && this.angleOnSphere) : (this.angleAdaptorIsOn)
+//         const zoomLevel = globe.api_GetCurrentLODWithDecimal();
+//         const zoomAdaptor = this.zoomLevelAdaptor(zoomLevel);
+//         for (const item of itemMap.values()) {
+//             const { lat, long, text, opacity = null, angle = null, zPayload, position } = item;
+//             const { x, y } = globe.api_GetScreenPointFromGeo(
+//                 {
+//                     long: long,
+//                     lat: lat,
+//                     z: 0,
+//                 },
+//                 style.zMode === CSZMode.Z_MSL,
+//             );
+//             const { opacityMultiplier, sizeMultiplier } = zoomAdaptor(zPayload);
+//             const o = (opacity === null ? opacity_ : opacity * opacity_) * opacityMultiplier;
+//             textFont.size = sizeMultiplier * textSize;
+//             textFont.position = position;
+//             if (x !== null && y !== null) globe.api_DrawContextTextMultiLine(text, textFont, o, { x: x + xOffset, y: y - yOffset }, angleIsOn, angle);
+//         }
+//         textFont.size = textSize;
+//     }
+//     insertTextBulk(container, properties) {
+//         container.forEach((v, i, c) => {
+//             this.insertText(v, i, c, properties);
+//         });
+//     }
+//     deleteTextBulk(keys) {
+//         for (const key of keys) {
+//             this.itemMap.delete(key);
+//         }
+//     }
+//     insertText(item, id, container, properties) {
+//         const key = this.keyAdaptor(item, id, container, properties)
+//         const coords = this.coordinatesAdaptor(item, id, container, properties)
+//         if (coords == null) {
+//             this.itemMap.delete(key);
+//             return;
+//         }
+//         const text = this.textAdaptor(item, id, container, properties)
+//         if (text == null) {
+//             this.itemMap.delete(key);
+//             return
+//         };
+//         const opacity = this.opacityAdaptor(item, id, container, properties);
+//         const angle = this.angleAdaptor(item, id, container, properties);
+//         const position = this.positionAdaptor(item, id, container, properties);
+//         this.itemMap.set(key, { long: coords.long, lat: coords.lat, text, opacity, angle, zPayload: item, position });
+//     }
+//     clear() {
+//         this.itemMap.clear();
+//     }
+//     free() {
+//         this.itemMap = null;
+//     }
+// }

package/dist/write-text/index.js

@@ -0,0 +1 @@
+export { ContextTextWriter } from "./context-text";

package/dist/write-text/writer-plugin.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * registerMap(id, aMap, textFont)
+ * aMap key, object map.
+ * aMap is a specifical tem for a use case.
+ * The object has { text, long, lat, opacity, angle, zPayload, achor, xOffset, yOffset, ...extraPropertiesForZoomLevelAdaptor } properties.
+ * the plugin runs over items in aMap and draw text on the globe.
+ */ 

package/heatwave/index.js

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