@pirireis/webglobeplugins 0.17.0 → 1.0.2

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

@@ -1,187 +1,220 @@
-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;
-// }
+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;
+// }

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

@@ -0,0 +1,133 @@
+import { Tile, DrawnTileInfo, Color } from "../../../types";
+import { TextItem } from "../../../write-text/context-text4";
+import { ArcInput } from "../../../semiplugins/shape-on-terrain/arc-plugin";
+import { LongLat } from "../../../Math/types";
+import { Globe } from "../../../types";
+
+function boilerArcInput(start: LongLat, end: LongLat, color: Color, key: string): ArcInput {
+    return {
+        key: key,
+        start: start,
+        end: end,
+        color: color,
+        height: null,
+        msl: null
+    };
+}
+
+export function tileToArcInputs(tiles: DrawnTileInfo[], color: Color): ArcInput[] {
+
+    if (tiles.length === 0) return [];
+    const result: ArcInput[] = [];
+    // (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: { mesh: Float32Array, bbox: { ll: { x: number, y: number }, ur: { x: number, y: number } }, zoom: number }, color: Color):
+    ArcInput[] {
+    const result: ArcInput[] = [];
+    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: DrawnTileInfo[]): TextItem[] {
+
+    const result: TextItem[] = [];
+    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;
+}
+