@pirireis/webglobeplugins 0.9.6 → 0.9.7

package/shape-on-terrain/arc/naive/plugin.ts

@@ -1,304 +0,0 @@
-// 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/shape-on-terrain/goal.md

@@ -1,12 +0,0 @@
-The fact that a straight line have two points, lacks the ability to cover elevation data on higher zoom levels.
-
-The purpose of this subplugin is to adapt the straight line to the terrain.
-
-
-### Steps
-
-- filter by bbox with tree -> indexes
-- find intersaction. Also filters in a more precise way then bbox. -> index and 2 points. 3d carteasian so it can be used on slerp.
-- Populate the line points -> Array<lat long>
-- 3d cartesian coords with globe api
-

package/tests/Math/junction/arc-plane.test.ts

@@ -1,133 +0,0 @@
-import { Plane, Line, Vec3, Quaternion, Arc } from '../../../Math/types';
-import { plane } from '../../../Math/plane';
-import { line } from '../../../Math/line';
-import { arc } from '../../../Math/arc';
-import { vec3 } from '../../../Math/vec3';
-import { quaternion } from '../../../Math/quaternion';
-import { planePlaneJuction } from '../../../Math/juction/plane-plane';
-import { arcSlice } from '../../../Math/juction/arc-plane';
-import { EPSILON } from '../../../Math/constants';
-
-
-const arcIn = arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-const arcOut: [Arc, Arc] = [
-    arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0)),
-    arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0))
-];
-const arcExpected = arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-const junctionPlane = plane.create(vec3.create(0, 0, 1), 0);
-
-const r2 = Math.sqrt(2) / 2;
-const r3 = Math.sqrt(3) / 3;
-
-beforeAll(() => {
-    // Initialize any necessary data or state before running the tests
-    arc.set(arcIn, vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-    arc.set(arcOut[0], vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-    arc.set(arcOut[1], vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-
-    plane.set(junctionPlane, vec3.create(0, 0, 1), 0);
-
-});
-
-
-
-
-
-test('arcSlice - No intersection 1', () => {
-    junctionPlane.distance = 2; // Set distance to ensure no intersection
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(false);
-});
-
-
-
-test('arcSlice - Full intersection 1', () => {
-    junctionPlane.distance = 0; // Set distance to ensure full intersection
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(true);
-    const isEqual = arc.equals(arcOut[0], arcExpected);
-    expect(isEqual).toBe(true);
-});
-
-
-test('arcSlice-1', () => {
-    // Set up a case where the arc intersects with the plane
-
-
-    const r3 = Math.sqrt(3);
-    const juctionNormal = vec3.create(r3, r3, r3);
-
-    plane.set(junctionPlane, juctionNormal, 0);
-
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(true);
-});
-
-
-test('arcSlice - Plane intersection line is out of sphere', () => {
-    // Set up a case where the arc intersects with the plane
-
-    const point1 = vec3.create(0, 1, 0);
-    const point2 = vec3.create(0, 0, 1);
-    arc.set(arcIn, point1, point2);
-
-    const juctionNormal = vec3.create(r3, r3, r3);
-
-    const closestPoint = vec3.create(r2, r2, 0);
-    const distance = vec3.dot(juctionNormal, closestPoint) + EPSILON;
-    plane.set(junctionPlane, juctionNormal, distance);
-
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(false);
-});
-
-
-test("arcSlice - Planes are parallel", () => {
-
-    const point1 = vec3.create(0, 1, 0);
-    const point2 = vec3.create(0, 0, 1);
-    arc.set(arcIn, point1, point2);
-
-    plane.fromValues(junctionPlane, 1, 0, 0, 0.3); // Set a plane parallel to the arc's normal
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(false); // Expect no intersection
-
-    junctionPlane.distance = -0.3;
-
-    const result2 = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result2).toBe(true); // Expect no intersection
-    const isEqual = arc.equals(arcOut[0], arcIn);
-    expect(isEqual).toBe(true); // Expect the output arc to be equal to the input arc
-});
-
-
-test("arcSlice - Arc sliced in half", () => {
-
-    const point1 = vec3.create(0, 1, 0);
-    const point2 = vec3.create(0, 0, 1);
-    arc.set(arcIn, point1, point2);
-
-    expect(vec3.equals(arcIn.normal, vec3.create(1, 0, 0))).toBe(true); // Arc normal should be (1, 0, 0)
-
-    plane.fromValues(junctionPlane, 0, -r2, r2, 0); // Set a plane parallel to the arc's normal
-
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(true); // Expect an intersection
-    const expectedPoint1 = vec3.create(0, r2, r2);
-    const expectedPoint2 = vec3.create(0, 0, 1);
-    arc.set(arcExpected, expectedPoint1, expectedPoint2);
-    const isEqual = arc.equals(arcOut[0], arcExpected);
-    expect(isEqual).toBe(true); // Expect the output arc to be equal to the expected arc
-});
-
-
-// test("arcSlice - Arc sliced in middle", () => {
-//     const point1 = vec3.create(0, 1, 0);
-//     const point2 = vec3.create(0, 0, 1);
-//     arc.set(arcIn, point1, point2);
-
-
-//     plane.fromValues(junctionPlane, 0, r2, r2, )
-
-// });

package/tests/Math/junction/plane-plane.test.ts

@@ -1,82 +0,0 @@
-import { Plane, Line, Vec3, Quaternion } from '../../../Math/types';
-import { plane } from '../../../Math/plane';
-import { line } from '../../../Math/line';
-import { vec3 } from '../../../Math/vec3';
-import { quaternion } from '../../../Math/quaternion';
-import { planePlaneJuction } from '../../../Math/juction/plane-plane';
-
-
-let plane1: Plane;
-let plane2: Plane;
-let intersectionLine: Line;
-let quaternion1: Quaternion;
-
-beforeAll(() => {
-    plane1 = plane.create();
-    plane2 = plane.create();
-    intersectionLine = line.create();
-    quaternion1 = quaternion.create();
-});
-
-
-test('plane-plane intersection - parallel planes', () => {
-    plane.fromValues(plane1, 0, 0, 1, 5); // Plane: z = 5
-    plane.fromValues(plane2, 0, 0, 1, 10); // Plane: z = 10
-    const result = planePlaneJuction(intersectionLine, plane1, plane2);
-    expect(result).toBe(false);
-});
-
-test('plane-plane intersection - intersecting planes', () => {
-    plane.fromValues(plane1, 0, 0, 1, 5); // Plane: z = 5
-    plane.fromValues(plane2, 1, 0, 0, 3); // Plane: x = 3
-
-    const result = planePlaneJuction(intersectionLine, plane1, plane2);
-    expect(result).toBe(true);
-    expect(vec3.equals(intersectionLine.direction, vec3.create(0, 1, 0))).toBe(true);
-    expect(vec3.equals(intersectionLine.origin, vec3.create(3, 0, 5))).toBe(true);
-});
-
-
-test('plane-plane intersection - rotating a plane', () => {
-    // plane1 z = 5
-    plane.fromValues(plane1, 0, 0, 1, 5);
-
-    // plane2 x = 3, for the start
-    vec3.randomUnit(plane2.normal);
-    plane2.distance = 3;
-
-    const result = planePlaneJuction(intersectionLine, plane1, plane2);
-    expect(result).toBe(true);
-    const quaRotateLine = line.clone(intersectionLine);
-
-    const step = 90;
-    quaternion.fromAxisAngle(quaternion1, plane1.normal, Math.PI / step); // Rotate 90 degrees around Y-axis
-
-
-    for (let i = 0; i < step; i++) {
-
-        vec3.applyQuaternion(plane2.normal, plane2.normal, quaternion1);
-
-        const result = planePlaneJuction(intersectionLine, plane1, plane2);
-
-
-        line.applyQuaternion(quaRotateLine, quaRotateLine, quaternion1);
-
-        expect(result).toBe(true);
-        expect(vec3.equals(intersectionLine.direction, quaRotateLine.direction)).toBe(true);
-        expect(line.contains(intersectionLine, quaRotateLine.origin)).toBe(true);
-    }
-});
-
-test("plane-plane intersection 1", () => {
-    const r2 = Math.sqrt(2) / 2;
-    plane.fromValues(plane1, 1, 0, 0, 0);
-    plane.fromValues(plane2, 0, -r2, r2, 0);
-    const result = planePlaneJuction(intersectionLine, plane1, plane2);
-
-    expect(result).toBe(true);
-    console.log(intersectionLine);
-    expect(vec3.equals(intersectionLine.direction, vec3.create(0, r2, r2)) || vec3.equals(intersectionLine.direction, vec3.create(0, -r2, -r2))
-    ).toBe(true);
-    expect(line.contains(intersectionLine, vec3.create(0, 0, 0))).toBe(true);
-});

package/tests/Math/plane.test.ts

@@ -1,43 +0,0 @@
-import { Plane, Vec3 } from "../../Math/types";
-import { vec3 } from "../../Math/vec3";
-import { plane } from "../../Math/plane";
-
-
-const _planeA = /*@__PURE__*/ plane.create(vec3.create(1, 0, 0), 0);
-const _planeB = /*@__PURE__*/ plane.create(vec3.create(0, 1, 0), 0);
-const _vecA = /*@__PURE__*/ vec3.create(1, 0, 0);
-
-beforeAll(() => {
-    vec3.set(_vecA, 1, 0, 0);
-    plane.set(_planeA, vec3.create(1, 0, 0), 0);
-    plane.set(_planeB, vec3.create(0, 1, 0), 0);
-});
-
-test("Plane: getUnitSphereRadiusAngle", () => {
-    const angleA = plane.getUnitSphereRadiusAngle(_planeA);
-    const angleB = plane.getUnitSphereRadiusAngle(_planeB);
-
-    expect(angleA).toBeCloseTo(Math.PI / 2, 5); // 90 degrees
-    expect(angleB).toBeCloseTo(Math.PI / 2, 5); // 90 degrees
-});
-
-
-test("Plane: getUnitSphereRadiusAngle 1", () => {
-
-    vec3.set(_vecA, 1, 1, 0);
-    vec3.normalize(_vecA, _vecA);
-    const distance = Math.sqrt(2) / 2; // Distance from origin to the plane
-    plane.set(_planeA, _vecA, distance);
-    const angleA = plane.getUnitSphereRadiusAngle(_planeA);
-    expect(angleA).toBeCloseTo(Math.PI / 4, 5); // 45 degrees
-
-    for (let i = 0; i < 100; i++) {
-        const distance = Math.random();
-
-        const angle = Math.acos(distance);
-        vec3.randomUnit(_vecA)
-        plane.set(_planeA, _vecA, distance);
-        const angleA = plane.getUnitSphereRadiusAngle(_planeA);
-        expect(angleA).toBeCloseTo(angle, 5); // Check if the angle is close to the expected value
-    }
-});  

package/tests/Math/vec3.test.ts

@@ -1,14 +0,0 @@
-import { Vec3 } from "../../Math/types";
-import { vec3 } from "../../Math/vec3";
-
-test("vec3.create", () => {
-    const v = vec3.create(1, 2, 3);
-    expect(v).toEqual([1, 2, 3]);
-});
-
-
-test("vec3.length", () => {
-    const v = vec3.create(3, 4, 0);
-    const length = vec3.length(v);
-    expect(length).toBe(5);
-});

package/timetracks/adaptors-line-strip.js

@@ -1,80 +0,0 @@
-import { latLongToPixelXY } from "../util";
-
-
-
-/**
- * @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 } = 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;
-}
-
-
-
-
-
-export { addCuttingPointLineStrip, featuresToLineStringData, fillSliceOfFloat32ArrayLineStrip, latLongToPixelXY };