@pirireis/webglobeplugins 1.0.2 → 1.0.3

package/heatwave/{texture-point-sampler.ts → texture-point-sampler.js}

@@ -1,220 +1,187 @@
-class PointCoordsMeta {
-
-    _bbox: [number, number, number, number];
-    _width: number;
-    _height: number;
-    _xRatio: number;
-    _yRatio: number;
-
-    constructor(bbox: [number, number, number, number], width: number, height: number) {
-        this._bbox = bbox;
-        this._width = width;
-        this._height = height;
-        this._xRatio = this._width / (this._bbox[2] - this._bbox[0]);
-        this._yRatio = this._height / (this._bbox[3] - this._bbox[1]);
-
-    }
-
-    getFlooredIndex(long: number, lat: number): number {
-        let x = (long - this._bbox[0]) * this._xRatio;
-        let y = (this._bbox[3] - lat) * this._yRatio;
-        x = x > 0 ? x - 1 : 0;
-        y = y > 0 ? y - 1 : 0;
-        const index = Math.floor(y) * this._width + Math.floor(x);
-        return index;
-    }
-}
-
-type BBOX = [number, number, number, number];
-type CallBackFunction = (data0: number | null, data1: number | null, interpolated: number | null) => void;
-type PointObject = {
-    long: number;
-    lat: number;
-    posIndex: number;
-    callback: CallBackFunction;
-}
-type TypedArray = Float32Array | Uint8Array | Uint16Array | Uint32Array;
-
-const pointObject = (long: number, lat: number, posIndex: number, callback: CallBackFunction): PointObject => {
-    return { long, lat, posIndex, callback };
-}
-
-export class TexturePointSampler {
-    _bbox: BBOX;
-    _width: number;
-    _height: number;
-    _textureCount: 1 | 2;
-    _metaCalculater: PointCoordsMeta;
-    _pointObjects: Map<string, PointObject>;
-    _textures: Array<TypedArray>;
-    _ratio: number;
-    _isReady: boolean = false;
-
-    constructor(bbox: BBOX, width: number, height: number, textureCount: 1 | 2 = 2) {
-        this._pointObjects = new Map<string, PointObject>();
-
-        this._ratio = 0.0;
-        this._bbox = bbox;
-        this._width = width;
-        this._height = height;
-        this._textureCount = textureCount;
-        this._metaCalculater = new PointCoordsMeta(bbox, width, height);
-        this._textures = new Array(textureCount).fill(null);
-        this._isReady = false;
-    }
-
-    setTextureCount(textureCount: 1 | 2) {
-        if (textureCount !== 1 && textureCount !== 2) {
-            throw new Error("Texture count must be 1 or 2");
-        }
-
-        this._textureCount = textureCount;
-        this._pushPointCallbackAll();
-    }
-
-    registerPoint(key: string, long: number, lat: number, callback: CallBackFunction): boolean {
-        if (key in this._pointObjects) {
-            console.warn("key already registered, old one is unregistered");
-            this.unregisterPoint(key);
-        }
-        if (!this._isInBBox(long, lat)) {
-            this._pointObjects.set(key, pointObject(long, lat, -1, callback));
-            this._findAndSend(key);
-
-            return false;
-        } else {
-            const index = this._metaCalculater.getFlooredIndex(long, lat)
-            this._pointObjects.set(key, pointObject(long, lat, index, callback));
-        }
-
-        this._findAndSend(key);
-        return true;
-    }
-
-
-
-    unregisterPoint(key: string): boolean {
-        return this._pointObjects.delete(key);
-    }
-
-    updatePoint(key: string, long: number, lat: number): boolean {
-        const pointObject = this._pointObjects.get(key);
-        if (!pointObject) {
-            console.warn("Point not registered, use registerPoint first");
-            return false;
-        }
-        pointObject.long = long;
-        pointObject.lat = lat;
-        if (!this._isInBBox(long, lat)) {
-            pointObject.posIndex = -1; // Mark as invalid
-            pointObject.callback(null, null, null);
-            return false
-        };
-
-        const index = this._metaCalculater.getFlooredIndex(long, lat);
-        pointObject.posIndex = index;
-        this._findAndSend(key);
-
-        return true;
-    }
-
-    updateTextureData(ratio: number, textureData0: TypedArray | null = null, textureData1: TypedArray | null = null,) {
-
-        if (this._textureCount === 1) {
-            if (textureData0 === null) {
-                this._isReady = false;
-            } else {
-                this._textures[0] = textureData0;
-                this._isReady = true;
-            }
-        } else if (this._textureCount === 2) {
-            if (textureData0 === null || textureData1 === null) {
-                this._isReady = false;
-            } else {
-                this._textures[0] = textureData0;
-                this._textures[1] = textureData1;
-                this._isReady = true;
-            }
-        } else {
-            throw new Error("Invalid texture count, must be 1 or 2");
-        }
-        this.updateRatio(ratio);
-    }
-
-
-    updateRatio(ratio: number) {
-        if (typeof ratio !== "number") {
-            throw new Error("Ratio must be a number");
-        }
-        this._ratio = ratio;
-        this._pushPointCallbackAll();
-    }
-
-    flush(callEmptyCallback: boolean = false) {
-        if (callEmptyCallback) {
-            for (const [, { callback }] of this._pointObjects.entries()) {
-                callback(null, null, null);
-            }
-        }
-        this._pointObjects.clear();
-    }
-
-    // ------- PRIVATE METHODS -------
-
-    _isInBBox(long: number, lat: number) {
-        return lat >= this._bbox[1] && lat <= this._bbox[3] && long >= this._bbox[0] && long <= this._bbox[2];
-    }
-
-
-    _findAndSend(key: string) {
-        const pointObject = this._pointObjects.get(key);
-        if (!pointObject) {
-            console.warn("Point not registered, use registerPoint first");
-            return;
-        }
-        const { posIndex, callback } = pointObject;
-        if (posIndex === -1 || !this._isReady || this._ratio < 0 || this._ratio > 1) {
-            callback(null, null, null);
-            return;
-        }
-        const data0 = this._textures[0][posIndex];
-
-        if (this._textureCount === 1) {
-            callback(data0, data0, data0);
-        } else if (this._textureCount === 2) {
-            const data1 = this._textures[1][posIndex];
-            const interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
-            callback(data0, data1, interpolated);
-        }
-    }
-
-    _pushPointCallbackAll() {
-        if (this._isReady && this._ratio >= 0 && this._ratio <= 1) {
-            for (const key of this._pointObjects.keys()) {
-                this._findAndSend(key);
-            }
-        } else {
-            for (const [, { callback }] of this._pointObjects.entries()) {
-                callback(null, null, null);
-            }
-        }
-    }
-}
-
-// function test() {
-//     const cp = window.plugin.getPointCoordinatesDataCalculator();
-//     const bbox = [-15, 25, 70, 60];
-//     cp.registerPoint("left up", -15, 60, (data0, data1, interpolated) => {
-//         console.log("left up", data0, data1, interpolated);
-//     });
-//     cp.registerPoint("right up", 70, 60, (data0, data1, interpolated) => {
-//         console.log("right up", data0, data1, interpolated);
-//     });
-//     cp.registerPoint("left down", -15, 25, (data0, data1, interpolated) => {
-//         console.log("right down", data0, data1, interpolated);
-//     });
-//     cp.registerPoint("right down", 70, 25, (data0, data1, interpolated) => {
-//         console.log("right down", data0, data1, interpolated);
-//     });
-//     return cp;
-// }
+class PointCoordsMeta {
+    _bbox;
+    _width;
+    _height;
+    _xRatio;
+    _yRatio;
+    constructor(bbox, width, height) {
+        this._bbox = bbox;
+        this._width = width;
+        this._height = height;
+        this._xRatio = this._width / (this._bbox[2] - this._bbox[0]);
+        this._yRatio = this._height / (this._bbox[3] - this._bbox[1]);
+    }
+    getFlooredIndex(long, lat) {
+        let x = (long - this._bbox[0]) * this._xRatio;
+        let y = (this._bbox[3] - lat) * this._yRatio;
+        x = x > 0 ? x - 1 : 0;
+        y = y > 0 ? y - 1 : 0;
+        const index = Math.floor(y) * this._width + Math.floor(x);
+        return index;
+    }
+}
+const pointObject = (long, lat, posIndex, callback) => {
+    return { long, lat, posIndex, callback };
+};
+export class TexturePointSampler {
+    _bbox;
+    _width;
+    _height;
+    _textureCount;
+    _metaCalculater;
+    _pointObjects;
+    _textures;
+    _ratio;
+    _isReady = false;
+    constructor(bbox, width, height, textureCount = 2) {
+        this._pointObjects = new Map();
+        this._ratio = 0.0;
+        this._bbox = bbox;
+        this._width = width;
+        this._height = height;
+        this._textureCount = textureCount;
+        this._metaCalculater = new PointCoordsMeta(bbox, width, height);
+        this._textures = new Array(textureCount).fill(null);
+        this._isReady = false;
+    }
+    setTextureCount(textureCount) {
+        if (textureCount !== 1 && textureCount !== 2) {
+            throw new Error("Texture count must be 1 or 2");
+        }
+        this._textureCount = textureCount;
+        this._pushPointCallbackAll();
+    }
+    registerPoint(key, long, lat, callback) {
+        if (key in this._pointObjects) {
+            console.warn("key already registered, old one is unregistered");
+            this.unregisterPoint(key);
+        }
+        if (!this._isInBBox(long, lat)) {
+            this._pointObjects.set(key, pointObject(long, lat, -1, callback));
+            this._findAndSend(key);
+            return false;
+        }
+        else {
+            const index = this._metaCalculater.getFlooredIndex(long, lat);
+            this._pointObjects.set(key, pointObject(long, lat, index, callback));
+        }
+        this._findAndSend(key);
+        return true;
+    }
+    unregisterPoint(key) {
+        return this._pointObjects.delete(key);
+    }
+    updatePoint(key, long, lat) {
+        const pointObject = this._pointObjects.get(key);
+        if (!pointObject) {
+            console.warn("Point not registered, use registerPoint first");
+            return false;
+        }
+        pointObject.long = long;
+        pointObject.lat = lat;
+        if (!this._isInBBox(long, lat)) {
+            pointObject.posIndex = -1; // Mark as invalid
+            pointObject.callback(null, null, null);
+            return false;
+        }
+        ;
+        const index = this._metaCalculater.getFlooredIndex(long, lat);
+        pointObject.posIndex = index;
+        this._findAndSend(key);
+        return true;
+    }
+    updateTextureData(ratio, textureData0 = null, textureData1 = null) {
+        if (this._textureCount === 1) {
+            if (textureData0 === null) {
+                this._isReady = false;
+            }
+            else {
+                this._textures[0] = textureData0;
+                this._isReady = true;
+            }
+        }
+        else if (this._textureCount === 2) {
+            if (textureData0 === null || textureData1 === null) {
+                this._isReady = false;
+            }
+            else {
+                this._textures[0] = textureData0;
+                this._textures[1] = textureData1;
+                this._isReady = true;
+            }
+        }
+        else {
+            throw new Error("Invalid texture count, must be 1 or 2");
+        }
+        this.updateRatio(ratio);
+    }
+    updateRatio(ratio) {
+        if (typeof ratio !== "number") {
+            throw new Error("Ratio must be a number");
+        }
+        this._ratio = ratio;
+        this._pushPointCallbackAll();
+    }
+    flush(callEmptyCallback = false) {
+        if (callEmptyCallback) {
+            for (const [, { callback }] of this._pointObjects.entries()) {
+                callback(null, null, null);
+            }
+        }
+        this._pointObjects.clear();
+    }
+    // ------- PRIVATE METHODS -------
+    _isInBBox(long, lat) {
+        return lat >= this._bbox[1] && lat <= this._bbox[3] && long >= this._bbox[0] && long <= this._bbox[2];
+    }
+    _findAndSend(key) {
+        const pointObject = this._pointObjects.get(key);
+        if (!pointObject) {
+            console.warn("Point not registered, use registerPoint first");
+            return;
+        }
+        const { posIndex, callback } = pointObject;
+        if (posIndex === -1 || !this._isReady || this._ratio < 0 || this._ratio > 1) {
+            callback(null, null, null);
+            return;
+        }
+        const data0 = this._textures[0][posIndex];
+        if (this._textureCount === 1) {
+            callback(data0, data0, data0);
+        }
+        else if (this._textureCount === 2) {
+            const data1 = this._textures[1][posIndex];
+            const interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
+            callback(data0, data1, interpolated);
+        }
+    }
+    _pushPointCallbackAll() {
+        if (this._isReady && this._ratio >= 0 && this._ratio <= 1) {
+            for (const key of this._pointObjects.keys()) {
+                this._findAndSend(key);
+            }
+        }
+        else {
+            for (const [, { callback }] of this._pointObjects.entries()) {
+                callback(null, null, null);
+            }
+        }
+    }
+}
+// function test() {
+//     const cp = window.plugin.getPointCoordinatesDataCalculator();
+//     const bbox = [-15, 25, 70, 60];
+//     cp.registerPoint("left up", -15, 60, (data0, data1, interpolated) => {
+//         console.log("left up", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("right up", 70, 60, (data0, data1, interpolated) => {
+//         console.log("right up", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("left down", -15, 25, (data0, data1, interpolated) => {
+//         console.log("right down", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("right down", 70, 25, (data0, data1, interpolated) => {
+//         console.log("right down", data0, data1, interpolated);
+//     });
+//     return cp;
+// }

package/investigation-tools/draw/tiles/adapters.js

@@ -0,0 +1,67 @@
+function boilerArcInput(start, end, color, key) {
+    return {
+        key: key,
+        start: start,
+        end: end,
+        color: color,
+        height: null,
+        msl: null
+    };
+}
+export function tileToArcInputs(tiles, color) {
+    if (tiles.length === 0)
+        return [];
+    const result = [];
+    // (alias) type ArcInput = {
+    //     key: string;
+    //     start: LongLat;
+    //     end: LongLat;
+    //     color: Color;
+    //     height?: Meter | null;
+    //     msl?: boolean | null;
+    // }
+    for (const tile of tiles) {
+        const tileKey = `tile_${tile.x}_${tile.y}`;
+        const bbox = tile.bbox;
+        // left side
+        result.push(boilerArcInput([bbox.ll.x, bbox.ll.y], [bbox.ll.x, bbox.ur.y], color, `${tileKey}_left`));
+        // top side
+        result.push(boilerArcInput([bbox.ll.x, bbox.ur.y], [bbox.ur.x, bbox.ur.y], color, `${tileKey}_top`));
+        // bottom side
+        result.push(boilerArcInput([bbox.ll.x, bbox.ll.y], [bbox.ur.x, bbox.ll.y], color, `${tileKey}_bottom`));
+        // right side
+        result.push(boilerArcInput([bbox.ur.x, bbox.ll.y], [bbox.ur.x, bbox.ur.y], color, `${tileKey}_right`));
+    }
+    return result;
+}
+export function mergedTileToArcInputs(mergedTile, color) {
+    const result = [];
+    const bbox = mergedTile.bbox;
+    // left side
+    result.push(boilerArcInput([bbox.ll.x, bbox.ll.y], [bbox.ll.x, bbox.ur.y], color, `${mergedTile.zoom}_left`));
+    // right side
+    result.push(boilerArcInput([bbox.ur.x, bbox.ll.y], [bbox.ur.x, bbox.ur.y], color, `${mergedTile.zoom}_right`));
+    // top side
+    result.push(boilerArcInput([bbox.ll.x, bbox.ur.y], [bbox.ur.x, bbox.ur.y], color, `${mergedTile.zoom}_top`));
+    // bottom side
+    result.push(boilerArcInput([bbox.ll.x, bbox.ll.y], [bbox.ur.x, bbox.ll.y], color, `${mergedTile.zoom}_bottom`));
+    return result;
+}
+export function tilesToContextWriter4Inputs(tiles) {
+    const result = [];
+    for (const tile of tiles) {
+        const tileKey = `L_${tile.level}_R${tile.x}_C${tile.y}`;
+        const centerLong = (tile.bbox.ll.x + tile.bbox.ur.x) / 2;
+        const centerLat = (tile.bbox.ll.y + tile.bbox.ur.y) / 2;
+        result.push({
+            key: tileKey,
+            long: centerLong,
+            lat: centerLat,
+            text: tileKey,
+            opacity: null,
+            angle: null,
+            position: 'center'
+        });
+    }
+    return result;
+}