@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/Math/juction/{plane-plane.js → plane-plane.ts}

@@ -1,53 +1,62 @@
-import { EPSILON } from "../constants";
-import { dot, cross, lengthSquared } from "../vec3";
-export function planePlaneJunction(out, plane1, plane2) {
-    const _normal1 = plane1.normal;
-    const _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;
-    // 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;
-}
+import { Plane, Line, Vec3 } from "../types";
+import { EPSILON } from "../constants";
+import { copy, create, dot, cross, lengthSquared } from "../vec3";
+
+
+export function planePlaneJunction(out: Line, plane1: Plane, plane2: Plane): boolean {
+    const _normal1 = plane1.normal;
+    const _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.js → line.ts}

@@ -1,52 +1,84 @@
-import { EPSILON } from './constants';
-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()) {
-    const direction_ = vec3clone(direction);
-    normalize(direction_, direction_);
-    return {
-        origin: vec3clone(origin),
-        direction: direction_
-    };
-}
-function set(out, origin, direction) {
-    vec3copy(out.origin, origin);
-    vec3copy(out.direction, direction);
-}
-function copy(out, a) {
-    out.origin = vec3copy(out.origin, a.origin);
-    out.direction = vec3copy(out.direction, a.direction);
-}
-function clone(a) {
-    return {
-        origin: vec3clone(a.origin),
-        direction: vec3clone(a.direction)
-    };
-}
-function fromTwoPoints(out, a, b) {
-    subtract(out.direction, b, a);
-    normalize(out.direction, out.direction);
-    vec3copy(out.origin, a);
-}
-function at(out, line, distance) {
-    multiplyScalar(_0vector, line.direction, distance);
-    add(out, _0vector, line.origin);
-}
-function closestPoint(out, line, point) {
-    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, point) {
-    subtract(_0vector, point, line.origin);
-    cross(_0vector, _0vector, line.direction);
-    return lengthSquared(_0vector) < EPSILON;
-}
-function applyQuaternion(out, line, 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 };
+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/mesh/mapbox-delaunay.d.ts

@@ -0,0 +1,74 @@
+export default class Delaunator {
+    /**
+     * Constructs a delaunay triangulation object given an array of points (`[x, y]` by default).
+     * `getX` and `getY` are optional functions of the form `(point) => value` for custom point formats.
+     */
+    static from<P>(
+        points: P[],
+        getX?: (p: P) => number,
+        getY?: (p: P) => number
+    ): Delaunator;
+
+    /**
+     * Constructs a delaunay triangulation object given an array of point coordinates of the form:
+     * `[x0, y0, x1, y1, ...]` (use a typed array for best performance). Duplicate points are skipped.
+     */
+    constructor(coords: ArrayLike<number>);
+
+    /** The input coordinates array */
+    coords: ArrayLike<number>;
+
+    /** A `Uint32Array` array of indices that reference points on the convex hull of the input data, counter-clockwise. */
+    hull: Uint32Array;
+
+    /** A `Uint32Array` array of triangle vertex indices (each group of three numbers forms a triangle). All triangles are directed counterclockwise. */
+    triangles: Uint32Array;
+
+    /**
+     * A `Int32Array` array of triangle half-edge indices that allows you to traverse the triangulation.
+     * `i`-th half-edge in the array corresponds to vertex `triangles[i]` the half-edge is coming from.
+     * `halfedges[i]` is the index of a twin half-edge in an adjacent triangle (or `-1` for outer half-edges on the convex hull).
+     */
+    halfedges: Int32Array;
+
+    /**
+     * Updates the triangulation if you modified `delaunay.coords` values in place, avoiding expensive memory allocations.
+     * Useful for iterative relaxation algorithms such as Lloyd's.
+     */
+    update(): void;
+
+    // Private properties and methods
+    private _triangles: Uint32Array;
+    private _halfedges: Int32Array;
+    private _hashSize: number;
+    private _hullPrev: Uint32Array;
+    private _hullNext: Uint32Array;
+    private _hullTri: Uint32Array;
+    private _hullHash: Int32Array;
+    private _ids: Uint32Array;
+    private _dists: Float64Array;
+    private trianglesLen: number;
+    private _cx: number;
+    private _cy: number;
+    private _hullStart: number;
+
+    private _hashKey(x: number, y: number): number;
+    private _legalize(a: number): number;
+    private _link(a: number, b: number): void;
+    private _addTriangle(i0: number, i1: number, i2: number, a: number, b: number, c: number): number;
+}
+
+// Utility functions (not exported in the original module)
+declare function pseudoAngle(dx: number, dy: number): number;
+declare function dist(ax: number, ay: number, bx: number, by: number): number;
+declare function inCircle(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, px: number, py: number): boolean;
+declare function circumradius(ax: number, ay: number, bx: number, by: number, cx: number, cy: number): number;
+declare function circumcenter(ax: number, ay: number, bx: number, by: number, cx: number, cy: number): { x: number; y: number };
+declare function quicksort(ids: Uint32Array, dists: Float64Array, left: number, right: number): void;
+declare function swap(arr: Uint32Array, i: number, j: number): void;
+declare function defaultGetX(p: [number, number]): number;
+declare function defaultGetY(p: [number, number]): number;
+
+// Constants
+declare const EPSILON: number;
+declare const EDGE_STACK: Uint32Array;

package/Math/{methods.js → methods.ts}

@@ -1,107 +1,182 @@
-import { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR } from './constants';
-import { dot as dot3, copy as copy3 } from './vec3';
-export const RADIAN = 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];
-    output[0] = Math.atan2(y, x); // longitude
-    output[1] = Math.asin(z); // latitude
-};
-export const radianToMercator = (xy) => {
-    return [
-        WORLD_RADIUS_MERCATOR * xy[0],
-        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))
-    ];
-};
-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];
-};
-export const sphericalLinearInterpolation_UnitVector = (output, normalizedA, normalizedB, ratio) => {
-    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, 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;
-    output[0] = _0vec3[0] * height;
-    output[1] = _0vec3[1] * height;
-    output[2] = _0vec3[2] * height;
-};
-export const wgs84ToCartesian3d = (output, long, lat, height) => {
-    const longRad = long * RADIAN;
-    const latRad = lat * RADIAN;
-    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, lat) => {
-    return [
-        WORLD_RADIUS_MERCATOR * long * RADIAN,
-        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIAN / 2))
-    ];
-};
-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];
-};
-export const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
-    const [long, lat] = pixelXYToRadians([pixelXYHeight[0], pixelXYHeight[1]]);
-    const radius = WORLD_RADIUS_3D + pixelXYHeight[2];
-    return [...radianToCartesian3d([long, lat]), radius];
-};
-export const globe3Dcoordinates = (globe, longlats, height = 0, msl = false, { 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, msl);
-        result.set(xyz, i * 3);
-    }
-    return result;
-};
-const manhattanDistance = (a, b) => {
-    return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);
-};
-export const globe2Dcoordinates = (globe, distanceFilterMeter = WORLD_RADIUS_MERCATOR) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
-    let _lastXY = [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;
-};
+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, GlobeBBox } from '../types';
+
+export const RADIAN = 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 function radianToMercatorXY(xy: Vec2): Vec2 {
+    return [
+        xy[0],
+        Math.log(Math.tan(Math.PI / 4 + xy[1] / 2)),
+    ];
+}
+
+export function globeBBoxToXYBBOX(t: GlobeBBox): { ll: [number, number], ur: [number, number] } {
+    // this code scales Y to linear integration
+
+    return {
+        ll: radianToMercatorXY([t.ll.x * RADIAN, t.ll.y * RADIAN]),  // west longitude, north latitude
+        ur: radianToMercatorXY([t.ur.x * RADIAN, t.ur.y * RADIAN])   // east longitude, south latitude
+    };
+}
+
+
+export function tileXY2Radian(x: number, y: number, zoom: number): LongLat {
+    const n = Math.pow(2, zoom);
+    const long = x / n * 2 * Math.PI - Math.PI;
+    const lat = Math.atan(Math.sinh(Math.PI - (y / n * 2 * Math.PI)));
+    return [long, lat];
+}
+
+
+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 * RADIAN;
+    const latRad = lat * RADIAN;
+    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 * RADIAN,
+        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIAN / 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;
+};