@pirireis/webglobeplugins 0.9.7 → 0.9.8

package/dist/point-heat-map/adaptors/timetracksplugin-format-to-this.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @typedef {Float32Array} TimeTrackMultiColorData  | A linestring is representation, let A{a1, a2, a3}, B{b1, b2} be the points of the line.
+     * TimeTrackMultiColorData is [
+     *  a1x, a1y, a1z, a1time, a1r, a1g, a1b, a1time, a3time,
+     *  a2x, a2y, a2z, a2time, a2r, a2g, a2b, a1time, a3time,
+     *  a3x, a3y, a3z, a3time, a3r, a3g, a3b, a1time, a3time,
+     *  0, 0, 0, 0, -1, -1, -1, 0, 0,
+     *  b1x, b1y, b1z, b1time, b1r, b1g, b1b, b1time, b2time,
+     *  b2x, b2y, b2z, b2time, b2r, b2g, b2b, BstartTime, BendTime
+     * ]
+     * there is a cutting point between A and B
+     *
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeTrackPluginDataToPointHeatInterpolatorAdapter = void 0;
+/**
+ * ABOVE
+ *  TO
+ * BELOW
+
+/**
+ * @typedef {Array<number>} vec3 [x, y, z]
+ * @typedef {Array<number>} vec2 [x, y]
+ * @typedef {Array<number>} vec4 [x, y, z, w]
+ * @typedef {number} fraction a number between 0 and 1
+ * @typedef {Array<number>} wgs84 [long, lat]
+ */
+/**
+ * @typedef Timetrack
+ * @property {Array<vec4>}} coordinates [x,y,z, length]
+ * @property {Array<Number>} times
+ * @param {Array<Timetrack>} timeTracks
+ */
+const methods_1 = require("../../Math/methods");
+const processACut = (array, offset) => {
+    // first 3 values of array
+    const v3 = array.slice(offset, offset + 3);
+    const v4 = (0, methods_1.pixelXYLenghtToUnitVectorWithHeight)(v3);
+    const time = array[offset + 3];
+    return [v4, time];
+};
+const timeTrackPluginDataToPointHeatInterpolatorAdapter = (timeTrackPluginData) => {
+    const timeTracks = [];
+    let offset = 0;
+    let timeTrack = {
+        coordinates: [],
+        times: []
+    };
+    while (offset < timeTrackPluginData.length) {
+        if (!timeTrackPluginData[offset]) {
+            timeTracks.push(timeTrack);
+            timeTrack = {
+                coordinates: [],
+                times: []
+            };
+            offset += 9;
+        }
+        const point = processACut(timeTrackPluginData, offset);
+        offset += 9;
+        timeTrack.coordinates.push(point[0]);
+        timeTrack.times.push(point[1]);
+    }
+    return timeTracks;
+};
+exports.timeTrackPluginDataToPointHeatInterpolatorAdapter = timeTrackPluginDataToPointHeatInterpolatorAdapter;

package/dist/point-heat-map/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/point-heat-map/plugin-webworker.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointHeatmapPlugin = void 0;
+const point_to_heat_map_flow_1 = require("./point-to-heat-map-flow");
+// import { webworkerStr } from "../util/interpolation/timetrack/web-worker-str"; // TODO: Delete When this plugin is tested on production
+const index_1 = require("../util/interpolation/timetrack/index");
+const util_1 = require("../util");
+const typecheck_1 = require("../util/check/typecheck");
+class PointHeatmapPlugin {
+    constructor(id, { opacity = 1.0, pointSize = 5.0, onInterpolationComplete = () => { } } = {}) {
+        this.id = id;
+        this.globe = null;
+        this.gl = null;
+        this.densityToLegendProgram = null;
+        this._time = null;
+        this._opacity = opacity;
+        this._pointSize = pointSize;
+        this._legendTexture = null;
+        this._throttleListener = null;
+        this._timeTracksAreSet = false;
+        // const blob = new Blob([webworkerStr], { type: 'application/javascript' });
+        // this.timeTrackInterpolationWorker = new Worker(URL.createObjectURL(blob), { type: 'module' });
+        this.timeTrackInterpolationWorker = (0, index_1.createWorker)();
+        this.timeTrackInterpolationWorker.onmessage = (e) => {
+            if (e.data.error) {
+                throw new Error(e.data.error);
+            }
+            if (e.data === true) {
+                onInterpolationComplete();
+            }
+            if (e.data instanceof Float32Array) {
+                this.flow.setData(e.data);
+                this._throttleListener = null;
+                onInterpolationComplete();
+            }
+        };
+    }
+    // globe interaction
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this.flow = new point_to_heat_map_flow_1.PointHeatmapFlow(globe);
+        this.setGeometry();
+        this.resize();
+    }
+    setPointSize(pointSize) {
+        (0, typecheck_1.constraintFloat)(pointSize, 1);
+        this._pointSize = pointSize;
+        this.globe.DrawRender();
+    }
+    /**
+     * @param {Array<string>}
+     * @param {string} mode "interpolated" | "discrete"
+     */
+    setColorRamp(values, thresholds, mode = "interpolated") {
+        const gl = this.gl;
+        if (this.gl === null) {
+            throw new Error('Plugin not initialized');
+        }
+        ;
+        const rampData = (0, util_1.getColorRampModed)(values, thresholds, mode);
+        const texture = (0, util_1.createTexture)(gl, gl.LINEAR, rampData, 256, 1);
+        if (this._legendTexture) {
+            this.gl.deleteTexture(this._legendTexture);
+        }
+        this._legendTexture = texture;
+        this.globe.DrawRender();
+    }
+    setTime(time) {
+        // TODO: WORK ON THIS
+        this._time = time;
+        if (this.isReady() && this._throttleListener === null) {
+            this._throttleListener = setTimeout(() => {
+                this.timeTrackInterpolationWorker.postMessage({ time: this._time });
+            }, 0);
+        }
+    }
+    setTimetracks(timeTracks) {
+        this._timeTracksAreSet = true;
+        this.timeTrackInterpolationWorker.postMessage({ timeTracks });
+        if (this._time !== null) {
+            this.setTime(this._time);
+        }
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        (0, typecheck_1.opacityCheck)(opacity);
+        this._opacity = opacity;
+        this.globe.DrawRender();
+    }
+    setGeometry() {
+        const geometry = this.globe.api_GetCurrentGeometry();
+        this.timeTrackInterpolationWorker.postMessage({ geometry });
+        if (this._time !== null) {
+            this.setTime(this._time);
+        }
+    }
+    draw3D() {
+        if (this.isReady()) {
+            this.flow.draw(this._legendTexture, this._pointSize, this._opacity);
+        }
+    }
+    resize() {
+        this.flow.resize();
+        if (this._time !== null) {
+            this.setTime(this._time);
+        }
+    }
+    isReady() {
+        return (this.gl !== null && this._legendTexture !== null && this._timeTracksAreSet);
+    }
+    free() {
+        if (this._isFreed)
+            return;
+        this.gl.deleteTexture(this._legendTexture);
+        this.flow.free();
+        this.flow = null;
+        this.gl = null;
+        this._isFreed = true;
+        this.timeTrackInterpolator = null;
+        this._legendTexture = null;
+        this.timeTrackInterpolationWorker.terminate();
+        this.timeTrackInterpolationWorker = null;
+    }
+}
+exports.PointHeatmapPlugin = PointHeatmapPlugin;

package/dist/point-heat-map/point-to-heat-map-flow.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointHeatmapFlow = void 0;
+const density_to_legend_1 = require("../programs/data2legend/density-to-legend");
+const point_to_density_texture_1 = require("../programs/data2legend/point-to-density-texture");
+// import { textureOnCanvasProgramCache } from "../util/programs/draw-texture-on-canvas";
+const gldefaultstates_1 = require("../util/webglobe/gldefaultstates");
+class PointHeatmapFlow {
+    constructor(globe) {
+        this.globe = null;
+        this.gl = null;
+        this.program = null;
+        this.densityToLegendProgram = null;
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.pointToDensityProgram = point_to_density_texture_1.pointToDensityTextureCache.get(globe);
+        this.densityToLegendProgram = density_to_legend_1.densityToLegendProgramCache.get(globe);
+        // this.testTextureProgram = textureOnCanvasProgramCache.get(globe.gl);
+        this._lookInfo = globe.api_GetCurrentLookInfo();
+        const { gl } = this;
+        {
+            this.buffer = gl.createBuffer();
+            this.vao2D = this.pointToDensityProgram.createVAO(this.buffer, 2);
+            this.vao3D = this.pointToDensityProgram.createVAO(this.buffer, 3);
+        }
+        { // framebuffer and texture
+            this.framebuffer = gl.createFramebuffer();
+            this.densityTexture = this._createDensityTexture();
+            this._bindTextureToFramebuffer();
+        }
+    }
+    _bindTextureToFramebuffer() {
+        const { gl, densityTexture, framebuffer } = this;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, densityTexture, 0);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    }
+    draw(legendTexture, pointSize, opacity = 1.0) {
+        const { gl, globe, framebuffer } = this;
+        if (this._drawDensityRequired || this._isVisionChanged()) {
+            gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+            gl.clearColor(0, 0, 0, 0);
+            gl.viewport(0, 0, Math.floor(globe.api_ScrW()), Math.floor(globe.api_ScrH()));
+            gl.clear(gl.COLOR_BUFFER_BIT);
+            this._drawDensity(pointSize);
+            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        }
+        (0, gldefaultstates_1.defaultblendfunction)(gl);
+        this._drawLegend(legendTexture, opacity);
+    }
+    resize() {
+        const { gl, densityTexture } = this;
+        gl.deleteTexture(densityTexture);
+        this.densityTexture = this._createDensityTexture();
+        this._bindTextureToFramebuffer();
+        this._drawDensityRequired = true;
+    }
+    // USER API
+    /**
+     * @param {Float32Array} data
+     * @format [x, y, z, height] x,y,z is normalized 3d cartesian coordinates. Height in kilometers. Set 6378.137 for ground level.
+     */
+    setData(data) {
+        const { gl, buffer } = this;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+        // use program
+        this.dataLength = data.length;
+        this._drawDensityRequired = true;
+        this.globe.DrawRender();
+    }
+    // implicit Methods
+    _createDensityTexture() {
+        const { gl, globe } = this;
+        const width = Math.floor(globe.api_ScrW());
+        const height = Math.floor(globe.api_ScrH());
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        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);
+        return texture;
+    }
+    _drawDensity(pointSize) {
+        const { gl, globe, pointToDensityProgram, vao2D, vao3D, dataLength } = this;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        const vao = is3D ? vao3D : vao2D;
+        const length = dataLength / (is3D ? 3 : 2);
+        gl.blendEquation(gl.FUNC_ADD);
+        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE, gl.SRC_ALPHA, gl.ONE);
+        pointToDensityProgram.draw(vao, length, pointSize);
+        this._drawDensityRequired = false;
+    }
+    _drawLegend(legendTexture, opacity) {
+        const { densityToLegendProgram, densityTexture } = this;
+        densityToLegendProgram.draw(densityTexture, legendTexture, opacity);
+    }
+    _isVisionChanged() {
+        const currentLookInfo = this.globe.api_GetCurrentLookInfo();
+        const _lookInfo = this._lookInfo;
+        if (currentLookInfo.CenterLong !== _lookInfo.CenterLong ||
+            currentLookInfo.CenterLat !== _lookInfo.CenterLat ||
+            currentLookInfo.Distance !== _lookInfo.Distance ||
+            currentLookInfo.Tilt !== _lookInfo.Tilt ||
+            currentLookInfo.NorthAng !== _lookInfo.NorthAng) {
+            this._lookInfo = currentLookInfo;
+            return true;
+        }
+        return false;
+    }
+    free() {
+        if (this._isFreed)
+            return;
+        this._isFreed = true;
+        density_to_legend_1.densityToLegendProgramCache.release(this.globe);
+        point_to_density_texture_1.pointToDensityTextureCache.release(this.globe);
+        // textureOnCanvasProgramCache.release(this.gl);
+        this.gl.deleteTexture(this.densityTexture);
+        this.gl.deleteFramebuffer(this.framebuffer);
+        this.gl.deleteBuffer(this.buffer);
+        this.gl.deleteVertexArray(this.vao2D);
+        this.gl.deleteVertexArray(this.vao3D);
+    }
+}
+exports.PointHeatmapFlow = PointHeatmapFlow;

package/dist/point-tracks/key-methods.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointKeyMeyhod = void 0;
+const pointKeyMeyhod = (trackId, pointID) => `${trackId}-${pointID}`;
+exports.pointKeyMeyhod = pointKeyMeyhod;

package/dist/point-tracks/plugin.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyMethod = exports.PointTracksPlugin = void 0;
+const account_1 = require("../util/account");
+const picker_displayer_1 = require("../util/picking/picker-displayer");
+const square_pixel_point_1 = require("../programs/point-on-globe/square-pixel-point");
+const methods_1 = require("../Math/methods");
+/**
+ * @typedef {number} long
+ * @typedef {number} lat
+ * @typedef {number} height
+ * @typedef {string} ID
+ * @typedef {string} trackID
+ * @typedef {[number, number, number, number]} rgba 0-1
+ * @typedef { long ,lat, height, ID } Point
+ * @typedef {Array<Point>, rgba, trackID} Track
+ */
+class PointTracksPlugin {
+    constructor(id, { pointSize = 2, hoveredPointSize = 4, selectionPointFilling = 4, opacity = 1.0 } = {}) {
+        this.id = id;
+        this._isFreed = false;
+        this._pointProgram = null;
+        this._vao = null;
+        this._bufferManagersMap = null;
+        this._bufferOrchestrator = null;
+        this._pickerDisplayer = null;
+        this._selectedID = -1;
+        this._selectedObj = null;
+        this._tracksToPointsMap = new Map(); // one to many
+        this._opacity = opacity;
+        this.program = null;
+        this._lastWH = { w: 0, h: 0 };
+        this._focusParams = { on: false, length: 0, elementBuffer: null, trackIDs: [] };
+        this.pointSizes = {
+            pointSize,
+            selectionPointFilling,
+            hoveredPointSize
+        };
+    }
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this._pickerDisplayer = new picker_displayer_1.PickerDisplayer(globe);
+        this._pointProgram = square_pixel_point_1.PointOnGlobeProgramCache.get(globe);
+        this._focusParams.elementBuffer = gl.createBuffer();
+        this._initBufferManagers();
+    }
+    _initBufferManagers() {
+        const { gl } = this;
+        const initialCapacity = 10;
+        const bufferType = "DYNAMIC_DRAW";
+        this._bufferOrchestrator = new account_1.BufferOrchestrator({ initialCapacity });
+        this._bufferManagersMap = new Map([
+            ["pos3D", {
+                    bufferManager: new account_1.BufferManager(gl, 3, { bufferType, initialCapacity }),
+                    adaptor: (item) => new Float32Array((0, methods_1.wgs84ToCartesian3d)(item.long, item.lat, item.height / 1000)) // height is in meters
+                }],
+            ["pos2D", {
+                    bufferManager: new account_1.BufferManager(gl, 2, { bufferType, initialCapacity }),
+                    adaptor: (item) => new Float32Array((0, methods_1.wgs84ToMercator)(item.long, item.lat))
+                }],
+            ["rgba", {
+                    bufferManager: new account_1.BufferManager(gl, 4, { bufferType, initialCapacity }),
+                    adaptor: (item) => item.rgba
+                }],
+            ["objectStore", {
+                    bufferManager: new account_1.ObjectStore({ initialCapacity }),
+                    adaptor: (item) => {
+                        return {
+                            trackID: item.trackID, pointID: item.pointID
+                        };
+                    }
+                }]
+        ]);
+        this._vao = this._pointProgram.createVAO(this._bufferManagersMap.get("pos3D").bufferManager.buffer, this._bufferManagersMap.get("pos2D").bufferManager.buffer, this._bufferManagersMap.get("rgba").bufferManager.buffer);
+    }
+    setPointSize(size) {
+        var _a;
+        this.pointSizes.pointSize = size;
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    }
+    setSelectionPointFilling(size) {
+        var _a;
+        this.pointSizes.selectionPointFilling = size;
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    }
+    setHoveredPointSize(size) {
+        var _a;
+        this.pointSizes.hoveredPointSize = size;
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    }
+    setOpacity(opacity) {
+        var _a;
+        if (opacity < 0 || opacity > 1)
+            return;
+        this._opacity = opacity;
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    }
+    getCurrentSelection() {
+        return this._selectedObj;
+    }
+    /**
+     *
+     * @param {*} x screen x
+     * @param {*} y screen y
+     * @param {*} callback callback on selection
+     */
+    screenSelection(x, y, callback) {
+        const { pointSizes, _pickerDisplayer } = this;
+        const objectStore = this._bufferManagersMap.get("objectStore").bufferManager;
+        const wrapper = (selectedIDsSet) => {
+            const selectedIDs = Array.from(selectedIDsSet);
+            if (selectedIDs.length === 0) {
+                this._selectedObj = null;
+                this._selectedID = -1;
+                callback([]);
+                return;
+            }
+            const selectedPoints = [];
+            for (let i = 0; i < selectedIDs.length; i++) {
+                const id = selectedIDs[i];
+                if (i === 0) {
+                    this._selectedID = id;
+                    this._selectedObj = objectStore.get(id);
+                }
+                const obj = objectStore.get(id);
+                selectedPoints.push(obj);
+            }
+            callback(selectedPoints);
+        };
+        _pickerDisplayer.pickXY(x, y, pointSizes.selectionPointFilling, wrapper);
+    }
+    /**
+     * @param {Array<Track>} tracks
+     * @returns
+     */
+    insertBulk(tracks) {
+        var _a;
+        this._fillTracksToPointsMap(tracks); // TODO error should be at the top
+        const flattenedPoints = tracks.map(trackToFlatPoints).flat();
+        const currentLoad = this._bufferOrchestrator.length;
+        if (currentLoad + flattenedPoints.length >= 2147483647) {
+            throw new Error("Too many points, Point count cannot exceed 2147483647");
+        }
+        const { _bufferManagersMap, _bufferOrchestrator } = this;
+        _bufferOrchestrator.insertBulk(flattenedPoints, _bufferManagersMap);
+        this._refillFocus();
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    }
+    flush() {
+        var _a, _b;
+        const capacity = 100;
+        (_a = this._bufferOrchestrator) === null || _a === void 0 ? void 0 : _a.flush({ capacity });
+        this._bufferManagersMap.forEach(({ bufferManager }) => bufferManager.resetWithCapacity(capacity));
+        this._turnOffFocus();
+        this._tracksToPointsMap.clear();
+        (_b = this.globe) === null || _b === void 0 ? void 0 : _b.DrawRender();
+    }
+    /**
+     * @param {string} trackID
+     */
+    deleteTrack(trackID) {
+        var _a;
+        const pointSet = this._tracksToPointsMap.get(trackID);
+        const points = Array.from(pointSet);
+        const { _bufferOrchestrator, _bufferManagersMap } = this;
+        _bufferOrchestrator.deleteBulk(points.map((pointID) => keyMethod(trackID, pointID)), _bufferManagersMap);
+        this._tracksToPointsMap.delete(trackID);
+        this._redraw = true;
+        this._refillFocus();
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    }
+    /**
+     * @param {string} trackID
+     * @param {Array<string>} pointIDs
+     */
+    deletePoints(trackID, pointIDs) {
+        var _a;
+        const { _bufferOrchestrator, _bufferManagersMap } = this;
+        _bufferOrchestrator.deleteBulk(pointIDs.map((pointID) => keyMethod(trackID, pointID)), _bufferManagersMap);
+        this._deletePointsFromTracksMap(trackID, pointIDs);
+        this._refillFocus();
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    }
+    focusTracks(trackIDs = null) {
+        var _a;
+        if (!this.globe)
+            return;
+        if (!trackIDs) {
+            this._focusParams.on = false;
+            (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+            return;
+        }
+        this._focusParams.on = this._fillElementBuffer(trackIDs);
+        if (!this._focusParams.on) {
+            this._turnOffFocus();
+        }
+        this.globe.DrawRender();
+    }
+    // GLOBE API METHODS
+    free() {
+        if (this._isFreed)
+            return;
+        this._isFreed = true;
+        this._pickerDisplayer.free();
+        square_pixel_point_1.PointOnGlobeProgramCache.release(this.globe);
+        this.gl.deleteBuffer(this._focusParams.elementBuffer);
+        this._bufferManagersMap.forEach(({ bufferManager, adaptor }) => bufferManager.free());
+    }
+    draw3D() {
+        const { gl, _pointProgram, _pickerDisplayer, _bufferOrchestrator, _vao } = this;
+        this.resize();
+        _pickerDisplayer.bindFBO();
+        _pickerDisplayer.clearTextures();
+        if (this._focusParams.on) {
+            _pointProgram.draw(_vao, this._focusParams.length, {
+                hoveredID: this._selectedID,
+                opacity: this._opacity,
+                pointSize: this.pointSizes.pointSize,
+                hoveredPointSize: this.pointSizes.hoveredPointSize,
+                elementBuffer: this._focusParams.elementBuffer
+            });
+        }
+        else {
+            _pointProgram.draw(_vao, _bufferOrchestrator.length, {
+                hoveredID: this._selectedID,
+                opacity: this._opacity,
+                pointSize: this.pointSizes.pointSize,
+                hoveredPointSize: this.pointSizes.hoveredPointSize
+            });
+        }
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        _pickerDisplayer.drawColorTexture();
+        this._selfSelect();
+    }
+    resize() {
+        var _a;
+        const w = this.globe.api_ScrW();
+        const h = this.globe.api_ScrH();
+        if (w === this._lastWH.w && h === this._lastWH.h)
+            return;
+        this._lastWH.w = w;
+        this._lastWH.h = h;
+        this._pickerDisplayer.resize();
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    }
+    // IMPLICIT METHODS
+    _fillTracksToPointsMap(tracks) {
+        for (const track of tracks) {
+            const trackID = track.trackID;
+            const points = track.points;
+            if (!this._tracksToPointsMap.has(trackID)) {
+                this._tracksToPointsMap.set(trackID, new Set());
+            }
+            const pointSet = this._tracksToPointsMap.get(trackID);
+            for (let p = 0; p < points.length; p++) {
+                const pointID = points[p].ID;
+                pointSet.add(pointID);
+            }
+        }
+    }
+    _refillFocus() {
+        if (this._focusParams.on) {
+            this.focusTracks(this._focusParams.trackIDs);
+        }
+    }
+    _deletePointsFromTracksMap(trackID, pointIDs) {
+        const trackSet = this._tracksToPointsMap.get(trackID);
+        for (const pointID of pointIDs) {
+            trackSet.delete(pointID);
+        }
+    }
+    _selfSelect() {
+        const { globe } = this;
+        const pos = globe.api_GetMousePos();
+        const x = pos.canvasX;
+        const y = globe.api_ScrH() - pos.canvasY;
+        this.screenSelection(x, y, (selectedPoints) => {
+        });
+    }
+    _turnOffFocus() {
+        const { gl } = this;
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._focusParams.elementBuffer);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint32Array([]), gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+        this._focusParams.length = 0;
+        this._focusParams.on = false;
+    }
+    _fillElementBuffer(trackIDs) {
+        let length = 0;
+        const indexes = [];
+        const foundTracks = [];
+        for (const trackID of trackIDs) {
+            const pointSet = this._tracksToPointsMap.get(trackID);
+            if (!pointSet)
+                continue;
+            foundTracks.push(trackID);
+            const points = Array.from(pointSet);
+            for (const pointID of points) {
+                const key = keyMethod(trackID, pointID);
+                const index = this._bufferOrchestrator.offsetMap.get(key);
+                indexes.push(index);
+                length++;
+            }
+        }
+        this._focusParams.trackIDs = foundTracks;
+        this._focusParams.length = length;
+        if (length === 0) {
+            return false;
+        }
+        const { gl } = this;
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._focusParams.elementBuffer);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint32Array(indexes), gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+        return true;
+    }
+}
+exports.PointTracksPlugin = PointTracksPlugin;
+const trackToFlatPoints = (track) => {
+    const trackID = track.trackID;
+    const points = track.points;
+    const rgba = new Float32Array(track.rgba);
+    const flatPoints = [];
+    for (const point of points) {
+        flatPoints.push({
+            key: keyMethod(trackID, point.ID),
+            long: point.long,
+            lat: point.lat,
+            height: point.height,
+            pointID: point.ID,
+            rgba,
+            trackID
+        });
+    }
+    return flatPoints;
+};
+const keyMethod = (trackID, pointID) => `${trackID}_${pointID}`;
+exports.keyMethod = keyMethod;

package/dist/programs/arrowfield/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const object_1 = __importDefault(require("./object"));
+exports.default = object_1.default;