@pirireis/webglobeplugins 0.15.35 → 0.16.0

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

@@ -0,0 +1,91 @@
+import { Plane, Line, Vec3, Quaternion } from '../../../Math/types';
+import * as plane from '../../../Math/plane';
+import * as line from '../../../Math/line';
+import * as vec3 from '../../../Math/vec3';
+import * as 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);
+});
+
+test("plane-plane intersection 2", () => {
+    plane.fromValues(plane1, 1, 0, 0, 1);
+    plane.fromValues(plane2, 0, 1, 0, 1);
+    const result = planePlaneJuction(intersectionLine, plane1, plane2);
+    expect(result).toBe(true);
+    expect(vec3.equals(intersectionLine.direction, vec3.create(0, 0, 1))).toBe(true);
+    expect(line.contains(intersectionLine, vec3.create(1, 1, 0))).toBe(true);
+});

package/tests/Math/plane-test.ts

@@ -0,0 +1,17 @@
+import { Vec3, Plane } from '../../Math/types';
+import * as vec3 from '../../Math/vec3';
+import * as plane from '../../Math/plane';
+
+
+const EPSILON = 1e-6;
+
+const _0plane = plane.create(vec3.create(0, 0, 1), 0);
+const _1plane = plane.create(vec3.create(1, 1, 1), 0);
+
+beforeAll(() => {
+    // Initialize any necessary data or state before running the tests
+    plane.set(_0plane, vec3.create(0, 0, 1), 0);
+    plane.set(_1plane, vec3.create(1, 1, 1), 0);
+});
+
+

package/tests/Math/plane.test.ts

@@ -0,0 +1,43 @@
+import { Plane, Vec3 } from "../../Math/types";
+import * as vec3 from "../../Math/vec3";
+import * as 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

@@ -0,0 +1,14 @@
+import { Vec3 } from "../../Math/types";
+import * as 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,65 +1,80 @@
-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 };
+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 };

package/timetracks/index.js

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