@pirireis/webglobeplugins 0.16.7 → 0.17.0

package/Math/angle-calculation.js

@@ -1,3 +1,4 @@
+const Radians = Math.PI / 180;
 function bearingRealAngle(long, lat, endLong, endLat) {
     const rLong = Radians * long;
     const rLat = Radians * lat;

package/Math/contour/quadtreecontours.js

@@ -0,0 +1,300 @@
+// © 2019 3D Robotics. License: Apache-2.0
+const OUTSIDE = 0;
+const ABOVE = 1;
+const BELOW = 2;
+const WITHIN = 3;
+// Build mipmap layer N from layer N+1
+function mipmapReduce({ min, max, width, height, scale }) {
+    const outWidth = Math.ceil(width / 2);
+    const outHeight = Math.ceil(height / 2);
+    function reduceWith(data, reduce) {
+        const out = new Float32Array(outWidth * outHeight);
+        let x;
+        let y;
+        for (y = 0; y < Math.floor(height / 2); y++) {
+            for (x = 0; x < Math.floor(width / 2); x++) {
+                out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 0) * width + (x * 2 + 1)], data[(y * 2 + 1) * width + (x * 2 + 0)], data[(y * 2 + 1) * width + (x * 2 + 1)]);
+            }
+            if (x < outWidth) {
+                out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 1) * width + (x * 2 + 0)]);
+            }
+        }
+        if (y < outHeight) {
+            for (x = 0; x < Math.floor(width / 2); x++) {
+                out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 0) * width + (x * 2 + 1)]);
+            }
+        }
+        //@ts-ignore
+        if (x < outWidth && y < outHeight) {
+            //@ts-ignore
+            out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)]);
+        }
+        return out;
+    }
+    function minFinite(...args) {
+        let r = Infinity;
+        for (let i = 0; i < args.length; i++) {
+            const v = args[i];
+            if (v < r)
+                r = v;
+        }
+        return r;
+    }
+    function maxFinite(...args) {
+        let r = -Infinity;
+        for (let i = 0; i < args.length; i++) {
+            const v = args[i];
+            if (v > r)
+                r = v;
+        }
+        return r;
+    }
+    return {
+        min: reduceWith(min, minFinite),
+        max: reduceWith(max, maxFinite),
+        width: outWidth,
+        height: outHeight,
+        scale: scale * 2,
+    };
+}
+class ContourMipmap {
+    levels;
+    constructor(raster, width, height) {
+        // Bottom mipmap layer is just the raster: at each pixel the minimum and maximum are the same
+        this.levels = [{ min: raster, max: raster, width, height, scale: 1 }];
+        while (this.levels[0].width > 1 || this.levels[0].height > 1) {
+            this.levels.unshift(mipmapReduce(this.levels[0]));
+        }
+    }
+    // Get the minimum elevation in the mipmap
+    min() { return this.levels[0].min[0]; }
+    // Get the maximum elevation in the mipmap
+    max() { return this.levels[0].max[0]; }
+    // Get an array of contour levels for a specified contour interval
+    intervals(interval) {
+        if (interval <= 0)
+            throw new Error('Contour interval must be positive');
+        const min = this.min();
+        const max = this.max();
+        const levels = [];
+        let level = Math.ceil(min / interval) * interval;
+        while (level < max) {
+            levels.push(level);
+            level += interval;
+        }
+        return levels;
+    }
+    // Walk the quadtree for a specified contour level, and pass quadtree nodes
+    // and contour line segments to the callbacks. This is used for visualizing
+    // the quadtree; in most cases you should use .contour() instead, which
+    // assembles the line segments into lines and rings.
+    evaluateContour(contourLevel, { maxMipmapLevel }, addLine, addNode) {
+        maxMipmapLevel = maxMipmapLevel || this.levels.length - 1;
+        // Test the mipmap at the given coordinate and level, returning whether the contour line is ABOVE, BELOW, or WITHIN this mipmap cell
+        // If the mipmap is out of bounds or NaN at that point, OUTSIDE is returned.
+        const evaluate = (l, x, y) => {
+            const ml = this.levels[l];
+            const i = ml.width * y + x;
+            if (x >= ml.width || y >= ml.height || !Number.isFinite(ml.min[i]) || !Number.isFinite(ml.max[i]))
+                return OUTSIDE;
+            if (ml.min[i] >= contourLevel)
+                return ABOVE;
+            if (ml.max[i] < contourLevel)
+                return BELOW;
+            // If we've reached the maximum mipmap level, arbitrarily decide that cells that contain
+            // the contour elevation go inside the contour line.
+            if (l >= maxMipmapLevel)
+                return ABOVE;
+            return WITHIN;
+        };
+        // Add any vertical contour lines that exist between passed mipmap cell and
+        // its horizontal neighbor to the right. If the line exists at this mipmap
+        // level, it is added directly, otherwise split the edge and recurse at a
+        // more detailed mipmap level.
+        const edgeH = (l, x, y) => {
+            const e1 = evaluate(l, x, y);
+            const e2 = evaluate(l, x + 1, y);
+            if (e1 === ABOVE && e2 === BELOW) {
+                addLine(l, x + 1, y + 1, x + 1, y);
+            }
+            else if (e2 === ABOVE && e1 === BELOW) {
+                // reverse order of coordinates compared to case above so that lines
+                // go counterclockwise around the region above the contour value
+                addLine(l, x + 1, y, x + 1, y + 1);
+            }
+            else if (e1 === WITHIN || e2 === WITHIN) {
+                edgeH(l + 1, x * 2 + 1, y * 2 + 0);
+                edgeH(l + 1, x * 2 + 1, y * 2 + 1);
+            }
+        };
+        // Like edgeH, but for horizontal contour lines between the passed cell
+        // and its vertical neighbor below.
+        const edgeV = (l, x, y) => {
+            const e1 = evaluate(l, x, y);
+            const e2 = evaluate(l, x, y + 1);
+            if (e1 === ABOVE && e2 === BELOW) {
+                addLine(l, x, y + 1, x + 1, y + 1);
+            }
+            else if (e2 === ABOVE && e1 === BELOW) {
+                addLine(l, x + 1, y + 1, x, y + 1);
+            }
+            else if (e1 === WITHIN || e2 === WITHIN) {
+                edgeV(l + 1, x * 2 + 0, y * 2 + 1);
+                edgeV(l + 1, x * 2 + 1, y * 2 + 1);
+            }
+        };
+        // Add all contour lines within a mipmap cell.
+        // It recurses into the four quadrants of the cell, and also uses edgeH and
+        // edgeV to add the contour lines that exist between quadrants.
+        const node = (l, x, y) => {
+            const e = evaluate(l, x, y);
+            if (e === WITHIN) {
+                node(l + 1, x * 2 + 0, y * 2 + 0);
+                node(l + 1, x * 2 + 1, y * 2 + 0);
+                node(l + 1, x * 2 + 0, y * 2 + 1);
+                node(l + 1, x * 2 + 1, y * 2 + 1);
+                edgeH(l + 1, x * 2 + 0, y * 2 + 0);
+                edgeV(l + 1, x * 2 + 0, y * 2 + 0);
+                edgeH(l + 1, x * 2 + 0, y * 2 + 1);
+                edgeV(l + 1, x * 2 + 1, y * 2 + 0);
+            }
+            else {
+                if (addNode)
+                    addNode(l, x, y, e);
+            }
+        };
+        node(0, 0, 0);
+    }
+    // Generate a contour line for a specified value
+    //
+    // level: Value in the input array at which to draw a contour line
+    // opts: {
+    //   maxMipmapLevel: Maximum recursion depth in the mipmap. As if you rescaled
+    //                   the input to a maximum dimension of 2^n pixels.
+    //                   (default unlimited)
+    //   minPoints: Lines and rings with fewer points are removed. (default 0)
+    //   smoothKernelWidth: Width of the rectangular filter for smoothing (default 2)
+    //   smoothCycles: Number of iterations of smoothing (default 2)
+    // }
+    //
+    // Returns an array of lines, where each line is an array of [x, y] pairs.
+    contour(level, { maxMipmapLevel, smoothKernelWidth = 2, smoothCycles = 2, minPoints = 0 } = {}) {
+        // Use the quadtree algorithm to generate line segments that make up the contour
+        const segments = [];
+        this.evaluateContour(level, { maxMipmapLevel }, (l, x1, y1, x2, y2) => {
+            const scale = this.levels[l].scale;
+            const start = [scale * x1, scale * y1];
+            const end = [scale * x2, scale * y2];
+            segments.push({ start, end });
+        });
+        segments.sort((a, b) => key(a.start) - key(b.start));
+        // .. and then join them together into rings
+        // An arbitrary function to use a 2D point as a Map key
+        function key(a) { return a[0] + a[1] * 65536; }
+        const fragmentStart = new Map();
+        const fragmentEnd = new Map();
+        const rings = [];
+        segments.forEach(({ start, end }) => {
+            const a = fragmentEnd.get(key(start));
+            const b = fragmentStart.get(key(end));
+            if (a && b) {
+                fragmentEnd.delete(key(start));
+                fragmentStart.delete(key(end));
+                if (a === b) {
+                    // Close a ring
+                    a.push(end);
+                    rings.push(a);
+                }
+                else {
+                    // Join two lines together
+                    const c = a.concat(b);
+                    fragmentStart.set(key(c[0]), c);
+                    fragmentEnd.set(key(c[c.length - 1]), c);
+                }
+            }
+            else if (a) {
+                // Extend an existing line from the end
+                fragmentEnd.delete(key(start));
+                a.push(end);
+                fragmentEnd.set(key(end), a);
+            }
+            else if (b) {
+                // Extend an existing line from the start
+                fragmentStart.delete(key(end));
+                b.unshift(start);
+                fragmentStart.set(key(start), b);
+            }
+            else {
+                // New line doesn't connect to any existing line
+                const c = [start, end];
+                fragmentStart.set(key(start), c);
+                fragmentEnd.set(key(end), c);
+            }
+            if (fragmentStart.size !== fragmentEnd.size) {
+                console.error(`Contour remaining fragment size mismatch ${fragmentStart.size} ${fragmentEnd.size}`);
+            }
+        });
+        const smoothOpts = {
+            kernelWidth: smoothKernelWidth,
+            cycles: smoothCycles,
+        };
+        // Closed rings and any unclosed line strings
+        return [...rings, ...fragmentStart.values()]
+            .filter(l => l.length >= minPoints && l.length >= smoothKernelWidth * 2)
+            .map(l => smooth(l, smoothOpts));
+    }
+}
+// Smooth a line by repeatedly applying a rectangular filter to approximate
+// a gaussian filter. It detects closed loops and preserves them.
+// The line is passed as an array of `[x, y]` pairs.
+//
+// kernelWidth: Width of the rectangular filter kernel
+// cycles: Number of times to apply the kernel
+function smooth(line, { kernelWidth = 2, cycles = 2 }) {
+    const isLoop = line[0][0] === line[line.length - 1][0] && line[0][1] === line[line.length - 1][1];
+    let pointAt;
+    if (isLoop) {
+        pointAt = (i) => line[(i + line.length) % line.length];
+    }
+    else {
+        pointAt = (i) => line[Math.min(Math.max(i, 0), line.length - 1)];
+    }
+    const sc = 1.0 / (kernelWidth * 2);
+    for (let cycle = 0; cycle < cycles; cycle++) {
+        let px = 0;
+        let py = 0;
+        if (isLoop) {
+            for (let i = line.length - kernelWidth; i < line.length; i++) {
+                px += line[i][0];
+                py += line[i][1];
+            }
+        }
+        else {
+            px = line[0][0] * kernelWidth;
+            py = line[0][1] * kernelWidth;
+        }
+        for (let i = 0; i < kernelWidth; i++) {
+            px += line[i][0];
+            py += line[i][1];
+        }
+        const res = line.slice();
+        for (let i = 0; i < line.length; i++) {
+            res[i] = [px * sc, py * sc];
+            px += pointAt(i + kernelWidth)[0] - pointAt(i - kernelWidth)[0];
+            py += pointAt(i + kernelWidth)[1] - pointAt(i - kernelWidth)[1];
+        }
+        if (isLoop) {
+            // Keep the loop closed
+            res[res.length - 1] = res[0].slice();
+        }
+        line = res;
+    }
+    return line;
+}
+function scaleParameters(minLongitude, minLatitude, maxLongitude, maxLatitude, width, height) {
+    const scaleX = (maxLongitude - minLongitude) / width;
+    const scaleY = (maxLatitude - minLatitude) / height;
+    return { scaleX, scaleY };
+}
+export default ContourMipmap;
+export { scaleParameters };

package/Math/finite-line-2d.js

@@ -0,0 +1,58 @@
+function junctionPoint(out, inLine, origin, slope) {
+    const x0 = inLine[0];
+    const y0 = inLine[1];
+    const x1 = inLine[0];
+    const y1 = inLine[1];
+    const m1 = (y1 - y0) / (x1 - x0); // slope of line
+    const b1 = y0 - m1 * x0; // y-intercept of line
+    const m2 = slope;
+    const b2 = origin[1] - m2 * origin[0]; // y-intercept of line
+    if (m1 === m2) {
+        return 0; // parallel lines
+    }
+    const x = (b2 - b1) / (m1 - m2);
+    const y = m1 * x + b1;
+    // check if point is within line segment
+    if (x < Math.min(x0, x1) || x > Math.max(x0, x1) ||
+        y < Math.min(y0, y1) || y > Math.max(y0, y1)) {
+        return 0;
+    }
+    out[0] = x;
+    out[1] = y;
+    return 1;
+}
+export function junctionVerticalOrHorizontalLines(out, inLine1, value, isVertical) {
+    const x0 = inLine1[0];
+    const y0 = inLine1[1];
+    const x1 = inLine1[0];
+    const y1 = inLine1[1];
+    if (isVertical) {
+        // vertical line x = value
+        const m1 = (y1 - y0) / (x1 - x0);
+        const b1 = y0 - m1 * x0;
+        const y = m1 * value + b1;
+        // check if point is within line segment
+        if (y < Math.min(y0, y1) || y > Math.max(y0, y1)) {
+            return 0;
+        }
+        out[0] = value;
+        out[1] = y;
+        return 1;
+    }
+    else {
+        // horizontal line y = value
+        const m1 = (y1 - y0) / (x1 - x0);
+        const b1 = y0 - m1 * x0;
+        if (m1 === 0) {
+            return 0; // parallel lines
+        }
+        const x = (value - b1) / m1;
+        // check if point is within line segment
+        if (x < Math.min(x0, x1) || x > Math.max(x0, x1)) {
+            return 0;
+        }
+        out[0] = x;
+        out[1] = value;
+        return 1;
+    }
+}

package/Math/tessellation/hybrid-triangle-tessellation-meta.js

@@ -0,0 +1,123 @@
+/**
+ * @author Toprak Ozturk
+ */
+import { equals, fromLongLatToUnitVector, fromUnitVectorToLongLat } from "../vec3";
+import { pointsOnArc } from "../juction/arc-plane";
+import { junctionVerticalOrHorizontalLines } from "../finite-line-2d";
+// TODO:get rid of embedded lists. always flat list
+const TILE_DEM_VERTEX_COUNT = 5; // 5x5 grid for DEM
+const TILE_DEM_STEPCOUNT = TILE_DEM_VERTEX_COUNT - 1; // 4 inner divisions in each dimension
+var EdgeType;
+(function (EdgeType) {
+    EdgeType[EdgeType["ARC"] = 0] = "ARC";
+    EdgeType[EdgeType["LINEAR"] = 1] = "LINEAR";
+})(EdgeType || (EdgeType = {}));
+const _tempVec2 = /*@__PURE__*/ [0, 0];
+const _plane = /*@__PURE__*/ { normal: [0, 0, 0], distance: 0 };
+const _resultPoints = /*@__PURE__*/ [[0, 0, 0], [0, 0, 0]];
+/**
+ *
+ * @param triangleMeta
+ * @param zoom
+ * @param angle
+ * @param dimension false for longitude (meridian) true for latitude (parallel)
+ */
+function getPoints(triangleMeta, angle, dimension) {
+    // console.log("getPoints called with angle:", angle * 180 / Math.PI, "dimension:", dimension ? 'latitude' : 'longitude');
+    // find which arcs are cut by plane
+    const radians = angle;
+    if (dimension) {
+        _plane.normal[0] = 0;
+        _plane.normal[1] = 0;
+        _plane.normal[2] = 1;
+        _plane.distance = Math.sin(radians);
+    }
+    else {
+        _plane.normal[0] = Math.sin(radians);
+        _plane.normal[1] = -Math.cos(radians);
+        _plane.normal[2] = 0;
+        _plane.distance = 0;
+    }
+    let result = [];
+    // Add debugging
+    let resultsFromDistinctEdges = 0;
+    for (let i = 0; i < 3; i++) {
+        const edgeType = triangleMeta.edgeTypes[i];
+        const edge = triangleMeta.edges[i];
+        const coordIndex = dimension ? 1 : 0;
+        const minCoord = edge.bbox.min[coordIndex];
+        const maxCoord = edge.bbox.max[coordIndex];
+        if (minCoord > angle || maxCoord < angle) {
+            continue; // edge is out of range
+        }
+        let count = 0;
+        if (edgeType === EdgeType.ARC) {
+            count = pointsOnArc(edge, _plane, _resultPoints);
+            if (count === 1) {
+                fromUnitVectorToLongLat(_tempVec2, _resultPoints[0]);
+                result.push([[..._resultPoints[0]], [..._tempVec2]]);
+            }
+            else if (count === 2) {
+                // throw new Error('Unexpected 2 cut points on arc, should be max 1'); // TODO DELETE this line later
+                fromUnitVectorToLongLat(_tempVec2, _resultPoints[0]);
+                result.push([[..._resultPoints[0]], [..._tempVec2]]);
+                fromUnitVectorToLongLat(_tempVec2, _resultPoints[1]);
+                result.push([[..._resultPoints[1]], [..._tempVec2]]); // TODO: this is a fix for a bug, need to investigate later
+            }
+        }
+        else {
+            // linear line
+            count = junctionVerticalOrHorizontalLines(_tempVec2, edge.line, angle, dimension);
+            if (count === 1) {
+                fromLongLatToUnitVector(_resultPoints[0], _tempVec2);
+                result.push([[..._resultPoints[0]], [..._tempVec2]]);
+            }
+        }
+        resultsFromDistinctEdges += 1;
+    }
+    if (resultsFromDistinctEdges === 3) {
+        result = filterDuplicate(result);
+    }
+    if (result.length !== 2 && result.length !== 4) {
+        // TODO: THERE is a case where 4 points are found.
+        // this happens when two arcs has limit and share space in Z dimension
+        console.log("ERROR");
+        const text = 'Angle:' + angle + ' dimension:' + (dimension ? 'latitude' : 'longitude') + "\n" +
+            'Result points count:' + result.length + "\n" +
+            "bbox:" + triangleMeta.bbox.min[0] * 180 / Math.PI + ", " + triangleMeta.bbox.min[1] * 180 / Math.PI + ", " + triangleMeta.bbox.max[0] * 180 / Math.PI + ", " + triangleMeta.bbox.max[1] * 180 / Math.PI + "\n";
+        for (let res of result) {
+            const ll = res[1];
+            console.log("Point: " + ll[0] * 180 / Math.PI + ", " + ll[1] * 180 / Math.PI + "\n");
+        }
+        throw new Error(`Unexpected cut count for tile cut, got: ${result.length}, angle: ${angle * 180 / Math.PI}, dimension: ${dimension ? 'latitude' : 'longitude'} \n` + text);
+    }
+    // TODO: i want to see it delete later
+    if (result.length === 4) {
+        console.warn("Warning: 4 cut points found on triangle for angle:", angle * 180 / Math.PI, "dimension:", dimension ? 'latitude' : 'longitude', "points:", result);
+    }
+    result.sort((a, b) => {
+        if (dimension) {
+            return a[1][0] - b[1][0]; // sort by y for longitude cuts
+        }
+        else {
+            return a[1][1] - b[1][1]; // sort by x for latitude cuts
+        }
+    });
+    return result;
+}
+function filterDuplicate(points) {
+    const result = [points[0]];
+    let dublicate = false;
+    for (let i = 1; i < points.length; i++) {
+        for (let j = 0; j < result.length; j++) {
+            if (equals(points[i][0], result[j][0])) {
+                dublicate = true;
+                break;
+            }
+        }
+        if (!dublicate) {
+            result.push(points[i]);
+        }
+    }
+    return result;
+}

package/Math/tessellation/tile-merger.js

@@ -0,0 +1,56 @@
+"use strict";
+function _sortXY(a, b) {
+    if (a.y === b.y) {
+        return a.x - b.x;
+    }
+    return a.y - b.y;
+}
+function groupByZoomLevel(tiles) {
+    const map = new Map();
+    for (const tile of tiles) {
+        if (!map.has(tile.z)) {
+            map.set(tile.z, []);
+        }
+        map.get(tile.z).push(tile);
+    }
+    map.forEach((tileList, z) => {
+        tileList.sort(_sortXY);
+    });
+    return map;
+}
+function _insertDEM(sourceDEM, sourceWidth, sourceHeight, targetDEM, targetWidth, targetHeight, offsetX, offsetY) {
+    for (let row = 0; row < sourceHeight; row++) {
+        for (let col = 0; col < sourceWidth; col++) {
+            const sourceIndex = row * sourceWidth + col;
+            const targetIndex = (row + offsetY) * targetWidth + (col + offsetX);
+            targetDEM[targetIndex] = sourceDEM[sourceIndex];
+        }
+    }
+}
+function mergeTiles(tiles, demWidth, demHeight) {
+    let minX = Number.MAX_VALUE;
+    let maxX = Number.MIN_VALUE;
+    let minY = Number.MAX_VALUE;
+    let maxY = Number.MIN_VALUE;
+    for (let tile of tiles) {
+        if (tile.x < minX) {
+            minX = tile.x;
+        }
+        if (tile.x > maxX) {
+            maxX = tile.x;
+        }
+        if (tile.y < minY) {
+            minY = tile.y;
+        }
+        if (tile.y > maxY) {
+            maxY = tile.y;
+        }
+    }
+    const xCount = maxX - minX + 1;
+    const yCount = maxY - minY + 1;
+    const mergedDEM = new Float32Array(xCount * demWidth * yCount * demHeight).fill(0);
+    for (let tile of tiles) {
+        _insertDEM(tile.DEM, demWidth, demHeight, mergedDEM, xCount * demWidth, yCount * demHeight, (tile.x - minX) * demWidth, (tile.y - minY) * demHeight);
+    }
+    return mergedDEM;
+}