@pirireis/webglobeplugins 0.10.11-alpha → 0.10.12-alpha

package/Math/methods.js

@@ -1,133 +1,52 @@
 import { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR } from './constants';
-/**
- * @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]
- */
-// *********************************************************
-// **************** VECTOR OPERATIONS **********************
-// *********************************************************
-const RADIANS = Math.PI / 180;
-/**
- * @param {vec3} a
- * @returns {vec3}
- */
-const normalize3 = (a) => {
-    const len = length3(a);
-    return [a[0] / len, a[1] / len, a[2] / len];
-};
-/**
- * @param {vec3} a
- * @param {vec3} b
- * @returns {number}
- */
-const dot3 = (a, b) => {
-    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-};
-/**
- * @param {vec3} a
- * @returns {number}
- */
-const length3 = (a) => {
-    return Math.sqrt(dot3(a, a));
-};
-// *********************************************************
-// **************** TRANSFORMATIONS ************************
-// *********************************************************
-/**
- * @param {vec3} cartesian
- * @returns {vec2} long lat in radians
- */
-const cartesian3dToRadian = (cartesian) => {
+import { dot as dot3, copy as copy3 } from './vec3';
+export const RADIANS = Math.PI / 180;
+const _0vec3 = [0, 0, 0];
+const _0vec2 = [0, 0];
+export const cartesian3dToRadian = (output, cartesian) => {
     const x = cartesian[0];
     const y = cartesian[1];
     const z = cartesian[2];
-    // const length = Math.sqrt(x * x + y * y + z * z);
-    const long = Math.atan2(y, x);
-    const lat = Math.asin(z); // length);
-    return [long, lat];
+    output[0] = Math.atan2(y, x); // longitude
+    output[1] = Math.asin(z); // latitude
 };
-/**
- * @param {vec2} xy long lat in radians
- * @returns {vec2} long lat in mercator meters
- */
-const radianToMercator = (xy) => {
-    return [WORLD_RADIUS_MERCATOR * xy[0], WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
+export const radianToMercator = (xy) => {
+    return [
+        WORLD_RADIUS_MERCATOR * xy[0],
+        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))
+    ];
 };
-/**
- * @param {vec2} xy long lat radians
- * @returns {vec3} cartesian
- */
-const radianToCartesian3d = (xy) => {
+export const radianToCartesian3d = (xy) => {
     const x = Math.cos(xy[1]) * Math.cos(xy[0]);
     const y = Math.cos(xy[1]) * Math.sin(xy[0]);
     const z = -Math.sin(xy[1]);
     return [x, y, z];
 };
-// *********************************************************
-// ***************** INTERPOLATIONS ************************
-// *********************************************************
-/**
- * @param {vec3} normalizedA
- * @param {vec3} normalizedB
- * @param {fraction} ratio
- * @returns {vec3}
- */
-const sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio) => {
+export const sphericalLinearInterpolation_UnitVector = (output, normalizedA, normalizedB, ratio) => {
     const theta = Math.acos(dot3(normalizedA, normalizedB));
-    if (theta < 0.000001)
-        return normalizedA; // CALIBRATE?
+    if (theta < 0.000001) {
+        copy3(output, normalizedA);
+        return;
+    }
     const sinTheta = Math.sin(theta);
-    const result = [
-        (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta,
-        (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta,
-        (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta
-    ];
-    return result;
-};
-/**
- * @param {vec3} normalizedA
- * @param {vec3} normalizedB
- * @param {fraction} ratio
- * @returns
- */
-const sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio) => {
-    const unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);
-    const angles = cartesian3dToRadian(unitVector);
-    return radianToMercator(angles);
-};
-/**
- * @param {vec4} a vec3 unit vector and length
- * @param {vec4} b vec3 unit vector and length
- * @param {fraction} ratio
- */
-const sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {
-    const unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);
+    output[0] = (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta;
+    output[1] = (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta;
+    output[2] = (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta;
+};
+export const sphericalLinearInterpolation_Mercator = (output, normalizedA, normalizedB, ratio) => {
+    sphericalLinearInterpolation_UnitVector(_0vec3, normalizedA, normalizedB, ratio);
+    cartesian3dToRadian(_0vec2, _0vec3);
+    output[0] = WORLD_RADIUS_MERCATOR * _0vec2[0];
+    output[1] = WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + _0vec2[1] / 2));
+};
+export const sphericalLinearInterpolation_Cartesian3d = (output, a, b, ratio) => {
+    sphericalLinearInterpolation_UnitVector(_0vec3, [a[0], a[1], a[2]], [b[0], b[1], b[2]], ratio);
     const height = a[3] + (b[3] - a[3]) * ratio;
-    return [unitVector[0] * height, unitVector[1] * height, unitVector[2] * height];
+    output[0] = _0vec3[0] * height;
+    output[1] = _0vec3[1] * height;
+    output[2] = _0vec3[2] * height;
 };
-/**
- *
- * @param {wgs84} coordinates
- * @returns {vec3}
- */
-const wgs84ToUnitVector = (coordinates) => {
-    const long = coordinates[0] * RADIANS;
-    const lat = coordinates[1] * RADIANS;
-    const x = Math.cos(lat) * Math.cos(long);
-    const y = Math.cos(lat) * Math.sin(long);
-    const z = Math.sin(lat);
-    return [x, y, z];
-};
-/**
- * @param {number} long wgs84
- * @param {number} lat wgs84
- * @param {number} height
- * @returns {vec3} cartesian3D
- */
-const wgs84ToCartesian3d = (long, lat, height) => {
+export const wgs84ToCartesian3d = (long, lat, height) => {
     const longRad = long * RADIANS;
     const latRad = lat * RADIANS;
     const x = Math.cos(latRad) * Math.cos(longRad);
@@ -136,29 +55,23 @@ const wgs84ToCartesian3d = (long, lat, height) => {
     const radius = WORLD_RADIUS_3D + height;
     return [x * radius, y * radius, z * radius];
 };
-/**
- * @param {number} long
- * @param {number} lat
- * @returns {vec2} mercator
- */
-const wgs84ToMercator = (long, lat) => {
-    return [WORLD_RADIUS_MERCATOR * long * RADIANS, WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))];
+export const wgs84ToMercator = (long, lat) => {
+    return [
+        WORLD_RADIUS_MERCATOR * long * RADIANS,
+        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))
+    ];
 };
-/**
- * @param {vec2} pixelXY
- * @returns {vec2} long lat in radians
- */
-const pixelXYToRadians = (pixelXY) => {
+export const pixelXYToRadians = (pixelXY) => {
     const long = (2.0 * pixelXY[0] - 1.0) * Math.PI;
     const lat = (2.0 * pixelXY[1] - 1.0) * Math.PI / 2.0;
     return [long, lat];
 };
-const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
-    const [long, lat] = pixelXYToRadians(pixelXYHeight);
+export const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
+    const [long, lat] = pixelXYToRadians([pixelXYHeight[0], pixelXYHeight[1]]);
     const radius = WORLD_RADIUS_3D + pixelXYHeight[2];
-    return radianToCartesian3d([long, lat]).concat(radius);
+    return [...radianToCartesian3d([long, lat]), radius];
 };
-const globe3Dcoordinates = (globe, height = 0) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
+export const globe3Dcoordinates = (globe, height = 0) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
     const len = longlats.length / 2;
     const result = new Float32Array(len * 3 + paddingCount * 3).fill(paddingValue);
     for (let i = 0; i < len; i++) {
@@ -169,7 +82,7 @@ const globe3Dcoordinates = (globe, height = 0) => (longlats, { paddingCount = 0,
     }
     return result;
 };
-const globe2Dcoordinates = (globe) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
+export const globe2Dcoordinates = (globe) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
     const len = longlats.length / 2;
     const result = new Float32Array(len * 2 + paddingCount * 2).fill(paddingValue);
     for (let i = 0; i < len; i++) {
@@ -180,4 +93,3 @@ const globe2Dcoordinates = (globe) => (longlats, { paddingCount = 0, paddingValu
     }
     return result;
 };
-export { RADIANS, normalize3, dot3, length3, cartesian3dToRadian, radianToMercator, radianToCartesian3d, sphericalLinearInterpolation_UnitVector, sphericalLinearInterpolation_Mercator, sphericalLinearInterpolation_Cartesian3d, wgs84ToUnitVector, wgs84ToCartesian3d, wgs84ToMercator, pixelXYLenghtToUnitVectorWithHeight, globe3Dcoordinates, globe2Dcoordinates, };

package/Math/methods1.js

@@ -0,0 +1,183 @@
+import { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR } from './constants';
+/**
+ * @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]
+ */
+// *********************************************************
+// **************** VECTOR OPERATIONS **********************
+// *********************************************************
+const RADIANS = Math.PI / 180;
+/**
+ * @param {vec3} a
+ * @returns {vec3}
+ */
+const normalize3 = (a) => {
+    const len = length3(a);
+    return [a[0] / len, a[1] / len, a[2] / len];
+};
+/**
+ * @param {vec3} a
+ * @param {vec3} b
+ * @returns {number}
+ */
+const dot3 = (a, b) => {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+};
+/**
+ * @param {vec3} a
+ * @returns {number}
+ */
+const length3 = (a) => {
+    return Math.sqrt(dot3(a, a));
+};
+// *********************************************************
+// **************** TRANSFORMATIONS ************************
+// *********************************************************
+/**
+ * @param {vec3} cartesian
+ * @returns {vec2} long lat in radians
+ */
+const cartesian3dToRadian = (cartesian) => {
+    const x = cartesian[0];
+    const y = cartesian[1];
+    const z = cartesian[2];
+    // const length = Math.sqrt(x * x + y * y + z * z);
+    const long = Math.atan2(y, x);
+    const lat = Math.asin(z); // length);
+    return [long, lat];
+};
+/**
+ * @param {vec2} xy long lat in radians
+ * @returns {vec2} long lat in mercator meters
+ */
+const radianToMercator = (xy) => {
+    return [WORLD_RADIUS_MERCATOR * xy[0], WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
+};
+/**
+ * @param {vec2} xy long lat radians
+ * @returns {vec3} cartesian
+ */
+const radianToCartesian3d = (xy) => {
+    const x = Math.cos(xy[1]) * Math.cos(xy[0]);
+    const y = Math.cos(xy[1]) * Math.sin(xy[0]);
+    const z = -Math.sin(xy[1]);
+    return [x, y, z];
+};
+// *********************************************************
+// ***************** INTERPOLATIONS ************************
+// *********************************************************
+/**
+ * @param {vec3} normalizedA
+ * @param {vec3} normalizedB
+ * @param {fraction} ratio
+ * @returns {vec3}
+ */
+const sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio) => {
+    const theta = Math.acos(dot3(normalizedA, normalizedB));
+    if (theta < 0.000001)
+        return normalizedA; // CALIBRATE?
+    const sinTheta = Math.sin(theta);
+    const result = [
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta,
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta,
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta
+    ];
+    return result;
+};
+/**
+ * @param {vec3} normalizedA
+ * @param {vec3} normalizedB
+ * @param {fraction} ratio
+ * @returns
+ */
+const sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio) => {
+    const unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);
+    const angles = cartesian3dToRadian(unitVector);
+    return radianToMercator(angles);
+};
+/**
+ * @param {vec4} a vec3 unit vector and length
+ * @param {vec4} b vec3 unit vector and length
+ * @param {fraction} ratio
+ */
+const sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {
+    const unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);
+    const height = a[3] + (b[3] - a[3]) * ratio;
+    return [unitVector[0] * height, unitVector[1] * height, unitVector[2] * height];
+};
+/**
+ *
+ * @param {wgs84} coordinates
+ * @returns {vec3}
+ */
+const wgs84ToUnitVector = (coordinates) => {
+    const long = coordinates[0] * RADIANS;
+    const lat = coordinates[1] * RADIANS;
+    const x = Math.cos(lat) * Math.cos(long);
+    const y = Math.cos(lat) * Math.sin(long);
+    const z = Math.sin(lat);
+    return [x, y, z];
+};
+/**
+ * @param {number} long wgs84
+ * @param {number} lat wgs84
+ * @param {number} height
+ * @returns {vec3} cartesian3D
+ */
+const wgs84ToCartesian3d = (long, lat, height) => {
+    const longRad = long * RADIANS;
+    const latRad = lat * RADIANS;
+    const x = Math.cos(latRad) * Math.cos(longRad);
+    const y = Math.cos(latRad) * Math.sin(longRad);
+    const z = Math.sin(latRad);
+    const radius = WORLD_RADIUS_3D + height;
+    return [x * radius, y * radius, z * radius];
+};
+/**
+ * @param {number} long
+ * @param {number} lat
+ * @returns {vec2} mercator
+ */
+const wgs84ToMercator = (long, lat) => {
+    return [WORLD_RADIUS_MERCATOR * long * RADIANS, WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))];
+};
+/**
+ * @param {vec2} pixelXY
+ * @returns {vec2} long lat in radians
+ */
+const pixelXYToRadians = (pixelXY) => {
+    const long = (2.0 * pixelXY[0] - 1.0) * Math.PI;
+    const lat = (2.0 * pixelXY[1] - 1.0) * Math.PI / 2.0;
+    return [long, lat];
+};
+const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
+    const [long, lat] = pixelXYToRadians(pixelXYHeight);
+    const radius = WORLD_RADIUS_3D + pixelXYHeight[2];
+    return radianToCartesian3d([long, lat]).concat(radius);
+};
+const globe3Dcoordinates = (globe, height = 0) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
+    const len = longlats.length / 2;
+    const result = new Float32Array(len * 3 + paddingCount * 3).fill(paddingValue);
+    for (let i = 0; i < len; i++) {
+        const long = longlats[i * 2];
+        const lat = longlats[i * 2 + 1];
+        const xyz = globe.api_GetCartesian3DPoint(long, lat, height, 0);
+        result.set(xyz, i * 3);
+    }
+    return result;
+};
+const globe2Dcoordinates = (globe) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
+    const len = longlats.length / 2;
+    const result = new Float32Array(len * 2 + paddingCount * 2).fill(paddingValue);
+    for (let i = 0; i < len; i++) {
+        const long = longlats[i * 2];
+        const lat = longlats[i * 2 + 1];
+        const xyz = globe.api_GetMercator2DPoint(long, lat);
+        result.set(xyz, i * 2);
+    }
+    return result;
+};
+export { RADIANS, normalize3, dot3, length3, cartesian3dToRadian, radianToMercator, radianToCartesian3d, sphericalLinearInterpolation_UnitVector, sphericalLinearInterpolation_Mercator, sphericalLinearInterpolation_Cartesian3d, wgs84ToUnitVector, wgs84ToCartesian3d, wgs84ToMercator, pixelXYLenghtToUnitVectorWithHeight, globe3Dcoordinates, globe2Dcoordinates, };

package/altitude-locator/plugin.js

@@ -5,7 +5,7 @@ import { ElementGlobeSufaceGlowCache } from '../programs/point-on-globe/element-
 import { LineOnGlobeCache } from '../programs/line-on-globe/naive-accurate-flexible.js';
 import { BufferOrchestrator, BufferManager } from "../util/account";
 import { PickerDisplayer } from '../util/picking/picker-displayer.js';
-import { wgs84ToCartesian3d, wgs84ToMercator } from '../Math/methods.js';
+import { wgs84ToCartesian3d, wgs84ToMercator } from '../Math/methods';
 import { constraintFloat, opacityCheck } from '../util/check/typecheck.js';
 import { createBufferAndReadInfo } from '../util/gl-util/buffer/attribute-loader';
 import { CameraUniformBlockTotemCache } from '../programs/totems/camerauniformblock.js';
@@ -13,6 +13,8 @@ import { CameraUniformBlockTotemCache } from '../programs/totems/camerauniformbl
  * is used with depth we can create a line from surface to the point.
  */
 const glowOverSize = 1.35; // 1.25 is the default value in the shader
+const _0vec6 = [0, 0, 0, 0, 0, 0];
+const _0vec3 = [0, 0, 0];
 class PointGlowLineToEarthPlugin {
     constructor({ isGlowPointOn = true, isGlowSurfaceOn = true }) {
         this.globe = null;
@@ -51,7 +53,14 @@ class PointGlowLineToEarthPlugin {
         this._bufferManagersMap = new Map([
             ['pos3D', {
                     bufferManager: new BufferManager(gl, 6, { bufferType, initialCapacity }),
-                    adaptor: (item) => new Float32Array([...wgs84ToCartesian3d(item.long, item.lat, item.altitude / 1000), ...wgs84ToCartesian3d(item.long, item.lat, 0 / 1000)])
+                    adaptor: (item) => {
+                        wgs84ToCartesian3d(_0vec6, item.long, item.lat, item.altitude / 1000);
+                        wgs84ToCartesian3d(_0vec3, item.long, item.lat, 0 / 1000);
+                        _0vec6[3] = _0vec3[0];
+                        _0vec6[4] = _0vec3[1];
+                        _0vec6[5] = _0vec3[2];
+                        new Float32Array(_0vec6);
+                    }
                 }],
             ['pos2D', {
                     bufferManager: new BufferManager(gl, 2, { bufferType, initialCapacity }),

package/package.json

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

package/timetracks/index.js

@@ -1,3 +1 @@
-import TimeTracksLineStrip from './plugin-line-strip';
-import { addCuttingPointLineStrip, featuresToLineStringData, fillSliceOfFloat32ArrayLineStrip, latLongToPixelXY } from './adaptors-line-strip';
-export { Adaptor, fillSliceOfFloat32Array, createFloat32Array, TimeTracks, TimeTracksLineStrip, addCuttingPointLineStrip, featuresToLineStringData, fillSliceOfFloat32ArrayLineStrip, latLongToPixelXY };
+"use strict";

package/util/interpolation/timetrack/timetrack-interpolator.js

@@ -7,6 +7,7 @@ import { sphericalLinearInterpolation_Cartesian3d, sphericalLinearInterpolation_
  * @typedef {number} fraction a number between 0 and 1
  * @typedef {Array<number>} wgs84 [long, lat]
  */
+const _0vec3 = [0, 0, 0];
 const GEOMETRY = Object.freeze({
     CARTESIAN3D: 0,
     MERCATOR: 1,
@@ -57,10 +58,13 @@ class TimeTrackInterpolator {
                 continue;
             }
             const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
-            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
-                sphericalLinearInterpolation_Cartesian3d(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
-                sphericalLinearInterpolation_Mercator(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
-            resultArray.push(...interpolated);
+            if (geometry === GEOMETRY.CARTESIAN3D) {
+                sphericalLinearInterpolation_Cartesian3d(_0vec3, coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            }
+            else {
+                sphericalLinearInterpolation_Mercator(_0vec3, coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            }
+            resultArray.push(..._0vec3);
         }
         return new Float32Array(resultArray);
     }