@toba/map/cjs/measure.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tools_1 = require("@toba/tools");
const piDeg = Math.PI / 180.0;
const radiusMiles = 3958.756;
const earthRadius = radiusMiles;
var Unit;
(function (Unit) {
    Unit[Unit["English"] = 0] = "English";
    Unit[Unit["Metric"] = 1] = "Metric";
})(Unit = exports.Unit || (exports.Unit = {}));
const toRadians = (deg) => deg * piDeg;
const toDegrees = (rad) => (rad * 180) / Math.PI;
const sameLocation = (p1, p2) => tools_1.is.array(p1) &&
    tools_1.is.array(p2) &&
    p1[1] == p2[1] &&
    p1[0] == p2[0];
function pointDistance(p1, p2) {
    if (sameLocation(p1, p2) || !tools_1.is.array(p1) || !tools_1.is.array(p2)) {
        return 0;
    }
    const radLat1 = toRadians(p1[1]);
    const radLat2 = toRadians(p2[1]);
    const latDistance = toRadians(p2[1] - p1[1]);
    const lonDistance = toRadians(p2[0] - p1[0]);
    const a = Math.sin(latDistance / 2) ** 2 +
        Math.cos(radLat1) * Math.cos(radLat2) * Math.sin(lonDistance / 2) ** 2;
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    return earthRadius * c;
}
const length = (points) => points.reduce((total, p, i) => total + (i > 0 ? pointDistance(points[i - 1], p) : 0), 0);
function speed(p1, p2) {
    const t = Math.abs(p1[3] - p2[3]);
    const d = pointDistance(p1, p2);
    return t > 0 && d > 0 ? d / (t / 3600000) : 0;
}
function duration(line) {
    const firstPoint = line[0];
    const lastPoint = line[line.length - 1];
    return (lastPoint[3] - firstPoint[3]) / 3600000;
}
function pointLineDistance(p, p1, p2) {
    let x = p1[0];
    let y = p1[1];
    let Δx = p2[0] - x;
    let Δy = p2[1] - y;
    if (Δx !== 0 || Δy !== 0) {
        const t = ((p[0] - x) * Δx + (p[1] - y) * Δy) /
            (Δx * Δx + Δy * Δy);
        if (t > 1) {
            x = p2[0];
            y = p2[1];
        }
        else if (t > 0) {
            x += Δx * t;
            y += Δy * t;
        }
    }
    Δx = p[0] - x;
    Δy = p[1] - y;
    return Δx * Δx + Δy * Δy;
}
function centroid(points) {
    const count = points.length;
    if (count == 0) {
        return null;
    }
    if (count == 1) {
        return {
            lon: points[0][0],
            lat: points[0][1]
        };
    }
    const location = { lon: 0, lat: 0 };
    let x = 0;
    let y = 0;
    let z = 0;
    points.forEach(p => {
        const radLat = toRadians(p[1]);
        const radLon = toRadians(p[0]);
        x += Math.cos(radLat) * Math.cos(radLon);
        y += Math.cos(radLat) * Math.sin(radLon);
        z += Math.sin(radLat);
    });
    x /= count;
    y /= count;
    z /= count;
    const lon = Math.atan2(y, x);
    const hyp = Math.sqrt(x * x + y * y);
    const lat = Math.atan2(z, hyp);
    location.lat = toDegrees(lat);
    location.lon = toDegrees(lon);
    return location;
}
function simplify(points, maxPointDeviationFeet = 0) {
    if (maxPointDeviationFeet <= 0) {
        return points;
    }
    const yard = 3;
    const mile = yard * 1760;
    const equatorFeet = mile * radiusMiles;
    const len = points.length;
    const keep = new Uint8Array(len);
    const tolerance = maxPointDeviationFeet / equatorFeet;
    let first = 0;
    let last = len - 1;
    const stack = [];
    let maxDistance = 0;
    let distance = 0;
    let index = 0;
    keep[first] = 1;
    keep[last] = 1;
    while (last > 0) {
        maxDistance = 0;
        for (let i = first + 1; i < last; i++) {
            distance = pointLineDistance(points[i], points[first], points[last]);
            if (distance > maxDistance) {
                index = i;
                maxDistance = distance;
            }
        }
        if (maxDistance > tolerance) {
            keep[index] = 1;
            stack.push(first, index, index, last);
        }
        let i = stack.pop();
        if (i !== undefined) {
            last = i;
            i = stack.pop();
            if (i !== undefined) {
                first = i;
            }
        }
    }
    return points.filter((_p, i) => keep[i] == 1);
}
exports.measure = {
    speed,
    length,
    centroid,
    duration,
    toRadians,
    toDegrees,
    sameLocation,
    pointDistance,
    simplify
};