@pirireis/webglobeplugins 0.15.35 → 0.16.0

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

@@ -0,0 +1,121 @@
+import { PointHeatmapFlow } from "./point-to-heat-map-flow";
+import { createWorker } from "../util/interpolation/timetrack/index";
+import { createTexture, getColorRampModed } from "../util";
+import { opacityCheck, constraintFloat } from "../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;
+        this.timeTrackInterpolationWorker = 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 PointHeatmapFlow(globe);
+        this.setGeometry();
+        this.resize();
+    }
+    setPointSize(pointSize) {
+        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 = getColorRampModed(values, thresholds, mode);
+        const texture = 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) {
+            if (this._isFreed)
+                return;
+            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) {
+        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._legendTexture = null;
+        this.timeTrackInterpolationWorker.terminate();
+        this.timeTrackInterpolationWorker = null;
+    }
+}
+export { PointHeatmapPlugin };

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

@@ -0,0 +1,124 @@
+import { densityToLegendProgramCache } from "../programs/data2legend/density-to-legend";
+import { pointToDensityTextureCache } from "../programs/data2legend/point-to-density-texture";
+// import { textureOnCanvasProgramCache } from "../util/programs/draw-texture-on-canvas";
+import { defaultblendfunction } from "../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 = pointToDensityTextureCache.get(globe);
+        this.densityToLegendProgram = 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);
+        }
+        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;
+        densityToLegendProgramCache.release(this.globe);
+        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);
+    }
+}
+export { PointHeatmapFlow };

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

@@ -0,0 +1,2 @@
+const pointKeyMeyhod = (trackId, pointID) => `${trackId}-${pointID}`;
+export { pointKeyMeyhod };

package/dist/point-tracks/plugin.js

@@ -0,0 +1,393 @@
+import { BufferOrchestrator, BufferManager, ObjectStore } from "../util/account/index";
+import { PickerDisplayer } from "../util/picking/picker-displayer";
+import { PointOnGlobeProgramCache } from "../programs/point-on-globe/square-pixel-point";
+import { wgs84ToCartesian3d, wgs84ToMercator } from "../Math/methods";
+const _0vec3 = /* @__PURE__ */ [0, 0, 0];
+/**
+ * @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, objectStoreExtraParameters = ["long", "lat", "height"], initialCapacity = 1000 } = {}) {
+        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 ? opacity : 1.0;
+        this.program = null;
+        this._lastWH = { w: 0, h: 0 };
+        this._focusParams = { on: false, length: 0, elementBuffer: null, trackIDs: [] };
+        this.pointSizes = {
+            pointSize: pointSize ? pointSize : 2,
+            selectionPointFilling: selectionPointFilling ? selectionPointFilling : 4,
+            hoveredPointSize: hoveredPointSize ? hoveredPointSize : 4
+        };
+        this._objectStoreExtraParameters = objectStoreExtraParameters ? objectStoreExtraParameters : [];
+        this._objectStoreExtraParametersFiltered = objectStoreExtraParameters.filter(param => {
+            return !["long", "lat", "height", "ID", "trackID"].includes(param);
+        });
+        this._bufferOrchestrator = new BufferOrchestrator({ capacity: initialCapacity ? initialCapacity : 1000 });
+    }
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this._pickerDisplayer = new PickerDisplayer(globe);
+        this._pointProgram = PointOnGlobeProgramCache.get(globe);
+        this._focusParams.elementBuffer = gl.createBuffer();
+        this._initBufferManagers();
+    }
+    _initBufferManagers() {
+        const { gl } = this;
+        const initialCapacity = this._bufferOrchestrator.capacity;
+        const bufferType = "DYNAMIC_DRAW";
+        this._bufferManagersMap = new Map([
+            ["pos3D", {
+                    bufferManager: new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                    adaptor: (item) => {
+                        wgs84ToCartesian3d(_0vec3, item.long, item.lat, item.height / 1000); // height is in meters
+                        return new Float32Array(_0vec3); // height is in meters
+                    }
+                }],
+            ["pos2D", {
+                    bufferManager: new BufferManager(gl, 2, { bufferType, initialCapacity }),
+                    adaptor: (item) => new Float32Array(wgs84ToMercator(item.long, item.lat))
+                }],
+            ["rgba", {
+                    bufferManager: new BufferManager(gl, 4, { bufferType, initialCapacity }),
+                    adaptor: (item) => item.rgba
+                }],
+            ["objectStore", {
+                    bufferManager: new ObjectStore({ initialCapacity }),
+                    adaptor: (item) => {
+                        const result = {
+                            trackID: item.trackID,
+                            pointID: item.pointID,
+                        };
+                        // Add extra parameters specified in _objectStoreExtraParameters
+                        this._objectStoreExtraParameters.forEach(param => {
+                            if (item.hasOwnProperty(param)) {
+                                result[param] = item[param];
+                            }
+                        });
+                        return result;
+                    }
+                }]
+        ]);
+        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) {
+        this.pointSizes.pointSize = size;
+        this.globe?.DrawRender();
+    }
+    setSelectionPointFilling(size) {
+        this.pointSizes.selectionPointFilling = size;
+        this.globe?.DrawRender();
+    }
+    setHoveredPointSize(size) {
+        this.pointSizes.hoveredPointSize = size;
+        this.globe?.DrawRender();
+    }
+    setOpacity(opacity) {
+        if (opacity < 0 || opacity > 1)
+            return;
+        this._opacity = opacity;
+        this.globe?.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) {
+        this._fillTracksToPointsMap(tracks);
+        const flattenedPoints = tracks.map(track => trackToFlatPoints(track, this._objectStoreExtraParametersFiltered)).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();
+        this.globe?.DrawRender();
+    }
+    flush() {
+        const capacity = 100;
+        this._bufferOrchestrator?.flush({ capacity });
+        this._bufferManagersMap.forEach(({ bufferManager }) => bufferManager.resetWithCapacity(capacity));
+        this._turnOffFocus();
+        this._tracksToPointsMap.clear();
+        this.globe?.DrawRender();
+    }
+    /**
+     * @param {string} trackID
+     */
+    deleteTrack(trackID) {
+        const pointList = this._tracksToPointsMap.get(trackID);
+        if (!pointList) {
+            console.warn(`Track with ID ${trackID} does not exist.`);
+            return;
+        }
+        ;
+        const points = Array.from(pointList);
+        const { _bufferOrchestrator, _bufferManagersMap } = this;
+        _bufferOrchestrator.deleteBulk(points.map((pointID) => keyMethod(trackID, pointID)), _bufferManagersMap);
+        this._tracksToPointsMap.delete(trackID);
+        this._redraw = true;
+        this._refillFocus();
+        this.globe?.DrawRender();
+    }
+    /**
+     * @param {string} trackID
+     * @param {Array<string>} pointIDs
+     */
+    deletePoints(trackID, pointIDs) {
+        const { _bufferOrchestrator, _bufferManagersMap } = this;
+        _bufferOrchestrator.deleteBulk(pointIDs.map((pointID) => keyMethod(trackID, pointID)), _bufferManagersMap);
+        this._deletePointsFromTracksMap(trackID, pointIDs);
+        this._refillFocus();
+        this.globe?.DrawRender();
+    }
+    focusTracks(trackIDs = null) {
+        if (!this.globe)
+            return;
+        if (!trackIDs) {
+            this._focusParams.on = false;
+            this.globe?.DrawRender();
+            return;
+        }
+        this._focusParams.on = this._fillElementBuffer(trackIDs);
+        if (!this._focusParams.on) {
+            this._turnOffFocus();
+        }
+        this.globe.DrawRender();
+    }
+    updateTrackColor(trackID, rgba) {
+        if (!this._tracksToPointsMap.has(trackID)) {
+            console.warn(`Track with ID ${trackID} does not exist.`);
+            return;
+        }
+        const pointList = this._tracksToPointsMap.get(trackID);
+        const points = Array.from(pointList);
+        const { _bufferOrchestrator, _bufferManagersMap } = this;
+        _bufferOrchestrator.updateBulk(points.map((pointID) => {
+            return {
+                key: keyMethod(trackID, pointID),
+                rgba: new Float32Array(rgba)
+            };
+        }), _bufferManagersMap, ["rgba"]);
+        this._refillFocus();
+        this.globe?.DrawRender();
+    }
+    // GLOBE API METHODS
+    free() {
+        if (this._isFreed)
+            return;
+        this._isFreed = true;
+        this._pickerDisplayer.free();
+        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;
+        if (!gl) {
+            throw new Error("GL is not loaded, PointTracks Plugin");
+        }
+        if (this._isFreed) {
+            throw new Error("Plugin is unregistered, PointTracks Plugin");
+        }
+        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() {
+        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();
+        this.globe?.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;
+                if (!pointSet.has(pointID)) {
+                    pointSet.add(pointID);
+                }
+                else {
+                    console.warn(`Point with ID ${pointID} already exists in track ${trackID}. Skipping duplicate.`);
+                }
+            }
+        }
+    }
+    _refillFocus() {
+        if (this._focusParams.on) {
+            this.focusTracks(this._focusParams.trackIDs);
+        }
+    }
+    _deletePointsFromTracksMap(trackID, pointIDs) {
+        const trackIDs = this._tracksToPointsMap.get(trackID);
+        if (trackIDs === undefined) {
+            console.warn(`Track with ID ${trackID} not found.`);
+            return;
+        }
+        for (const pointID of pointIDs) {
+            if (!trackIDs.has(pointID)) {
+                console.warn(`Point with ID ${pointID} not found in track ${trackID}.`);
+            }
+            else {
+                trackIDs.delete(pointID);
+            }
+        }
+        if (trackIDs.size === 0) {
+            this._tracksToPointsMap.delete(trackID);
+        }
+    }
+    _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 pointList = this._tracksToPointsMap.get(trackID);
+            if (!pointList)
+                continue;
+            foundTracks.push(trackID);
+            for (const pointID of pointList) {
+                const key = keyMethod(trackID, pointID);
+                const index = this._bufferOrchestrator.offsetMap.get(key);
+                if (index === undefined) {
+                    throw new Error;
+                }
+                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;
+    }
+}
+const trackToFlatPoints = (track, extraParameters) => {
+    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
+        });
+        for (let i = 0; i < extraParameters.length; i++) {
+            const param = extraParameters[i];
+            if (point.hasOwnProperty(param)) {
+                flatPoints[flatPoints.length - 1][param] = point[param];
+            }
+        }
+    }
+    return flatPoints;
+};
+const keyMethod = (trackID, pointID) => `${trackID}_${pointID}`;
+export { PointTracksPlugin, keyMethod };

package/dist/programs/arrowfield/index.js

@@ -0,0 +1,2 @@
+import ArrowField from './object';
+export default ArrowField;