@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/Math/methods.ts

@@ -0,0 +1,157 @@
+import { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR } from './constants';
+import { Vec3, Vec2, Vec4, Fraction, WGS84, LongLat } from './types';
+import { dot as dot3, copy as copy3 } from './vec3';
+import { Globe } from '../types';
+
+export const RADIANS = Math.PI / 180;
+
+const _0vec3 = [0, 0, 0] as Vec3;
+const _0vec2 = [0, 0] as Vec2;
+export const cartesian3dToRadian = (output: WGS84,
+    cartesian: Vec3): void => {
+    const x = cartesian[0];
+    const y = cartesian[1];
+    const z = cartesian[2];
+    output[0] = Math.atan2(y, x); // longitude
+    output[1] = Math.asin(z); // latitude
+};
+
+export const radianToMercator = (xy: Vec2): Vec2 => {
+    return [
+        WORLD_RADIUS_MERCATOR * xy[0],
+        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))
+    ];
+};
+
+export const radianToCartesian3d = (xy: Vec2): Vec3 => {
+    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];
+};
+
+export const sphericalLinearInterpolation_UnitVector = (
+    output: Vec3,
+    normalizedA: Vec3,
+    normalizedB: Vec3,
+    ratio: Fraction
+): void => {
+    const theta = Math.acos(dot3(normalizedA, normalizedB));
+    if (theta < 0.000001) {
+        copy3(output, normalizedA);
+        return;
+    }
+    const sinTheta = Math.sin(theta);
+    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: Vec2,
+    normalizedA: Vec3,
+    normalizedB: Vec3,
+    ratio: Fraction
+): void => {
+    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: Vec3,
+    a: Vec4,
+    b: Vec4,
+    ratio: Fraction
+): void => {
+    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;
+    output[0] = _0vec3[0] * height;
+    output[1] = _0vec3[1] * height;
+    output[2] = _0vec3[2] * height;
+}
+
+
+
+
+export const wgs84ToCartesian3d = (output: Vec3, long: number, lat: number, height: number): void => {
+    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;
+    output[0] = x * radius;
+    output[1] = y * radius;
+    output[2] = z * radius;
+};
+
+export const wgs84ToMercator = (long: number, lat: number): Vec2 => {
+    return [
+        WORLD_RADIUS_MERCATOR * long * RADIANS,
+        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))
+    ];
+};
+
+export const pixelXYToRadians = (pixelXY: Vec2): Vec2 => {
+    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];
+};
+
+export const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight: [number, number, number]): Vec4 => {
+    const [long, lat] = pixelXYToRadians([pixelXYHeight[0], pixelXYHeight[1]]);
+    const radius = WORLD_RADIUS_3D + pixelXYHeight[2];
+    return [...radianToCartesian3d([long, lat]), radius];
+};
+
+
+
+export const globe3Dcoordinates = (globe: Globe, longlats: number[] | Float64Array, height = 0, msl = false, { paddingCount = 0, paddingValue = NaN }: { paddingCount?: number; paddingValue?: number }
+): Float32Array => {
+    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, msl);
+        result.set(xyz, i * 3);
+    }
+    return result;
+};
+
+
+const manhattanDistance = (a: Vec2, b: Vec2): number => {
+    return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);
+};
+
+export const globe2Dcoordinates = (globe: Globe, distanceFilterMeter: number = WORLD_RADIUS_MERCATOR) => (
+    longlats: number[] | Float64Array,
+    { paddingCount = 0, paddingValue = NaN }: { paddingCount?: number; paddingValue?: number }
+): Float32Array => {
+    let _lastXY: Vec2 = [NaN, 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 xy = globe.api_GetMercator2DPoint(long, lat);
+        if (manhattanDistance(_lastXY, xy) > distanceFilterMeter) {
+            result.set([paddingValue, paddingValue], i * 2);
+        } else {
+            result.set(xy, i * 2);
+        }
+        _lastXY = xy;
+    }
+    return result;
+};

package/Math/plane.ts

@@ -0,0 +1,92 @@
+import { Vec3, Plane } from "./types";
+
+import { EPSILON } from "./constants";
+import {
+    copy as vec3copy, create as vec3create, clone as vec3clone, set as vec3set, dot,
+    subtract, multiplyScalar, cross, normalize,
+    equals as vec3equals
+} from "./vec3";
+const _0vector = /*@__PURE__*/ vec3create(0, 0, 0);
+const _1vector = /*@__PURE__*/ vec3create(1, 1, 1);
+
+
+function create(normal = vec3create(), distance = 0): Plane {
+    return {
+        normal: vec3clone(normal),
+        distance: distance
+    };
+}
+
+
+function set(out: Plane, normal: Vec3, distance: number): Plane {
+    vec3copy(out.normal, normal);
+    out.distance = distance;
+    return out;
+}
+
+
+function fromValues(out: Plane, nx: number, ny: number, nz: number, distance: number) {
+    vec3set(out.normal, nx, ny, nz);
+    out.distance = distance;
+}
+
+
+function copy(out: Plane, a: Plane): Plane {
+    vec3copy(out.normal, a.normal);
+    out.distance = a.distance;
+    return out;
+}
+
+
+function clone(a: Plane): Plane {
+    return {
+        normal: vec3clone(a.normal),
+        distance: a.distance
+    };
+}
+
+
+function distanceToPoint(plane: Plane, point: Vec3): number {
+    return dot(plane.normal, point) - plane.distance;
+}
+
+
+function projectPoint(out: Vec3, plane: Plane, point: Vec3) {
+    const distance = distanceToPoint(plane, point);
+    multiplyScalar(out, plane.normal, distance);
+    subtract(out, point, out);
+}
+
+
+function equals(plane: Plane, other: Plane): boolean {
+    return vec3equals(plane.normal, other.normal) && Math.abs(plane.distance - other.distance) < EPSILON;
+}
+
+
+
+function fromNormalAndCoplanarPoint(out: Plane, normal: Vec3, point: Vec3) {
+    vec3copy(out.normal, normal);
+    out.distance = dot(point, normal);
+}
+
+
+
+function fromPoints(out: Plane, a: Vec3, b: Vec3, c: Vec3) {
+    subtract(_0vector, b, a);
+    subtract(_1vector, c, a);
+    cross(out.normal, _0vector, _1vector);
+    normalize(out.normal, out.normal);
+    out.distance = dot(out.normal, a);
+}
+
+
+
+function getUnitSphereRadiusAngle(plane: Plane): number {
+    return Math.acos(Math.max(Math.min(plane.distance, 1), -1));
+}
+
+
+export {
+    create, set, fromValues, copy, clone, distanceToPoint, projectPoint,
+    equals, fromNormalAndCoplanarPoint, fromPoints, getUnitSphereRadiusAngle
+}

package/Math/quaternion.ts

@@ -0,0 +1,128 @@
+import { Vec3, Quaternion } from './types';
+import { dot } from './vec3';
+import { EPSILON } from './constants';
+
+function create(x = 0, y = 0, z = 0, w = 1): Quaternion {
+    return [x, y, z, w];
+}
+
+function set(out: Quaternion, x: number, y: number, z: number, w: number) {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    out[3] = w;
+}
+
+function copy(out: Quaternion, a: Quaternion) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+}
+
+function clone(a: Quaternion): Quaternion {
+    return [a[0], a[1], a[2], a[3]];
+}
+function lengthSquared(a: Quaternion): number {
+    return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
+}
+
+function length(a: Quaternion): number {
+    return Math.sqrt(lengthSquared(a));
+}
+
+function normalize(out: Quaternion, input: Quaternion) {
+    const len = Math.sqrt(lengthSquared(input));
+    if (len < EPSILON) {
+        set(out, 0, 0, 0, 1);
+    }
+    else {
+        const invLen = 1 / len;
+        set(out, input[0] * invLen, input[1] * invLen, input[2] * invLen, input[3] * invLen);
+    }
+}
+
+
+function multiply(out: Quaternion, a: Quaternion, b: Quaternion): Quaternion {
+    const x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
+    const y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
+    const z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
+    const w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
+    set(out, x, y, z, w);
+    return out;
+}
+
+function randomUnit(out: Quaternion): Quaternion {
+    const u1 = Math.random();
+    const u2 = Math.random();
+    const u3 = Math.random();
+    const sqrt1MinusU1 = Math.sqrt(1 - u1);
+    const sqrtU1 = Math.sqrt(u1);
+    const x = sqrt1MinusU1 * Math.sin(2 * Math.PI * u2);
+    const y = sqrt1MinusU1 * Math.cos(2 * Math.PI * u2);
+    const z = sqrtU1 * Math.sin(2 * Math.PI * u3);
+    const w = sqrtU1 * Math.cos(2 * Math.PI * u3);
+    set(out, x, y, z, w);
+    normalize(out, out);
+    return out;
+}
+
+function rotateQuaternion(out: Quaternion, a: Quaternion, b: Quaternion) {
+    const x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
+    const y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
+    const z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
+    const w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
+    set(out, x, y, z, w);
+    normalize(out, out);
+}
+
+
+function fromUnitVectors(out: Quaternion, from: Vec3, to: Vec3) {
+
+    const d = dot(from, to) + 1;
+    if (d < EPSILON) {
+        if (Math.abs(from[0]) > Math.abs(from[2])) {
+            set(out, -from[1], from[0], 0, 0);
+        } else {
+            set(out, 0, -from[2], from[1], 0);
+        }
+    } else {
+        const x = from[1] * to[2] - from[2] * to[1];
+        const y = from[2] * to[0] - from[0] * to[2];
+        const z = from[0] * to[1] - from[1] * to[0];
+        set(out, x, y, z, d);
+    }
+}
+
+
+function fromTwoQuaternions(out: Quaternion, from: Quaternion, to: Quaternion) {
+    const x = from[0] * to[3] + from[3] * to[0] + from[1] * to[2] - from[2] * to[1];
+    const y = from[1] * to[3] + from[3] * to[1] + from[2] * to[0] - from[0] * to[2];
+    const z = from[2] * to[3] + from[3] * to[2] + from[0] * to[1] - from[1] * to[0];
+    const w = from[3] * to[3] - from[0] * to[0] - from[1] * to[1] - from[2] * to[2];
+    set(out, x, y, z, w);
+    normalize(out, out);
+}
+
+function conjugate(out: Quaternion, a: Quaternion) {
+    set(out, -a[0], -a[1], -a[2], a[3]);
+}
+
+function fromAxisAngle(out: Quaternion, axis: Vec3, angle: number) {
+    const halfAngle = angle / 2;
+    const s = Math.sin(halfAngle);
+    set(out, axis[0] * s, axis[1] * s, axis[2] * s, Math.cos(halfAngle));
+}
+
+function reverse(out: Quaternion, a: Quaternion) {
+    out[0] = -a[0];
+    out[1] = -a[1];
+    out[2] = -a[2];
+    out[3] = a[3];
+}
+
+export {
+    create, set, copy, clone, length, lengthSquared, normalize, multiply,
+    randomUnit, rotateQuaternion, fromUnitVectors, fromTwoQuaternions,
+    conjugate, fromAxisAngle, reverse
+}

package/Math/roadmap.md

@@ -0,0 +1,10 @@
+
+There is an arc on a unit sphere. The sphere center is at the origin. The arc is represented with start and points. 
+
+And there is a plane the intersects with the same sphere. Represented with vector and distance from origin.
+
+I want to know the relative position of points to the plane. If they are at the same direction with the plane vector or not. 
+
+If two points are on the same side of the plane. If so, do they closer to origin then plane or not. 
+
+If two points are on different side of the plane, I want to know the intersection point of arc and plane.

package/Math/templete-shapes/grid-visually-equal.ts

@@ -0,0 +1,119 @@
+import { LongLat, Globe, Meter, Radians, CentigradeDegree } from "../../types";
+
+
+
+/**
+ * Createa a grıd of longitude/latitude points visually equal on the mercator projectıon.
+ */
+
+function mercatorMeterToLongLat(
+    mercatorX: number,
+    mercatorY: number
+): LongLat {
+    const R = 6378137; // Earth radius in meters
+    const lng = (mercatorX / R) * (180 / Math.PI);
+    const lat = (2 * Math.atan(Math.exp(mercatorY / R)) - Math.PI / 2) * (180 / Math.PI);
+    return [lng, lat];
+}
+
+
+function createGrid(sizeX: number, sizeY: number): any[][] {
+    const grid: LongLat[][] = [];
+    for (let y = 0; y < sizeY; y++) {
+        const row = new Array<any>(sizeX);
+        grid.push(row);
+    }
+
+    return grid;
+}
+
+function moveByAngle(
+    origin: [Meter, Meter],
+    angle: Radians,
+    distance: Meter
+): [Meter, Meter] {
+    const long = origin[0] + distance * Math.cos(angle);
+    const lat = origin[1] + distance * Math.sin(angle);
+    return [long, lat];
+}
+
+
+
+export function createfillGrid(
+    globe: Globe,
+    origin: LongLat,
+    startX: number, startY: number,
+    rowSize: number, columnSize: number,
+    cellSizeX: Meter, cellSizeY: Meter,
+    rotaionAngle: CentigradeDegree = 0
+): LongLat[][] {
+
+    const originMercator = globe.api_GetMercator2DPoint(origin[0], origin[1]);
+    const angleRadians = rotaionAngle * (Math.PI / 180);
+    const grid = createGrid(rowSize, columnSize);
+
+    // Set the origin point first
+    grid[startY][startX] = originMercator;
+
+    // fill single vertical row from origin - to the right
+    let lastPoint = originMercator;
+    for (let i = startX + 1; i < rowSize; i++) {
+        const [long, lat] = moveByAngle(
+            lastPoint,
+            angleRadians,
+            cellSizeX
+        );
+        lastPoint = [long, lat];
+        grid[startY][i] = [long, lat];
+    }
+
+    // fill single vertical row from origin - to the left
+    lastPoint = originMercator;
+    for (let i = startX - 1; i >= 0; i--) {
+        const [long, lat] = moveByAngle(
+            lastPoint,
+            Math.PI + angleRadians,
+            cellSizeX
+        );
+        lastPoint = [long, lat];
+        grid[startY][i] = [long, lat];
+    }
+
+    // fill single horizontal from origin from startY to 0
+    console.log("grid", grid);
+
+    for (let i = startY - 1; i >= 0; i--) {
+        for (let j = 0; j < rowSize; j++) {
+            const [long, lat] = moveByAngle(
+                grid[i + 1][j],
+                angleRadians - Math.PI / 2,
+                cellSizeY
+            );
+            grid[i][j] = [long, lat];
+        }
+    }
+
+    // fill single horizontal from origin from startY to last row
+    for (let i = startY + 1; i < columnSize; i++) {
+        for (let j = 0; j < rowSize; j++) {
+            const [long, lat] = moveByAngle(
+                grid[i - 1][j],
+                angleRadians + Math.PI / 2,
+                cellSizeY
+            );
+            grid[i][j] = [long, lat];
+        }
+    }
+
+    // Convert from mercator meters to longitude/latitude
+    for (let i = 0; i < columnSize; i++) {
+        for (let j = 0; j < rowSize; j++) {
+            const [long, lat] = mercatorMeterToLongLat(
+                grid[i][j][0],
+                grid[i][j][1]
+            );
+            grid[i][j] = [long, lat];
+        }
+    }
+    return grid;
+}

package/Math/types.ts

@@ -0,0 +1,66 @@
+type Radians = number;
+type Degrees = number;
+type Meter = number;
+type Fraction = number; // between 0 and 1
+type WGS84 = [number, number]; // [longitude, latitude]
+type Vec2 = [number, number]; // [x, y] or [longitude, latitude] in Mercator projection
+type Vec3 = [number, number, number];
+type Vec4 = [number, number, number, number];
+
+type Line = {
+    origin: Vec3;
+    direction: Vec3;
+}
+
+
+
+type Plane = {
+    normal: Vec3;
+    distance: number;
+};
+
+type LongLat = [number, number]; // [longitude, latitude]
+
+type Quaternion = [number, number, number, number];
+
+type Arc = {
+    p0: Vec3;
+    p1: Vec3;
+    normal: Vec3;
+    coverPlane: Plane;
+    coverAngle?: Radians;
+}
+
+type Sphere = {
+    center: Vec3;
+    radius: number;
+}
+
+type Circle = {
+    center: LongLat;
+    radius: Meter; // in meters
+}
+
+type CircleClosestAzimuthAngleProperties = {
+    normal: Vec3;
+    northPointProjectedToOriginPlaneNormalized: Vec3;
+}
+
+export {
+    Vec2,
+    Vec3,
+    Vec4,
+    Line,
+    Plane,
+    Quaternion,
+    Fraction,
+    WGS84,
+    Arc,
+    Sphere,
+    Radians,
+    Degrees,
+    Meter,
+    LongLat,
+    Circle,
+    CircleClosestAzimuthAngleProperties
+}

package/Math/utils.js

@@ -1,2 +1,3 @@
-import { Vector3D } from "./vector3d";
-import { Quaternion } from "./quaternion";
+import { Vector3D } from "./vector3d";
+import { Quaternion } from "./quaternion";
+