@pirireis/webglobeplugins 0.16.0 → 0.16.1

package/Math/juction/plane-plane.ts

@@ -1,64 +0,0 @@
-import { Plane, Line, Vec3 } from "../types";
-import { EPSILON } from "../constants";
-import { copy, create, dot, cross, lengthSquared } from "../vec3";
-
-const _normal1 = create();
-const _normal2 = create();
-
-export function planePlaneJuction(out: Line, plane1: Plane, plane2: Plane): boolean {
-    copy(_normal1, plane1.normal);
-    copy(_normal2, plane2.normal);
-    const distance1 = plane1.distance;
-    const distance2 = plane2.distance;
-
-    const { origin, direction } = out;
-
-    const d = dot(_normal1, _normal2);
-
-    if (Math.abs(d) > 1 - EPSILON) {
-        return false; // Planes are parallel, no intersection
-    }
-
-    cross(direction, _normal1, _normal2);
-
-    const magnitudeSquired = lengthSquared(out.direction);
-    if (magnitudeSquired < EPSILON) {
-        return false; // No valid intersection line
-    }
-
-    const magnitude = Math.sqrt(magnitudeSquired);
-    direction[0] /= magnitude;
-    direction[1] /= magnitude;
-    direction[2] /= magnitude;
-
-
-
-    let determinant: number;
-    // Calculate the intersection point
-    // set z = 0
-    determinant = _normal1[0] * _normal2[1] - _normal1[1] * _normal2[0];
-    if (Math.abs(determinant) > EPSILON) {
-        origin[0] = (distance1 * _normal2[1] - distance2 * _normal1[1]) / determinant;
-        origin[1] = (distance2 * _normal1[0] - distance1 * _normal2[0]) / determinant;
-        origin[2] = 0;
-    } else {
-        // set y = 0
-        determinant = _normal1[0] * _normal2[2] - _normal1[2] * _normal2[0];
-        if (Math.abs(determinant) > EPSILON) {
-            origin[0] = (distance1 * _normal2[2] - distance2 * _normal1[2]) / determinant;
-            origin[1] = 0;
-            origin[2] = (distance2 * _normal1[0] - distance1 * _normal2[0]) / determinant;
-        } else {
-            // set x = 0
-            determinant = _normal1[1] * _normal2[2] - _normal1[2] * _normal2[1];
-            if (Math.abs(determinant) > EPSILON) {
-                origin[0] = 0;
-                origin[1] = (distance1 * _normal2[2] - distance2 * _normal1[2]) / determinant;
-                origin[2] = (distance2 * _normal1[1] - distance1 * _normal2[1]) / determinant;
-            } else {
-                return false; // No valid intersection point
-            }
-        }
-    }
-    return true;
-}

package/Math/line.ts

@@ -1,84 +0,0 @@
-import { EPSILON } from './constants';
-import { Vec3, Line, Quaternion } from './types';
-import {
-    subtract,
-    applyQuaternion as vec3applyQuaternion,
-    add,
-    multiplyScalar,
-    normalize,
-    dot,
-    cross,
-    lengthSquared,
-    clone as vec3clone,
-    create as vec3create,
-    copy as vec3copy
-} from './vec3';
-
-
-const _0vector = /*@__PURE__*/ vec3create(0, 0, 0);
-
-
-function create(origin = vec3create(), direction = vec3create()): Line {
-    const direction_ = vec3clone(direction);
-    normalize(direction_, direction_);
-    return {
-        origin: vec3clone(origin),
-        direction: direction_
-    };
-}
-
-function set(out: Line, origin: Vec3, direction: Vec3) {
-    vec3copy(out.origin, origin);
-    vec3copy(out.direction, direction);
-}
-
-function copy(out: Line, a: Line) {
-    out.origin = vec3copy(out.origin, a.origin);
-    out.direction = vec3copy(out.direction, a.direction);
-}
-
-function clone(a: Line): Line {
-    return {
-        origin: vec3clone(a.origin),
-        direction: vec3clone(a.direction)
-    }
-}
-
-function fromTwoPoints(out: Line, a: Vec3, b: Vec3) {
-    subtract(out.direction, b, a);
-    normalize(out.direction, out.direction);
-    vec3copy(out.origin, a);
-}
-
-function at(out: Vec3, line: Line, distance: number) {
-    multiplyScalar(_0vector, line.direction, distance);
-    add(out, _0vector, line.origin);
-}
-
-
-function closestPoint(out: Vec3, line: Line, point: Vec3) {
-    subtract(_0vector, point, line.origin);
-    const dot_ = dot(_0vector, line.direction);
-    vec3copy(out, line.direction);
-    multiplyScalar(out, out, dot_);
-    add(out, out, line.origin);
-}
-
-
-function contains(line: Line, point: Vec3): boolean {
-    subtract(_0vector, point, line.origin);
-    cross(_0vector, _0vector, line.direction);
-    return lengthSquared(_0vector) < EPSILON;
-}
-
-function applyQuaternion(out: Line, line: Line, quaternion: Quaternion) {
-    vec3applyQuaternion(out.origin, line.origin, quaternion);
-    vec3applyQuaternion(out.direction, line.direction, quaternion);
-    normalize(out.direction, out.direction);
-}
-
-export {
-    create,
-    set,
-    copy, clone, fromTwoPoints, at, closestPoint, contains, applyQuaternion
-}

package/Math/methods.ts

@@ -1,157 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,10 +0,0 @@
-
-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

@@ -1,119 +0,0 @@
-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;
-}