@pirireis/webglobeplugins 0.9.7 → 0.9.8

package/dist/shape-on-terrain/arc/naive/plugin.js

@@ -0,0 +1,252 @@
+"use strict";
+// import { LineStripProgramCache } from "../../../programs/line-on-globe/linestrip"
+// import "../../../programs/interface";
+// import { createBufferAndReadInfo } from '../../../util/gl-util/buffer/attribute-loader';
+// import { populateFloat32Array } from "../../../util/jshelpers/data-filler";
+// import { BufferManagement, BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
+// import { globe3Dcoordinates, globe2Dcoordinates, RADIANS } from "../../../Math/methods";
+// import { Vector3D } from "../../../Math/vector3d";
+// import { Arc } from "../../../Math/arc";
+// import { Plane } from "../../../Math/plane";
+// import { arcFrustumPlanesIntersection } from "../../../Math/intersections/arc-frustum-planes";
+// import { CameraUniformBlockTotemCache, CameraUniformBlockTotem } from "../../../programs/totems/camerauniformblock";
+// import { FrustumPlanes } from "../../../Math/frustum/types";
+// const VERTEX_COUNT = 360;
+// const INITAL_CAPACITY = 10;
+// const _0vector = new Vector3D();
+// const _0arc = new Arc();
+// // window add properties
+// declare global {
+//     interface Window {
+//         startPoint: Vector3D;
+//         endPoint: Vector3D;
+//     }
+// }
+// let interval = 1;
+// const testVec = new Vector3D(0, 0, 1);
+// testVec.setFromLongLat(30 * RADIANS, 30 * RADIANS);
+// console.log("testVec", testVec.x, testVec.y, testVec.z);
+// testVec.setFromLongLat(50 * RADIANS, 50 * RADIANS);
+// console.log("testVec", testVec.x, testVec.y, testVec.z);
+// export class NaiveLineOnTerrainPlugin {
+//     public id: string;
+//     private program: ProgramInterface;
+//     private _bufferManagersCompMap: BufferManagement;
+//     private _bufferManagersCompMapTest: BufferManagement;
+//     private _bufferOrchestrator: BufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
+//     private _testOrchestrator: BufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
+//     private _opacity: number = 1;
+//     private _arcUBOHandler: UBOHandler;
+//     private _vao: WebGLVertexArrayObject;
+//     private _vaoAllTest: WebGLVertexArrayObject;
+//     private _ubohandlerAllTest: UBOHandler;
+//     private globe: any;
+//     private gl: WebGL2RenderingContext;
+//     private _arcMap: Map<string, Arc>;
+//     private _arcMapTest: Map<string, Arc>;
+//     private _screenPlane: Plane = new Plane();
+//     private _doBuild: boolean = false
+//     private _cameraUniformBlock: CameraUniformBlockTotem;
+//     public fieldOfView = 50 * RADIANS; // 50 degrees in radians
+//     constructor(id: string) {
+//         this.id = id;
+//         this._arcMap = new Map();
+//         this._arcMapTest = new Map();
+//     }
+//     insertArcFromLongLat(key: string, startPoint: { long: number, lat: number }, endPoint: { long: number, lat: number }) {
+//         if (this._arcMap.has(key)) {
+//             this._arcMap.delete(key);
+//         }
+//         const start = _0vector.setFromLongLat(startPoint.long * RADIANS, startPoint.lat * RADIANS).clone();
+//         const end = _0vector.setFromLongLat(endPoint.long * RADIANS, endPoint.lat * RADIANS).clone();
+//         window.startPoint = start;
+//         window.endPoint = end;
+//         const arc = new Arc(start, end);
+//         this._arcMap.set(key, arc);
+//         this._arcMapTest.set(key, arc.clone());
+//         const longLatArr = new Float32Array(2 * VERTEX_COUNT);
+//         const _3Dpoints = arc.populatePoints3D(VERTEX_COUNT);
+//         const longLat = {
+//             long: 1,
+//             lat: 1
+//         };
+//         for (let i = 0; i < _3Dpoints.length / 3; i++) {
+//             _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
+//             longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
+//         }
+//         const result = [{
+//             key: key,
+//             longLatArr: longLatArr,
+//         }
+//         ]
+//         this._testOrchestrator.insertBulk(result, this._bufferManagersCompMapTest);
+//         this._doBuild = true;
+//     }
+//     init(globe: any, gl: WebGL2RenderingContext) {
+//         this.globe = globe;
+//         this.gl = gl;
+//         this.program = LineStripProgramCache.get(globe);
+//         const g3D = globe3Dcoordinates(globe, 30);
+//         const g2D = globe2Dcoordinates(globe);
+//         this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
+//         this._bufferManagersCompMap = new Map(
+//             [
+//                 ["position3d", {
+//                     bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+//                     adaptor: (item: any) => {
+//                         const { longLatArr } = item;
+//                         const result = g3D(longLatArr, { paddingCount: 1 });
+//                         // console.log("result", result);
+//                         return result;
+//                     }
+//                 }],
+//                 ["position2d", {
+//                     bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+//                     adaptor: (item: any) => {
+//                         const { longLatArr } = item;
+//                         return g2D(longLatArr, { paddingCount: 1 });
+//                     }
+//                 }
+//                 ],
+//             ]
+//         );
+//         this._bufferManagersCompMapTest = new Map([
+//             ["positionTest3d", {
+//                 bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+//                 adaptor: (item: any) => {
+//                     const { longLatArr } = item;
+//                     const result = g3D(longLatArr, { paddingCount: 1 });
+//                     return result;
+//                 }
+//             }],
+//             ["positionTest2d", {
+//                 bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+//                 adaptor: (item: any) => {
+//                     const { longLatArr } = item;
+//                     return g2D(longLatArr, { paddingCount: 1 });
+//                 }
+//             }
+//             ]
+//         ]
+//         );
+//         this._bufferOrchestrator = new BufferOrchestrator(gl, this._bufferManagersCompMap);
+//         this._arcUBOHandler = this.program.createUBO();
+//         this._arcUBOHandler.update(new Map([
+//             ["u_color", new Float32Array([1, 0, 0, 1])],
+//         ]));
+//         this._ubohandlerAllTest = this.program.createUBO();
+//         this._ubohandlerAllTest.update(new Map([
+//             ["u_color", new Float32Array([0, 0, 1, 1])],
+//         ]));
+//         this._vao = this.program.createVAO(
+//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position3d").bufferManager.buffer),
+//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position2d").bufferManager.buffer),
+//             null,
+//             null,
+//             null,
+//         );
+//         this._vaoAllTest = this.program.createVAO(
+//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest3d").bufferManager.buffer),
+//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest2d").bufferManager.buffer),
+//             null,
+//             null,
+//             null,
+//         );
+//     }
+//     setFieldOfView(fieldOfView: number) {
+//         this.fieldOfView = fieldOfView * RADIANS; // convert degrees to radians
+//         this.globe.DrawRender();
+//     }
+//     _buildArcs() {
+//         // updatePlane
+//         const { globe, _arcMap } = this;
+//         const planes = this._cameraUniformBlock.getFrustumPlanes() as FrustumPlanes;
+// //
+//         const cameraPostition = new Vector3D();
+//         cameraPostition.copy(globe.Fp as Vector3D).normalize();
+//         // calculateHorizonPlane(globe, _screenPlane, this.fieldOfView);
+//         const result = [];
+//         const longLat = {
+//             long: 1,
+//             lat: 1
+//         }
+//         let counter = 0;
+//         for (const [key, arc] of _arcMap) {
+//             // const isArc = arc.intersectionMedium(_screenPlane, _0arc) as Arc;
+//             _0arc.copy(arc);
+//             const isArc = arcFrustumPlanesIntersection(_0arc, planes, _0arc);
+//             if (!isArc) {
+//                 continue;
+//             }
+//             counter++;
+//             const longLatArr = new Float32Array(2 * VERTEX_COUNT);
+//             // const _3Dpoints = _0arc.populatePoints3DInRespectToCamera(cameraPostition, VERTEX_COUNT);
+//             const _3Dpoints = _0arc.populatePoints3D(VERTEX_COUNT);
+//             for (let i = 0; i < _3Dpoints.length / 3; i++) {
+//                 _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
+//                 longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
+//             }
+//             result.push({
+//                 key: key,
+//                 longLatArr: longLatArr,
+//             });
+//             // if (!arc.imaginaryPlane.equals(_0arc.imaginaryPlane) || !arc.imaginaryPlane.equalsReverseOriantation(_0arc.imaginaryPlane)) {
+//             //     // console.log("Arc with key", key, "has imaginary plane equal to the original arc's imaginary plane.");
+//             //     throw new Error("The arc segment is not on the parent arc")
+//             // }
+//         }
+//         interval += 1;
+//         if (interval === 100) {
+//             interval = 1;
+//             console.log("Arc count on screen:", counter);
+//         }
+//         // update buffer
+//         this._bufferOrchestrator.resetWithCapacity(this._bufferManagersCompMap, result.length);
+//         this._bufferOrchestrator.insertBulk(result, this._bufferManagersCompMap);
+//         this._doBuild = false;
+//         this._checkIfCorrupted(); // check if any arc is corrupted
+//     }
+//     draw3D() {
+//         // Drawing logic here
+//         this._buildArcs() // can be async
+//         const { gl, program, _bufferOrchestrator } = this;
+//         gl.disable(gl.DEPTH_TEST);
+//         const drawOptionTest = {
+//             drawRange: {
+//                 first: 0,
+//                 count: this._testOrchestrator.length * (VERTEX_COUNT + 1)
+//             },
+//             indexes: null
+//         }
+//         program.draw(
+//             this._vaoAllTest,
+//             drawOptionTest,
+//             this._opacity,
+//             this._ubohandlerAllTest
+//         );
+//         const drawOptions = {
+//             drawRange: {
+//                 first: 0,
+//                 count: _bufferOrchestrator.length * (VERTEX_COUNT + 1)
+//             },
+//             indexes: null
+//         }
+//         program.draw(
+//             this._vao,
+//             drawOptions,
+//             this._opacity,
+//             this._arcUBOHandler
+//         );
+//         gl.enable(gl.DEPTH_TEST);
+//     }
+//     _checkIfCorrupted() {
+//         for (const [key, arc] of this._arcMap) {
+//             if (!arc.p0.equals(arc.p1)) {
+//                 continue; // valid arc
+//             }
+//             console.warn(`Arc with key ${key} is corrupted: p0 and p1 are the same point.`);
+//             // this._arcMap.delete(key);
+//             // this._arcMapTest.delete(key);
+//         }
+//     }
+// }

package/dist/timetracks/adaptors-line-strip.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.latLongToPixelXY = void 0;
+exports.addCuttingPointLineStrip = addCuttingPointLineStrip;
+exports.featuresToLineStringData = featuresToLineStringData;
+exports.fillSliceOfFloat32ArrayLineStrip = fillSliceOfFloat32ArrayLineStrip;
+const util_1 = require("../util");
+Object.defineProperty(exports, "latLongToPixelXY", { enumerable: true, get: function () { return util_1.latLongToPixelXY; } });
+/**
+ * @param {Array.<Array.<number>>} coordinates
+ * @param {Array.<number>} timestamps
+ * @param {Array.<String>} styleGroupNameArray
+ * @param {Object.<string, TrackStyleGroup>} _groupColorMap
+ * @param {Float32Array} floatArray
+ * @param {number} offset
+ *
+ * create floatArray with createFloat32Array before calling this function.
+ * start offset from 0.
+ * feed the floatArray with a track data and offset that is returned from the previous call.
+ */
+function featuresToLineStringData(data) {
+    /**
+     * features are the tracks
+     * feature[i].geometry.coordinates are the points of the track
+     * feature[i].properties.messageTime are the timestamps of the points
+     *
+     */
+    const features = data.features;
+    let size = data.features.length - 1;
+    let startTime = features[0].properties.messageTime[0];
+    let endTime = features[0].properties.messageTime[features[0].properties.messageTime.length - 1];
+    for (let feature of features) {
+        size += feature.properties.messageTime.length;
+        startTime = Math.min(startTime, feature.properties.messageTime[0]);
+        endTime = Math.max(endTime, feature.properties.messageTime[feature.properties.messageTime.length - 1]);
+    }
+    const array = new Float32Array(size * 9);
+    let offset = 0;
+    {
+        const feature = features[0];
+        const coordinates = feature.geometry.coordinates;
+        const timestamps = feature.properties.messageTime.map((time) => (time - startTime) / 1000);
+        offset = fillSliceOfFloat32ArrayLineStrip(array, offset, coordinates, timestamps);
+    }
+    for (let i = 1; i < features.length; i++) {
+        const feature = features[i];
+        const coordinates = feature.geometry.coordinates;
+        const timestamps = feature.properties.messageTime.map((time) => (time - startTime) / 1000);
+        offset = addCuttingPointLineStrip(array, offset);
+        offset = fillSliceOfFloat32ArrayLineStrip(array, offset, coordinates, timestamps);
+    }
+    return { data: array, startTime, endTime };
+}
+function fillSliceOfFloat32ArrayLineStrip(floatArray, offset, coordinates, timestamps, { styleGroupNameArray = null, groupColorFunction = () => [Math.random(), Math.random(), Math.random()] } = {}) {
+    const startTime = timestamps[0];
+    const endTime = timestamps[timestamps.length - 1];
+    for (let i = 0; i < coordinates.length; i++) {
+        const time = timestamps[i];
+        const coord = coordinates[i];
+        const styleGroupName = styleGroupNameArray ? styleGroupNameArray[i] : "default";
+        const { x, y } = (0, util_1.latLongToPixelXY)(coord[1], coord[0]);
+        const z = coord[2] ? coord[2] / 1000.0 : 0;
+        floatArray.set([x, y, z, time, ...groupColorFunction(styleGroupName), startTime, endTime], offset);
+        offset += 9;
+    }
+    return offset;
+}
+function addCuttingPointLineStrip(floatArray, offset) {
+    floatArray.set(new Float32Array(9).fill(NaN), offset);
+    return offset + 9;
+}

package/dist/timetracks/adaptors.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Adaptor = void 0;
+exports.fillSliceOfFloat32Array = fillSliceOfFloat32Array;
+exports.createFloat32Array = createFloat32Array;
+const util_1 = require("../util");
+const _latLongToPixelXY = util_1.latLongToPixelXY;
+class Adaptor {
+    /**
+     * @param {Object.<string, Color>} groupColorMap
+     * @typedef {Array} Color | [r, g, b] | between 0-1
+     */
+    constructor(groupColorMap) {
+        this._groupColorMap = groupColorMap;
+    }
+    /**
+     * @param {Object} geojsonObject
+     * @param {number} startTime
+     * @param {string} timePropertyName
+     * @param {string} styleGroupPropertyName
+     * @returns {lineData} lineData for Plugin
+     */
+    fromGeoJson(geojsonObject, startTime, timePropertyName = "messageTime", styleGroupPropertyName = "styleGroup") {
+        const features = geojsonObject.features.filter(feature => feature.geometry.coordinates.length > 1);
+        const buffer = createFloat32Array(features.map(feature => feature.geometry.coordinates));
+        let offset = 0;
+        for (let feature of features) {
+            const coordinates = feature.geometry.coordinates;
+            const timestamps = feature.properties[timePropertyName].map((time) => (time - startTime) / 1000);
+            const styleGroupNameArray = feature.properties[styleGroupPropertyName];
+            offset = fillSliceOfFloat32Array(coordinates, timestamps, styleGroupNameArray, this._groupColorMap, buffer, offset);
+        }
+        return buffer;
+    }
+    /**
+     * Inputs are lists of tracks. Each track is a list of coordinates, timestamps and styleGroupNames.
+     * @param {Array.<Array.<Array.<number>>>} coordinatesList | [ [ [lon, lat, z], [lon, lat, z], ...], ...
+     * @param {Array.<Array.<number>>} timestampsList | [ [time, time, ...], ...
+     * @param {Array.<Array.<String>>} colorGroupList | [ [styleGroupName, styleGroupName, ...], ...
+     * @param {number} startTime | epoch time
+     * @returns {lineData} lineData for Plugin
+     */
+    fromLists(coordinatesList, timestampsList, colorGroupList, startTime) {
+        const buffer = createFloat32Array(coordinatesList);
+        let offset = 0;
+        for (let i = 0; i < coordinatesList.length; i++) {
+            const coordinates = coordinatesList[i];
+            const timestamps = timestampsList[i].map((time) => (time - startTime) / 1000);
+            const styleGroupNameArray = colorGroupList[i];
+            offset = fillSliceOfFloat32Array(coordinates, timestamps, styleGroupNameArray, this._groupColorMap, buffer, offset);
+        }
+        return buffer;
+    }
+}
+exports.Adaptor = Adaptor;
+/**
+ * @param {Array.<Array.<number>>} coordinates
+ * @param {Array.<number>} timestamps
+ * @param {Array.<String>} styleGroupNameArray
+ * @param {Object.<string, TrackStyleGroup>} _groupColorMap
+ * @param {Float32Array} floatArray
+ * @param {number} offset
+ *
+ * create floatArray with createFloat32Array before calling this function.
+ * start offset from 0.
+ * feed the floatArray with a track data and offset that is returned from the previous call.
+ */
+function fillSliceOfFloat32Array(coordinates, timestamps, styleGroupNameArray, _groupColorMap, floatArray, offset) {
+    if (coordinates[0].length === 2) {
+        const startTime = timestamps[0];
+        const endTime = timestamps[timestamps.length - 1];
+        let prevPointData = null;
+        { // first point
+            const { x, y } = _latLongToPixelXY(coordinates[0][1], coordinates[0][0]);
+            prevPointData = [x, y, 0, timestamps[0], ..._groupColorMap[styleGroupNameArray[0]]];
+        }
+        { // middle points until end
+            for (let i = 1; i < coordinates.length; i++) {
+                const time = timestamps[i];
+                const coord = coordinates[i];
+                const { x, y } = _latLongToPixelXY(coord[1], coord[0]);
+                floatArray.set([...prevPointData, startTime, endTime, x, y, 0, time, ..._groupColorMap[styleGroupNameArray[i]], startTime, endTime], offset);
+                prevPointData = [x, y, 0, time, ..._groupColorMap[styleGroupNameArray[i]]];
+                offset += 18;
+            }
+        }
+    }
+    else {
+        const startTime = timestamps[0];
+        const endTime = timestamps[timestamps.length - 1];
+        let prevPointData = null;
+        { // first point
+            const { x, y } = _latLongToPixelXY(coordinates[0][1], coordinates[0][0]);
+            prevPointData = [x, y, coordinates[0][2] / 1000.0, timestamps[0], ..._groupColorMap[styleGroupNameArray[0]]];
+        }
+        { // middle points until end
+            for (let i = 1; i < coordinates.length; i++) {
+                const time = timestamps[i];
+                const coord = coordinates[i];
+                const { x, y } = _latLongToPixelXY(coord[1], coord[0]);
+                floatArray.set([...prevPointData, startTime, endTime, x, y, coord[2] / 1000.0, time, ..._groupColorMap[styleGroupNameArray[i]], startTime, endTime], offset);
+                prevPointData = [x, y, coord[2] / 1000.0, time, ..._groupColorMap[styleGroupNameArray[i]]];
+                offset += 18;
+            }
+        }
+    }
+    return offset;
+}
+/**
+ *
+ * @param {*} coordinatesArray
+ * @returns Float32Array
+ * Coordinates array is needed to calculate the size of the buffer.
+ */
+function createFloat32Array(coordinatesArray) {
+    let filteredSize = 0;
+    for (let coordinates of coordinatesArray) {
+        filteredSize += coordinates.length * 2 - 2;
+    }
+    const array = new Float32Array(filteredSize * 9);
+    return array;
+}

package/dist/timetracks/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.latLongToPixelXY = exports.fillSliceOfFloat32ArrayLineStrip = exports.featuresToLineStringData = exports.addCuttingPointLineStrip = exports.TimeTracksLineStrip = exports.TimeTracks = exports.createFloat32Array = exports.fillSliceOfFloat32Array = exports.Adaptor = void 0;
+const plugin_1 = __importDefault(require("./plugin"));
+exports.TimeTracks = plugin_1.default;
+const adaptors_1 = require("./adaptors");
+Object.defineProperty(exports, "Adaptor", { enumerable: true, get: function () { return adaptors_1.Adaptor; } });
+Object.defineProperty(exports, "fillSliceOfFloat32Array", { enumerable: true, get: function () { return adaptors_1.fillSliceOfFloat32Array; } });
+Object.defineProperty(exports, "createFloat32Array", { enumerable: true, get: function () { return adaptors_1.createFloat32Array; } });
+const plugin_line_strip_1 = __importDefault(require("./plugin-line-strip"));
+exports.TimeTracksLineStrip = plugin_line_strip_1.default;
+const adaptors_line_strip_1 = require("./adaptors-line-strip");
+Object.defineProperty(exports, "addCuttingPointLineStrip", { enumerable: true, get: function () { return adaptors_line_strip_1.addCuttingPointLineStrip; } });
+Object.defineProperty(exports, "featuresToLineStringData", { enumerable: true, get: function () { return adaptors_line_strip_1.featuresToLineStringData; } });
+Object.defineProperty(exports, "fillSliceOfFloat32ArrayLineStrip", { enumerable: true, get: function () { return adaptors_line_strip_1.fillSliceOfFloat32ArrayLineStrip; } });
+Object.defineProperty(exports, "latLongToPixelXY", { enumerable: true, get: function () { return adaptors_line_strip_1.latLongToPixelXY; } });