@pirireis/webglobeplugins 0.8.15-alpha → 0.8.18

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.8.15-alpha",
+    "version": "0.8.18",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT"

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

@@ -1,5 +1,5 @@
 import { PointHeatmapFlow } from "./point-to-heat-map-flow";
-// import { webworkerStr } from "../util/interpolation/timetrack/web-worker-str";
+// import { webworkerStr } from "../util/interpolation/timetrack/web-worker-str"; // TODO: Delete When this plugin is tested on production
 import { createWorker } from "../util/interpolation/timetrack/index";
 import { createTexture, getColorRampModed } from "../util";
 import { opacityCheck, constraintFloat } from "../util/check/typecheck";

package/programs/line-on-globe/circle-accurate-flat.js

@@ -6,6 +6,7 @@ import {
     mercatorXYToGLPosition, POLE
 } from "../../util/shaderfunctions/geometrytransformations";
 
+const Pole = 20037508.34;
 /**
 * Warning:
 * Insert the points from the second index and skip 1 point as you placed 361 points
@@ -204,9 +205,20 @@ function centerCoords2dflatDataCreator(globe, centerLong, centerLat, targetLong,
         360 / (edgeCount - 2), // 1 for return to start point, 1 for cutting circles
     );
 
+    let lastlg = pointsLongLat[0].long;
+    let lastlt = pointsLongLat[0].lat;
+
     for (let i = 1; i < edgeCount; i++) {
         const { long: lg, lat: lt } = pointsLongLat[i - 1];
-        centerCoords2dflat.set(globe.api_GetMercator2DPoint(lg, lt), i * 2);
+        if (manhattanDistance(lastlg, lastlt, lg, lt) < 170) {
+            centerCoords2dflat.set(
+                globe.api_GetMercator2DPoint(lg, lt)
+                , i * 2);
+        } else {
+            centerCoords2dflat.set([NaN, NaN], i * 2);
+        }
+        lastlg = lg;
+        lastlt = lt;
     }
     return centerCoords2dflat;
 }
@@ -227,9 +239,11 @@ function centerCoords2dflatDataCreatorWithRadius(globe, centerLong, centerLat, r
     for (let i = 1; i < edgeCount; i++) {
         const { long: lg, lat: lt } = pointsLongLat[i - 1];
         if (manhattanDistance(lastlg, lastlt, lg, lt) < 170) {
-            centerCoords2dflat.set(globe.api_GetMercator2DPoint(lg, lt), i * 2);
+            centerCoords2dflat.set(
+                globe.api_GetMercator2DPoint(lg, lt)
+                , i * 2);
         } else {
-            centerCoords2dflat.set([ESCAPE_VALUE, ESCAPE_VALUE], i * 2);
+            centerCoords2dflat.set([NaN, NaN], i * 2);
         }
         lastlg = lg;
         lastlt = lt;
@@ -242,6 +256,7 @@ function manhattanDistance(x1, y1, x2, y2) {
     return Math.max(Math.abs(x1 - x2), Math.abs(y1 - y2));
 }
 
+
 export {
     CircleCache, EDGE_COUNT, centerCoords2dflatDataCreator, centerCoords2dflatDataCreatorWithRadius
 }

package/rangerings/rangeringangletext.js

@@ -48,6 +48,7 @@ export default class RangeRingAngleText {
         label.vAlignment = 2;
         label.hAlignment = 2;
         label.size = 17;
+        // eslint-disable-next-line
         label.text = "`${aci}`"
 
         return style;
@@ -163,7 +164,7 @@ export default class RangeRingAngleText {
 
     /**
      * 
-     * @param {Array<{centerID:string, hide: bool}} centerHides 
+     * @param {Array<{centerID:string, hide: bool}>} centerHides 
      */
     updateCentersHide(centerHides) {
         if (this._hideAll) {

package/tests/Math/arc.test.ts

@@ -0,0 +1,52 @@
+import { Arc } from '../../Math/arc';
+import { Vector3D } from '../../Math/vector3d';
+import { Quaternion } from '../../Math/quaternion';
+import { Plane } from '../../Math/plane';
+
+let _0vector: Vector3D;
+let _1vector: Vector3D;
+let _0arc: Arc;
+let _1arc: Arc;
+let _0quaternion: Quaternion;
+let _medium: Plane;
+
+beforeAll(() => {
+
+    _0vector = new Vector3D(0, 0, 0);
+    _1vector = new Vector3D(1, 1, 1).normalize();
+    _0arc = new Arc(_0vector, _1vector);
+    _1arc = new Arc(_0vector, _1vector);
+    _0quaternion = new Quaternion(0, 0, 0, 1);
+    _medium = new Plane(new Vector3D(0, 0, 1), 0);
+
+});
+
+
+
+test("intersectionMedium", () => {
+
+
+    _0quaternion.setFromAxisAngle(_0vector.set(1, 0, 0), -Math.PI / 3);
+    const A = _0vector.set(0, 1, 0).applyQuaternion(_0quaternion).clone();
+    _0quaternion.setFromAxisAngle(_0vector.set(1, 0, 0), Math.PI / 3);
+    const B = _0vector.set(0, 1, 0).applyQuaternion(_0quaternion).clone();
+    _0arc.setFromUnitVectors(A, B);
+    const _1arc = _0arc.intersectionMedium(_medium)!;
+
+    expect(_1arc !== null).toBeTruthy();
+    expect([A, B].some((v) => v.equals(_1arc.pointA) || v.equals(_1arc.pointB))).toBeTruthy();
+    expect([_1arc.pointA, _1arc.pointB].some((v) => v.equals(new Vector3D(0, 1, 0)))).toBeTruthy();
+
+});
+
+
+test("intersectionMedium 2 - single point arc", () => {
+    _0arc.setFromUnitVectors(new Vector3D(0, 1, 0), new Vector3D(0, 1, 0));
+    const result = _0arc.intersectionMedium(_medium);
+    expect(result).toBeNull();
+});
+
+
+test(" populatePoints3D", () => {
+
+});

package/tests/Math/plane.test.ts

@@ -0,0 +1,45 @@
+import { Plane } from '../../Math/plane';
+import { Vector3D } from '../../Math/vector3d';
+import { Ray } from '../../Math/ray';
+
+
+const _0vector: Vector3D = new Vector3D(0, 0, 1);
+const _1vector: Vector3D = new Vector3D(0, 0, 1);
+const _3vector: Vector3D = new Vector3D(0, 0, 1);
+const _0ray: Ray = new Ray(new Vector3D(0, 0, 0), new Vector3D(1, 0, 0));;
+const _0plane: Plane = new Plane(new Vector3D(1, 0, 0), 0);;
+const _1plane: Plane = new Plane(new Vector3D(1, 0, 0), 0);;
+
+
+beforeAll(() => {
+    _0vector.randomUnit();
+    _1vector.randomUnit();
+    _3vector.randomUnit();
+    _0plane.setFromPoints(_0vector, _1vector, _3vector);
+    _3vector.randomUnit();
+    _1plane.setFromPoints(_0vector, _1vector, _3vector);
+});
+
+
+
+
+test("Plane Intersection => Ray", () => {
+    let result = Ray.fromTwoPlanes(_0plane, _1plane, _0ray);
+    expect(result).toBeInstanceOf(Ray);
+    if (result) {
+        expect(_0ray.contains(_0vector)).toBe(true);
+        expect(_0ray.contains(_1vector)).toBe(true);
+    }
+});
+
+test("set from a normal and a point", () => {
+    const normal = new Vector3D(1, 0, 0);
+    const point = new Vector3D(1, 2, 3);
+
+    _0plane.setFromNormalAndPoint(normal, point);
+    expect(_0plane.normal.equals(normal)).toBe(true);
+
+    expect(_0plane.constant).toBe(point.dot(normal));
+});
+
+

package/tests/Math/quaternion.test.ts

@@ -0,0 +1,98 @@
+import { Quaternion } from '../../Math/quaternion';
+import { Vector3D } from '../../Math/vector3d';
+
+
+let _0vector: Vector3D;
+let _0quaternion: Quaternion;
+let _1quaternion: Quaternion;
+
+
+beforeAll(() => {
+    _0vector = new Vector3D(0, 0, 0);
+    _0quaternion = new Quaternion(0, 0, 0, 1);
+    _1quaternion = new Quaternion(0, 0, 0, 1);
+});
+
+test('Quaternion constructor and normalization', () => {
+    const quaternion = new Quaternion(1, 2, 3, 4);
+    expect(quaternion.x).toBe(1);
+    expect(quaternion.y).toBe(2);
+    expect(quaternion.z).toBe(3);
+    expect(quaternion.w).toBe(4);
+
+    const length = Math.sqrt(1 ** 2 + 2 ** 2 + 3 ** 2 + 4 ** 2);
+    expect(length).toBeCloseTo(length); // Check the length of the quaternion
+
+    quaternion.normalize();
+    expect(quaternion.x).toBeCloseTo(1 / length);
+    expect(quaternion.y).toBeCloseTo(2 / length);
+    expect(quaternion.z).toBeCloseTo(3 / length);
+    expect(quaternion.w).toBeCloseTo(4 / length);
+});
+
+
+test('Quaternion Vector3D rotation , Z axis', () => {
+
+    const xyByEuler = (angle: number) => new Vector3D(
+        Math.cos(angle),
+        Math.sin(angle),
+        0
+    );
+
+
+    let angle = 0;
+    let step = Math.PI / 10;
+    _0quaternion.setFromAxisAngle(_0vector.set(0, 0, 1).clone(), step);
+    _0vector.set(1, 0, 0);
+    while (angle < Math.PI * 2) {
+        const vector = xyByEuler(angle);
+        expect(_0vector.equals(vector)).toBe(true);
+        angle += step;
+        _0vector.applyQuaternion(_0quaternion);
+    }
+
+
+});
+
+test('Quaternion Vector3D rotation , Y axis', () => {
+
+    const xyByEuler = (angle: number) => new Vector3D(
+        Math.cos(angle),
+        0,
+        (angle <= Math.PI ? -1 : 1) * Math.abs(Math.sin(angle)) // because of right hand rule
+    );
+
+
+    let angle = 0;
+    let step = Math.PI / 10;
+    _0quaternion.setFromAxisAngle(_0vector.set(0, 1, 0).clone(), step);
+    _0vector.set(1, 0, 0);
+    while (angle < Math.PI * 2) {
+        const vector = xyByEuler(angle);
+        expect(_0vector.equals(vector)).toBe(true);
+        angle += step;
+        _0vector.applyQuaternion(_0quaternion);
+    }
+
+
+});
+
+
+
+
+test('Quaternion Multiply', () => {
+    _0quaternion.setFromAxisAngle(_0vector.set(0, 0, 1), Math.PI / 2);
+    _1quaternion.setFromAxisAngle(_0vector.set(0, 1, 0), Math.PI / 2);
+    _0quaternion.multiply(_1quaternion);
+    _0vector.set(1, 0, 0).applyQuaternion(_0quaternion);
+    _0vector.equals(new Vector3D(0, -1, 0));
+});
+
+
+test("Quaternion all Zeros", () => {
+
+    _0quaternion.setFromAxisAngle(_0vector.set(0, 0, 0), 0);
+    _0vector.set(1, 0, 0).applyQuaternion(_0quaternion);
+    expect(_0vector.equals(new Vector3D(1, 0, 0))).toBe(true);
+});
+

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

@@ -0,0 +1,176 @@
+import { Ray } from '../../Math/ray'
+import { Vector3D } from '../../Math/vector3d';
+import { Plane } from '../../Math/plane';
+
+
+
+const _0vector: Vector3D = new Vector3D(0, 0, 1);
+const _1vector: Vector3D = new Vector3D(0, 0, 1);
+const _3vector: Vector3D = new Vector3D(0, 0, 1);
+const _0ray: Ray = new Ray(new Vector3D(0, 0, 0), new Vector3D(1, 0, 0));;
+const _0plane: Plane = new Plane(new Vector3D(1, 0, 0), 0);;
+const _1plane: Plane = new Plane(new Vector3D(1, 0, 0), 0);;
+
+
+beforeAll(() => {
+    _0vector.randomUnit();
+    _1vector.randomUnit();
+    _3vector.randomUnit();
+    _0plane.setFromPoints(_0vector, _1vector, _3vector);
+    _3vector.randomUnit();
+    _1plane.setFromPoints(_0vector, _1vector, _3vector);
+});
+
+
+
+test("Plane Intersection => Ray", () => {
+    let result = Ray.fromTwoPlanes(_0plane, _1plane, _0ray);
+    expect(result).toBeInstanceOf(Ray);
+    if (result) {
+        expect(_0ray.contains(_0vector)).toBe(true);
+        expect(_0ray.contains(_1vector)).toBe(true);
+    }
+});
+
+
+test('Ray constructor', () => {
+    const origin = new Vector3D(1, 2, 3);
+    const direction = new Vector3D(4, 5, 6);
+    const ray = new Ray(origin, direction);
+
+    expect(ray.origin).toEqual(origin);
+    expect(ray.direction).toEqual(direction.normalize());
+});
+
+test('Ray from two planes 1', () => {
+    const plane1 = new Plane(new Vector3D(1, 0, 0), 5);
+    const plane2 = new Plane(new Vector3D(0, 1, 0), 10);
+    const ray = Ray.fromTwoPlanes(plane1, plane2)!;
+    const plane1copy = plane1.clone();
+    const plane2copy = plane2.clone();
+    expect(ray).toBeInstanceOf(Ray);
+    expect(ray.contains(new Vector3D(5, 10, 0))).toBe(true);
+    expect(ray.contains(new Vector3D(5, 10, 5))).toBe(true);
+    expect(ray.contains(new Vector3D(5, 10, -5))).toBe(true);
+    expect(plane1.equals(plane1copy)).toBe(true);
+    expect(plane2.equals(plane2copy)).toBe(true);
+});
+
+
+test('Ray from two planes 2 ', () => {
+    const plane1 = new Plane(new Vector3D(1, 1, 1).normalize(), 1 / Math.sqrt(3));
+    const plane2 = new Plane(new Vector3D(0, 0, 1).normalize(), 0);
+    const plane1copy = plane1.clone();
+    const plane2copy = plane2.clone();
+    const ray = Ray.fromTwoPlanes(plane1, plane2)!;
+    expect(ray).toBeInstanceOf(Ray);
+    expect(ray.contains(new Vector3D(0.5, 0.5, 0))).toBe(true);
+    expect(ray.contains(new Vector3D(1, 0, 0))).toBe(true);
+    expect(ray.contains(new Vector3D(0, 1, 0))).toBe(true);
+    expect(plane1.equals(plane1copy)).toBe(true);
+    expect(plane2.equals(plane2copy)).toBe(true);
+});
+
+describe('Ray from two planes with parallel planes', () => {
+    test(`Ray from two planes from random points, try:`, () => {
+        for (let i = 0; i < 100; i++) {
+            _0vector.randomUnit();
+            _1vector.randomUnit();
+            _3vector.randomUnit();
+            _0plane.setFromPoints(_0vector, _1vector, _3vector);
+
+            const n = _3vector.clone().randomUnit();
+            _1plane.setFromPoints(_0vector, _1vector, n);
+            const plane1copy = _1plane.clone();
+            const plane2copy = _0plane.clone();
+
+            const ray = Ray.fromTwoPlanes(_0plane, _1plane)!;
+            if (ray === null) {
+                console.log(_0plane, _1plane, ray);
+                console.log(_0vector, _1vector, _3vector, n);
+            }
+            expect(ray).toBeInstanceOf(Ray);
+
+            expect(ray.contains(_0vector)).toBe(true);
+            expect(ray.contains(_1vector)).toBe(true);
+            expect(plane1copy.equals(_1plane)).toBe(true);
+            expect(plane2copy.equals(_0plane)).toBe(true);
+        }
+    });
+});
+
+
+
+test('Ray intersection sphere', () => {
+    const ray = new Ray(new Vector3D(0, 0, 0), new Vector3D(0, 0, 1));
+    const sphereOrigin = new Vector3D(0, 0, 5);
+    const sphereRadius = 2;
+    const intersections = ray.intersectionSphere(sphereOrigin, sphereRadius)!;
+
+    expect(intersections).toBeInstanceOf(Array);
+    expect(intersections.length).toBe(2);
+    expect(intersections[0].equals(new Vector3D(0, 0, 3))).toBe(true);
+    expect(intersections[1].equals(new Vector3D(0, 0, 7))).toBe(true);
+});
+
+
+
+describe('Ray from 2 points intersection with Sphere', () => {
+    test(`Ray from 2 points intersection with Sphere, try:`, () => {
+        for (let i = 0; i < 100; i++) {
+            const center = _3vector.randomUnit().scale(Math.random() * 10 + 1).clone();
+            const radius = Math.random() * 10 + 1;
+            const angle = Math.acos(_0vector.randomUnit().dot(_1vector.randomUnit()));
+            const _0clone = _0vector.scale(radius).add(center).clone();
+            const _1clone = _1vector.scale(radius).add(center).clone();
+
+            Ray.fromTwoPoints(_0vector, _1vector, _0ray);
+
+
+            const intersections = _0ray.intersectionSphere(center, radius)!;
+            expect(_3vector.equals(center)).toBe(true);
+            expect(intersections).toBeInstanceOf(Array);
+
+            expect(_0clone.equals(_0vector)).toBe(true);
+            expect(_1clone.equals(_1vector)).toBe(true);
+
+            expect(intersections.length).toBe(2);
+
+            _0vector.subtract(center).normalize().scale(radius).add(center);
+            _1vector.subtract(center).normalize().scale(radius).add(center);
+
+            expect(intersections.some((v) => v.equals(_0vector))).toBe(true);
+            expect(intersections.some((v) => v.equals(_1vector))).toBe(true);
+
+
+            const radius2 = radius * (1 + Math.random() * 10);
+            const intersections2 = _0ray.intersectionSphere(center, radius2)!;
+            expect(intersections2).toBeInstanceOf(Array);
+            expect(intersections2.length).toBe(2);
+
+            intersections2.forEach((v) => v.subtract(center).normalize());
+
+            const angle2 = Math.acos(intersections2[0].dot(intersections2[1]));
+
+            const x1 = angle / 2;
+            const D1 = Math.cos(x1) * radius;
+            const x2 = angle2 / 2;
+            const D2 = Math.cos(x2) * radius2;
+
+            expect(Math.abs(D1 - D2)).toBeLessThan(0.000001);
+        }
+    });
+});
+
+
+
+test('Ray copy', () => {
+    const origin = new Vector3D(1, 2, 3);
+    const direction = new Vector3D(4, 5, 6);
+    const ray1 = new Ray(origin, direction);
+    const ray2 = new Ray(new Vector3D(), new Vector3D()).copy(ray1);
+
+    expect(ray2.origin.equals(origin)).toBe(true);
+    expect(ray2.direction.equals(direction)).toBe(true);
+});
+

package/tests/Math/vector3d.test.ts

@@ -0,0 +1,71 @@
+import { Vector3D } from '../../Math/vector3d';
+import { Quaternion } from '../../Math/quaternion';
+
+
+const toRadians = (degrees: number) => degrees * (Math.PI / 180);
+const toDegrees = (radians: number) => radians * (180 / Math.PI);
+
+let _0vector: Vector3D;
+let _1vector: Vector3D;
+let _0quaternion: Quaternion;
+
+beforeEach(() => {
+    _0vector = new Vector3D(0, 0, 0);
+    _1vector = new Vector3D(1, 1, 1);
+    _0quaternion = new Quaternion(0, 0, 0, 1);
+});
+
+
+test('add', () => {
+    expect(_0vector.add(_1vector).equals(new Vector3D(1, 1, 1))).toBe(true);
+});
+
+
+test('setFromLonLat - toLonLat 2', () => {
+    expect(_0vector.setFromLonLat(0, 0).toLonLat()).toEqual({ lon: 0, lat: 0 });
+});
+
+
+test(' applyQuaternion ', () => {
+
+    _0quaternion.setFromAxisAngle(new Vector3D(0, 0, 1), Math.PI / 2);
+    _0vector.setFromLonLat(toRadians(10), 0);
+    _0vector.applyQuaternion(_0quaternion);
+    const result = _0vector.toLonLat();
+    expect(result).toEqual({ lon: toRadians(100), lat: 0 });
+});
+
+
+test('setFromLonLat - toLonLat', () => {
+    const result = _0vector.setFromLonLat(0, 0).toLonLat();
+    expect(result.lon).toBeCloseTo(0, 1e-6);
+    expect(result.lat).toBeCloseTo(0, 1e-6);
+});
+
+
+test('scale', () => {
+    const scale = 2;
+    const result = _0vector.set(1, 2, 3).scale(scale);
+    expect(result.equals(new Vector3D(2, 4, 6))).toBe(true);
+});
+
+
+
+test('negate', () => {
+    _0vector.set(1, -2, 3).negate();
+    expect(_0vector.equals(new Vector3D(-1, 2, -3))).toBe(true);
+});
+
+
+
+test('cross same and negated', () => {
+
+    const negated = _0vector.randomUnit().clone().negate();
+    const result = _0vector.clone().cross(negated);
+    const resul2 = _0vector.clone().cross(_0vector);
+
+    expect(result.equals(new Vector3D(0, 0, 0))).toBe(true);
+    expect(resul2.equals(new Vector3D(0, 0, 0))).toBe(true);
+});
+
+

package/util/geometry/index.js

@@ -1,4 +1,4 @@
-export function latLongToPixelXY(latitude, longitude) {
+function latLongToPixelXY(latitude, longitude) {
     return {
         x: (longitude + 180) / 360,
         y: (90 - latitude) / 180
@@ -11,7 +11,7 @@ export function latLongToPixelXY(latitude, longitude) {
  * for example: Transform image coordinates to map coordinates
  * glsl`vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);`
  */
-export function createBBoxMatrix(minX, maxX, minY, maxY) {
+function createBBoxMatrix(minX, maxX, minY, maxY) {
     return new Float32Array([
         maxX - minX, 0, 0,
         0, maxY - minY, 0,
@@ -19,7 +19,7 @@ export function createBBoxMatrix(minX, maxX, minY, maxY) {
     ])
 }
 
-export function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
+function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
     const minXY = latLongToPixelXY(minY, minX);
     const maxXY = latLongToPixelXY(maxY, maxX);
     return createBBoxMatrix(minXY.x, maxXY.x, minXY.y, maxXY.y);
@@ -31,7 +31,7 @@ export function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
  * @param {Float32List} array 
  * @returns {Float32Array}
  */
-export function normalize(array, newLength = 1) {
+function normalize(array, newLength = 1) {
     let total = 0;
     for (let i = 0; i < array.length; i++) {
         total += array[i] * array[i];
@@ -45,6 +45,9 @@ export function normalize(array, newLength = 1) {
 }
 
 
-export function sphereCoord(long, lat, globe, height = 0) {
+function sphereCoord(long, lat, globe, height = 0) {
     return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, 0), 6378.137 + height);
 }
+
+
+export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize };

package/util/surface-line-data/arc-bboxes.ts

@@ -0,0 +1,42 @@
+
+
+function naiveBBox(a: number[], b: number[]): BBox {
+    return {
+        minX: Math.min(a[0], b[0]),
+        minY: Math.min(a[1], b[1]),
+        maxX: Math.max(a[0], b[0]),
+        maxY: Math.max(a[1], b[1])
+    };
+
+}
+
+
+function slerp(a: Vector, b: Vector, t: number, theta: number, sinTheta: number): Vector {
+
+}
+
+
+function getArcBBoxes(arc: Arc, dotStep: number = 0.025): BBox[] {
+    const start = arc.start;
+    const end = arc.end;
+    const a = [start[0], start[1], start[2]];
+    const b = [end[0], end[1], end[2]];
+
+
+
+
+    const theta = Math.acos(a[0] * b[0] + a[1] * b[1] + a[2] * b[2]);
+    const step = dotStep / theta;
+
+    if (step >= 1) {
+        return [naiveBBox(start, end)];
+    }
+
+
+    let points = [start] as Vector[];
+
+
+    let currentStep = 
+
+    return bbox;
+}

package/util/surface-line-data/arcs-to-cuts.js

@@ -0,0 +1,74 @@
+
+
+
+
+class ArcsToCutsManager {
+
+    constructor(rbush, { dotDistanceOfArcCuts = 0.01 }) {
+
+        this._map = new Map();
+        this._dotDistanceOfArcCuts = dotDistanceOfArcCuts;
+        this._rbush = rbush;
+    }
+
+
+
+    insertArcs(arc) {
+
+        if (this._map.has(arc.id)) {
+            this._deleteCuts(arc.id);
+        }
+
+
+    }
+
+    _deleteCuts(id) {
+        const cuts = this._map.get(id);
+        if (cuts) {
+            cuts.forEach(cut => cut.remove());
+        }
+    }
+
+
+    _cutArcAndAddToRBush(arc) {
+        const cuts = this._cutArcToBBoxs(arc);
+        cuts.forEach(cut => {
+            this._rbush.insert(cut);
+        });
+        this._map.set(arc.id, cuts);
+    }
+
+
+    _cutArcToBBoxs(arc) {
+        const cuts = [];
+
+        // Calculate the bounding box of the arc
+
+
+        // Create a cut object and add it to the cuts array
+        const cut = {
+            minX: bbox.minX,
+            minY: bbox.minY,
+            maxX: bbox.maxX,
+            maxY: bbox.maxY,
+            arcId: arc.id,
+        };
+
+        cuts.push(cut);
+        return cuts;
+    }
+}
+
+
+
+function sphericalLinearInterpolation(phi1, lambda1, phi2, lambda2, t) {
+    // Spherical linear interpolation between two points on a sphere
+    // Args: phi1, lambda1: starting point (in radians)
+    //       phi2, lambda2: ending point (in radians)
+    //       t: interpolation parameter (0 <= t <= 1)
+    // Returns: [phi, lambda] in radians
+
+    const phi = phi1 + t * (phi2 - phi1);
+    const lambda = lambda1 + t * (lambda2 - lambda1);
+    return [phi, lambda];
+}