@pirireis/webglobeplugins 0.11.1-alpha → 0.13.0-alpha

package/Math/circle-cdf-points.js

@@ -0,0 +1,247 @@
+import { RADIANS } from "./methods";
+function createTemplate(intervalCount, strength = 1.0) {
+    const out = new Array(intervalCount);
+    const TOTAL = 1;
+    let cummulative = 0;
+    if (strength <= 0) {
+        // If strength is 0, distribute evenly.
+        const step = TOTAL / (intervalCount - 1);
+        for (let i = 0; i < intervalCount; i++) {
+            out[i] = cummulative;
+            cummulative += step;
+        }
+        out[intervalCount - 1] = TOTAL; // Ensure the last value is exactly TOTAL
+        return out;
+    }
+    // If strength is greater than 0, bias towards the start.
+    const weights = new Array(intervalCount);
+    let currentStep = 1;
+    let totalWeight = 0;
+    // Calculate weights for each interval, decreasing for later intervals.
+    for (let i = 0; i < intervalCount; i++) {
+        // Using (i + 1) in the denominator gives earlier intervals the highest weight.
+        totalWeight += currentStep;
+        weights[i] = totalWeight;
+        currentStep += strength;
+    }
+    // Distribute the total angle based on the weights.
+    for (let i = 0; i < intervalCount; i++) {
+        // Round to the nearest whole number for this interval.
+        out[i] = (weights[i] / totalWeight) * TOTAL;
+    }
+    if (out[intervalCount - 1] !== TOTAL) {
+        out[intervalCount - 1] = TOTAL;
+    }
+    // console.log("createTemplate", "strength", strength, "intervalCount", intervalCount, "out", out);
+    return out;
+}
+function interpolation(a, b, t) {
+    return a + (b - a) * t;
+}
+/**
+ * Populates the `out` array with values from the `template` array,
+ * distributing the surplus length as interpolated values between the template samples.
+ *
+ * @param out The destination array to be filled. Its length must be >= template.length.
+ * @param template An ordered array of numbers to be placed in the `out` array.
+ * @param strength A parameter controlling the distribution bias of surplus samples.
+ * - strength = 0: Surplus samples are distributed evenly.
+ * - strength > 0: Surplus samples are biased towards the start of the template.
+ * - Higher values create a stronger bias.
+ */
+function increasePopulation(// TODO: THERE IS A BUG
+out, template, strength = 1.0) {
+    const sourceLength = template.length;
+    const destinationLength = out.length;
+    const outLengthAtStart = out.length;
+    // --- Handle Edge Cases ---
+    // If the template is empty, there is nothing to interpolate from.
+    if (sourceLength === 0) {
+        return;
+    }
+    // If the template has only one value, fill the output array with that value.
+    if (sourceLength === 1) {
+        out.fill(template[0]);
+        return;
+    }
+    // If the destination is not larger than the source, just copy the template values.
+    if (destinationLength <= sourceLength) {
+        for (let i = 0; i < destinationLength; i++) {
+            out[i] = template[i];
+        }
+        return;
+    }
+    // --- Main Logic ---
+    const surplus = destinationLength - sourceLength;
+    const numGaps = sourceLength - 1;
+    // This array will hold the number of extra samples to add in each gap.
+    const surplusPerGap = new Array(numGaps).fill(0);
+    if (surplus > 0) {
+        // --- Step 1: Determine the distribution of surplus items ---
+        // If strength is 0, distribute surplus items as evenly as possible.
+        if (strength <= 0) {
+            const baseToAdd = Math.floor(surplus / numGaps);
+            const remainder = surplus % numGaps;
+            for (let i = 0; i < numGaps; i++) {
+                // Distribute the remainder one by one to the first gaps.
+                surplusPerGap[i] = baseToAdd + (i < remainder ? 1 : 0);
+            }
+        }
+        else {
+            // Biased Distribution: more items in earlier gaps.
+            const weights = new Array(numGaps);
+            let totalWeight = 0;
+            // A. Calculate a weight for each gap. The weight decreases for later gaps.
+            // The `strength` parameter makes this decay steeper.
+            for (let i = 0; i < numGaps; i++) {
+                // Using (i + 1) in the denominator gives earlier gaps (i=0) the highest weight.
+                const weight = Math.pow(1 / (i + 1), strength);
+                weights[i] = weight;
+                totalWeight += weight;
+            }
+            // B. Distribute the surplus based on the calculated weights.
+            // This method ensures the total distributed count equals the surplus.
+            let distributedCount = 0;
+            for (let i = 0; i < numGaps - 1; i++) {
+                const idealCount = (weights[i] / totalWeight) * surplus;
+                // Round to the nearest whole number for this gap.
+                const countForThisGap = Math.ceil(idealCount);
+                surplusPerGap[i] = countForThisGap;
+                distributedCount += countForThisGap;
+            }
+            // Assign the remainder to the last gap to guarantee the sum is correct.
+            //surplusPerGap[numGaps - 1] = surplus - distributedCount; 
+            // add to first 
+            const leftover = surplus - distributedCount;
+            if (leftover > 0) {
+                surplusPerGap[0] += leftover; // Add any leftover to the first gap.
+            }
+            console.log("leftover", leftover, "distributedCount", distributedCount, "surplus", surplus);
+        }
+    }
+    // --- Step 2: Populate the `out` array ---
+    let outIndex = 0;
+    for (let i = 0; i < surplusPerGap.length; i++) {
+        if (typeof surplusPerGap[i] !== "number" || isNaN(surplusPerGap[i]) || !isFinite(surplusPerGap[i])) {
+            console.warn("increasePopulation: Invalid surplusPerGap value at index", i, ":", surplusPerGap[i]);
+        }
+    }
+    for (let i = 0; i < sourceLength; i++) {
+        // A. Add the original template item.
+        out[outIndex++] = template[i];
+        // B. If this is not the last template item, fill the gap after it.
+        if (i < numGaps) {
+            const numToAdd = surplusPerGap[i];
+            if (numToAdd <= 0)
+                continue;
+            const startVal = template[i];
+            const endVal = template[i + 1];
+            // C. Add the interpolated ("surplus") items for this gap.
+            // The total number of intervals in this gap is numToAdd + 1.
+            const totalIntervals = numToAdd + 1;
+            for (let j = 1; j <= numToAdd; j++) {
+                const t = j / totalIntervals; // The interpolation factor (0 < t < 1)
+                // Linear interpolation: out = start * (1 - t) + end * t
+                const interpolatedValue = startVal * (1 - t) + endVal * t;
+                out[outIndex++] = interpolatedValue;
+                if (outIndex >= out.length) {
+                    console.warn("increasePopulation: Output array overflow. Stopping early.");
+                    console.warn("processeed item ratio:", i, "/", sourceLength);
+                    let count = numToAdd - j;
+                    console.log("count", count);
+                    for (let _i = i; _i < sourceLength; _i++) {
+                        count += surplusPerGap[_i];
+                    }
+                    console.warn("increasePopulation: Not enough space to add", count, "more items.");
+                    return; // Prevent overflow if the output array is not large enough.
+                }
+            }
+        }
+    }
+    // --- Step 3: Ensure the output length is correct ---
+    if (outLengthAtStart !== out.length) {
+        console.warn("increasePopulation: Output length mismatch. Expected", outLengthAtStart, "but got", out.length);
+    }
+}
+function createCummulativeTemplate(numberOfPoints, strength, denseRatio = 0.5 // Ratio of points to be densely packed at the start.
+) {
+    // Handle edge cases for the number of points.
+    if (numberOfPoints <= 0) {
+        // If zero or a negative number of points is requested, return an empty array.
+        return new Float64Array([]);
+    }
+    // Create the array to hold the results. Float64Array is used for high-precision floating-point numbers.
+    const distribution = new Float64Array(numberOfPoints);
+    if (numberOfPoints === 1) {
+        // If only one point is requested, it represents the entire range [0, 1].
+        // We place it at the start (0.0).
+        distribution[0] = 0.0;
+        return distribution;
+    }
+    // The exponent determines the curve of the distribution.
+    // We add 1 to the strength so that a strength of 0 results in an exponent of 1 (linear).
+    // We use Math.max(0, strength) to ensure the strength is not negative.
+    // The last index is used to normalize the position to a 0-1 range.
+    const lastIndex = numberOfPoints - 1;
+    distribution[0] = 0.0; // The first point is always at 0.0.
+    let totalWeight = 0;
+    let i = 1;
+    const denseCount = numberOfPoints * denseRatio;
+    for (i; i < denseCount; i++) {
+        // Calculate the ratio of the current index to the last index.
+        // The ratio is adjusted to create a non-linear distribution.
+        totalWeight += 1;
+        distribution[i] = totalWeight; // Store the raw value in the distribution array.
+    }
+    for (i; i < numberOfPoints; i++) {
+        // Calculate the ratio of the current index to the last index.
+        const ratio = 1 + ((i - denseCount) / lastIndex) / (1 - denseRatio) * 2;
+        const step = Math.pow(ratio, strength);
+        totalWeight += step;
+        distribution[i] = totalWeight; // Store the raw value in the distribution array.
+        // Apply the power function to create a non-linear distribution.
+        // The result is normalized to the range [0, 1].
+    }
+    for (let i = 1; i < numberOfPoints; i++) {
+        // Normalize the values to ensure they sum up to 1.
+        distribution[i] = distribution[i] / totalWeight;
+    }
+    return distribution;
+}
+function createCummulativeTemplateStash(levels, numberOfPoints, denseRatio = 0.5, strengthMultiplier = 2.4) {
+    const stash = [];
+    for (let i = 0; i < levels; i++) {
+        const template = createCummulativeTemplate(numberOfPoints, i * strengthMultiplier, denseRatio);
+        stash.push(template);
+    }
+    return stash;
+}
+function globeFindPointByPolar(out, globe, centerLong, centerLat, radius, ratios) {
+    for (let i = 0; i < ratios.length; i++) {
+        const point = globe.Math.FindPointByPolar(centerLong, centerLat, radius, ratios[i]);
+        out[i * 2] = point.long;
+        out[i * 2 + 1] = point.lat;
+    }
+}
+function globeFindPointByPolarHalfCircle(out, globe, centerLong, centerLat, radius, rotation, ratios) {
+    const rotCentigrade = rotation / RADIANS + 720;
+    for (let i = 0; i < ratios.length; i++) {
+        const point = globe.Math.FindPointByPolar(centerLong, centerLat, radius, (ratios[i] * 180 + rotCentigrade) % 360);
+        out[i * 2] = point.long;
+        out[i * 2 + 1] = point.lat;
+    }
+    // fill reflection
+    let offset = out.length;
+    for (let i = 0; i < ratios.length - 1; i++) {
+        const point = globe.Math.FindPointByPolar(centerLong, centerLat, radius, ((-ratios[i]) * 180 + rotCentigrade) % 360);
+        out[offset - 2] = point.long;
+        out[offset - 1] = point.lat;
+        offset -= 2;
+    }
+}
+export { 
+// createTemplate,
+// increasePopulation,
+// interpolation,
+// createCummulativeTemplate,
+createCummulativeTemplateStash, globeFindPointByPolar, globeFindPointByPolarHalfCircle };

package/Math/circle.js

@@ -0,0 +1,39 @@
+import { RADIANS } from './methods';
+import { subtract, normalize, dot, fromLongLatToUnitVector, copy, multiplyScalar } from './vec3';
+const _0vec3 = [0, 0, 0];
+function closestAzimuthAngle(circleProperties, point) {
+    const distance = dot(circleProperties.normal, point);
+    copy(_0vec3, circleProperties.normal);
+    multiplyScalar(_0vec3, _0vec3, distance);
+    subtract(_0vec3, point, _0vec3);
+    normalize(_0vec3, _0vec3);
+    const N = circleProperties.northPointProjectedToOriginPlaneNormalized;
+    const _dot = dot(_0vec3, N);
+    let angle = Math.acos(_dot);
+    const z = _0vec3[0] * N[1] - _0vec3[1] * N[0];
+    return z < 0 ? -angle : angle;
+}
+function createCircleClosestAzimuthAngleProperties(circle) {
+    const normal = Array(3);
+    fromLongLatToUnitVector(normal, [circle.center[0] * RADIANS, circle.center[1] * RADIANS]);
+    const distance = normal[2]; //dot(normal, [0, 0, 1] as Vec3)
+    const N = [0, 0, 0];
+    if (Math.abs(distance) < 1e-6) {
+        N[0] = -1;
+        N[1] = 0;
+        N[2] = 0;
+    }
+    else {
+        copy(N, normal);
+        multiplyScalar(N, N, distance);
+        N[0] = -N[0];
+        N[1] = -N[1];
+        N[2] = 1 - N[2];
+    }
+    normalize(N, N);
+    return {
+        normal: normal,
+        northPointProjectedToOriginPlaneNormalized: N,
+    };
+}
+export { closestAzimuthAngle, createCircleClosestAzimuthAngleProperties };

package/Math/methods.js

@@ -84,14 +84,24 @@ export const globe3Dcoordinates = (globe, height = 0) => (longlats, { paddingCou
     }
     return result;
 };
-export const globe2Dcoordinates = (globe) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
+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 xyz = globe.api_GetMercator2DPoint(long, lat);
-        result.set(xyz, i * 2);
+        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/vec3.js

@@ -80,7 +80,7 @@ function equals(a, b) {
         Math.abs(a[1] - b[1]) < EPSILON &&
         Math.abs(a[2] - b[2]) < EPSILON);
 }
-function toUnitVectorLongLat(out, a) {
+function fromUnitVectorToLongLat(out, a) {
     const len = length(a); // TODO Might drop length check 
     if (len === 0) {
         throw new Error('Cannot convert a zero vector to unit vector');
@@ -88,7 +88,7 @@ function toUnitVectorLongLat(out, a) {
     out[0] = Math.atan2(a[1], a[0]); // Longitude
     out[1] = Math.asin(a[2] / len); // Latitude
 }
-function fromUnitVectorLongLat(out, longLat) {
+function fromLongLatToUnitVector(out, longLat) {
     const longitude = longLat[0];
     const latitude = longLat[1];
     const cosLat = Math.cos(latitude);
@@ -119,4 +119,4 @@ function randomUnit(out) {
 function str(a) {
     return `Vec3(${a[0].toFixed(2)}, ${a[1].toFixed(2)}, ${a[2].toFixed(2)})`;
 }
-export { create, set, clone, copy, add, subtract, dot, cross, multiplyScalar, divideScalar, lengthSquared, length, normalize, distanceSquared, distance, equals, toUnitVectorLongLat, fromUnitVectorLongLat, applyQuaternion, randomUnit, str };
+export { create, set, clone, copy, add, subtract, dot, cross, multiplyScalar, divideScalar, lengthSquared, length, normalize, distanceSquared, distance, equals, fromUnitVectorToLongLat, fromLongLatToUnitVector, applyQuaternion, randomUnit, str };

package/package.json

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