dgeoutils 2.4.41 → 2.4.44

package/dist/es2015/DPoint.js

@@ -1,676 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { DLine } from './DLine';
-import { DPolygon } from './DPolygon';
-import { checkFunction, createArray, DGeo, div, isDefAndNotNull, toDegreesMinutesSeconds } from './utils';
-const diff = 0;
-const radiansPolygon = new DPolygon();
-const pseudoMercatorPolygon = new DPolygon();
-const worldGeodeticPolygon = new DPolygon();
-export const EARTH_RADIUS_IN_METERS = 6378137;
-const EARTH_IN_METERS = 20037508.34;
-const DEGREES_IN_EARTH = 180;
-const METERS_IN_ONE_DEGREE = EARTH_IN_METERS / DEGREES_IN_EARTH;
-const DEGREES_IN_ONE_METER = DEGREES_IN_EARTH / EARTH_IN_METERS;
-export const HALF_PI_IN_DEGREE = 90;
-export const PI_IN_DEGREE = 180;
-export const DOUBLE_PI_IN_DEGREE = 360;
-export const PI_TO_DEGREE = Math.PI / PI_IN_DEGREE;
-export const DEGREE_TO_PI = PI_IN_DEGREE / Math.PI;
-export class DPoint {
-    constructor(x = 0, y = x, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        this.properties = {};
-    }
-    static zero() {
-        return new DPoint();
-    }
-    static parse(c, format = DGeo.parseFormat) {
-        const { lat, lon, lng = lon, alt } = c;
-        if (lat && lng) {
-            return new DPoint(lng, lat, alt !== null && alt !== void 0 ? alt : 0);
-        }
-        const _a = c, { x, y, z } = _a, properties = __rest(_a, ["x", "y", "z"]);
-        if (isDefAndNotNull(x) && isDefAndNotNull(y)) {
-            return new DPoint(x, y, z).setProperties(properties);
-        }
-        let t = c;
-        if (c.type === 'Point') {
-            t = c.coordinates;
-        }
-        if (c.type === 'Feature') {
-            const f = DPoint.parse(c.geometry, format);
-            f.properties = Object.assign({}, c.properties);
-            return f;
-        }
-        return format.replace(/[^x-z]/gmiu, '')
-            .split('')
-            .reduce((a, k, index) => {
-            var _a, _b;
-            switch (k) {
-                case 'x':
-                    a.x = (_a = t[index]) !== null && _a !== void 0 ? _a : 0;
-                    break;
-                case 'y':
-                    a.y = (_b = t[index]) !== null && _b !== void 0 ? _b : 0;
-                    break;
-                case 'z':
-                    a.z = t[index];
-                    break;
-                default:
-            }
-            return a;
-        }, new DPoint());
-    }
-    static parseFromWKT(wkt) {
-        const regexp = /POINT \((?<data>(?:(?!\)).)*?)\)$/miu;
-        const data = wkt.trim().toUpperCase();
-        const res = regexp.exec(data);
-        const [x, y, z] = res.groups.data.split(' ').map(Number);
-        return new DPoint(x, y, z);
-    }
-    static random() {
-        return new DPoint(Math.random(), Math.random());
-    }
-    static getTileFromQuadKey(quadKey) {
-        const p = new DPoint(0, 0, quadKey.length);
-        for (let i = p.z; i > 0; i--) {
-            const mask = 1 << (i - 1);
-            switch (quadKey[p.z - i]) {
-                case '0':
-                    break;
-                case '1':
-                    p.x |= mask;
-                    break;
-                case '2':
-                    p.y |= mask;
-                    break;
-                case '3':
-                    p.x |= mask;
-                    p.y |= mask;
-                    break;
-                default:
-                    throw new Error('Invalid QuadKey digit sequence.');
-            }
-        }
-        return p;
-    }
-    toDegreesMinutesSeconds() {
-        return {
-            x: toDegreesMinutesSeconds(this.x),
-            y: toDegreesMinutesSeconds(this.y)
-        };
-    }
-    getTileFromCoords(zoom = this.z) {
-        checkFunction('getTileFromCoords')
-            .checkArgument('this')
-            .shouldBeDegree(this);
-        const x = Math.floor((this.x + PI_IN_DEGREE) / DOUBLE_PI_IN_DEGREE * (Math.pow(2, zoom)));
-        const y = Math.floor((1 - Math.log(Math.tan(this.y * PI_TO_DEGREE) + 1 / Math.cos(this.y * PI_TO_DEGREE)) / Math.PI) / 2 * (Math.pow(2, zoom)));
-        return new DPoint(x, y, zoom);
-    }
-    getQuadKeyFromTile(zoom = this.z) {
-        const quadKey = [];
-        for (let i = zoom; i > 0; i--) {
-            let digit = 0;
-            const mask = 1 << (i - 1);
-            if ((this.x & mask) !== 0) {
-                digit++;
-            }
-            if ((this.y & mask) !== 0) {
-                digit++;
-                digit++;
-            }
-            quadKey.push(digit);
-        }
-        return quadKey.join('');
-    }
-    getCoordsFromTile(zoom = this.z) {
-        checkFunction('getCoordsFromTile')
-            .checkArgument('this')
-            .shouldBeUInt(this);
-        const n = Math.PI - 2 * Math.PI * this.y / (Math.pow(2, zoom));
-        const x = this.x / (Math.pow(2, zoom)) * DOUBLE_PI_IN_DEGREE - PI_IN_DEGREE;
-        const y = PI_IN_DEGREE / Math.PI * Math.atan((Math.exp(n) - Math.exp(-n)) / 2);
-        return new DPoint(x, y, zoom);
-    }
-    toCoords(format = DGeo.parseFormat) {
-        return format.replace(/[^x-z]/gmiu, '').split('')
-            .map((k) => ({
-            x: this.x,
-            y: this.y,
-            z: this.z
-        })[k])
-            .filter((r) => r !== undefined);
-    }
-    toGeoJSON(format = DGeo.parseFormat) {
-        return {
-            type: 'Point',
-            coordinates: this.toCoords(format)
-        };
-    }
-    toGeoJSONFeature(format = DGeo.parseFormat) {
-        return {
-            type: 'Feature',
-            properties: Object.assign({}, this.properties),
-            geometry: this.toGeoJSON(format)
-        };
-    }
-    findLine(p) {
-        checkFunction('findLine')
-            .checkArgument('this')
-            .shouldBeMeters(this)
-            .checkArgument('p')
-            .shouldBeMeters(p);
-        if (this.equal(p)) {
-            return this.findLine(p.clone().move(0, 1));
-        }
-        const a = this.y - p.y - diff;
-        const b = p.x - this.x - diff;
-        const c = this.x * p.y - p.x * this.y - diff;
-        if (a === 0) {
-            return new DLine(0, 1, c / b, this, p);
-        }
-        if (b === 0) {
-            return new DLine(1, 0, c / a, this, p);
-        }
-        return new DLine(a, b, c, this, p);
-    }
-    findInnerAngle(p1, p3) {
-        checkFunction('findInnerAngle')
-            .checkArgument('this')
-            .shouldBeMeters(this)
-            .checkArgument('p1')
-            .shouldBeMeters(p1)
-            .checkArgument('p3')
-            .shouldBeMeters(p3);
-        const a1 = this.findLine(p1).getFi();
-        const a2 = this.findLine(p3).getFi();
-        if (a2 >= a1) {
-            return a2 - a1;
-        }
-        return a2 + Math.PI * 2 - a1;
-    }
-    toString() {
-        return `${this.x} ${this.y}`;
-    }
-    getValue() {
-        return [this.x, this.y];
-    }
-    height(z) {
-        this.z = z;
-        return this;
-    }
-    toWKT() {
-        const { x, y } = this;
-        return `POINT (${x} ${y})`;
-    }
-    distance(p) {
-        checkFunction('distance')
-            .checkArgument('this')
-            .shouldBeMeters(this)
-            .checkArgument('p')
-            .shouldBeMeters(p);
-        const dx = p.x - this.x;
-        const dy = p.y - this.y;
-        return Math.sqrt(dx * dx + dy * dy);
-    }
-    distance3d(p) {
-        checkFunction('distance3d')
-            .checkArgument('this')
-            .shouldBeMeters(this)
-            .checkArgument('p')
-            .shouldBeMeters(p)
-            .checkArgument('this.z')
-            .shouldExist(this.z)
-            .checkArgument('p.z')
-            .shouldExist(p.z);
-        const dx = p.x - this.x;
-        const dy = p.y - this.y;
-        const dz = p.z - this.z;
-        return Math.sqrt(dx * dx + dy * dy + dz * dz);
-    }
-    setX(x) {
-        this.x = typeof x === 'number' ? x : x(this);
-        return this;
-    }
-    setZ(z) {
-        this.z = typeof z === 'number' ? z : z(this);
-        return this;
-    }
-    setY(y) {
-        this.y = typeof y === 'number' ? y : y(this);
-        return this;
-    }
-    setProperties(v) {
-        this.properties = typeof v === 'object' ? v : v(this);
-        return this;
-    }
-    clone() {
-        const p = new DPoint(this.x, this.y, this.z);
-        p.properties = Object.assign({}, this.properties);
-        return p;
-    }
-    gt(p) {
-        return this.x > p.x && this.y > p.y;
-    }
-    lt(p) {
-        return this.x < p.x && this.y < p.y;
-    }
-    gtOrEqual(p) {
-        return this.gt(p) || this.equal(p);
-    }
-    ltOrEqual(p) {
-        return this.lt(p) || this.equal(p);
-    }
-    rotate(a) {
-        const x = this.x * Math.cos(a) - this.y * Math.sin(a);
-        const y = this.x * Math.sin(a) + this.y * Math.cos(a);
-        this.x = x;
-        this.y = y;
-        return this;
-    }
-    rotate3dX(a) {
-        const { y, z } = this;
-        this.y = y * Math.cos(a) + z * Math.sin(a);
-        this.z = -y * Math.sin(a) + z * Math.cos(a);
-        return this;
-    }
-    rotate3dY(a) {
-        const { x, z } = this;
-        this.x = x * Math.cos(a) + z * Math.sin(a);
-        this.z = -x * Math.sin(a) + z * Math.cos(a);
-        return this;
-    }
-    rotate3dZ(a) {
-        const { x, y } = this;
-        this.x = x * Math.cos(a) - y * Math.sin(a);
-        this.y = -x * Math.sin(a) + y * Math.cos(a);
-        return this;
-    }
-    move(x, y = x, z) {
-        let xV = 0;
-        let yV = 0;
-        let zV = undefined;
-        if (x instanceof DPoint) {
-            xV = this.x + x.x;
-            yV = this.y + x.y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
-                zV = this.z + x.z;
-            }
-        }
-        else {
-            xV = this.x + x;
-            yV = this.y + y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
-                zV = this.z + z;
-            }
-        }
-        this.x = xV;
-        this.y = yV;
-        if (isDefAndNotNull(zV)) {
-            this.z = zV;
-        }
-        return this;
-    }
-    degreeToMeters() {
-        checkFunction('degreeToMeters')
-            .checkArgument('this')
-            .shouldBeDegree(this);
-        const x = ((this.x + PI_IN_DEGREE) % DOUBLE_PI_IN_DEGREE - PI_IN_DEGREE) * METERS_IN_ONE_DEGREE;
-        const y = (Math.log(Math.tan(((this.y + HALF_PI_IN_DEGREE) % PI_IN_DEGREE) *
-            (Math.PI / DOUBLE_PI_IN_DEGREE))) / PI_TO_DEGREE) * METERS_IN_ONE_DEGREE;
-        this.x = x;
-        this.y = y;
-        return this;
-    }
-    metersToDegree() {
-        checkFunction('metersToDegree')
-            .checkArgument('this')
-            .shouldBeMeters(this);
-        const lon = this.x * DEGREES_IN_ONE_METER;
-        const lat = Math.atan(Math.pow(Math.E, ((this.y / METERS_IN_ONE_DEGREE) * PI_TO_DEGREE))) *
-            (DOUBLE_PI_IN_DEGREE / Math.PI) - HALF_PI_IN_DEGREE;
-        this.x = lon;
-        this.y = lat;
-        return this;
-    }
-    degreeToRadians() {
-        checkFunction('degreeToRadians')
-            .checkArgument('this')
-            .shouldBeDegree(this);
-        return this.scale(PI_TO_DEGREE);
-    }
-    radiansToDegrees() {
-        checkFunction('radiansToDegrees')
-            .checkArgument('this')
-            .shouldBeRadians(this);
-        return this.scale(DEGREE_TO_PI);
-    }
-    radiansToMeters() {
-        checkFunction('radiansToMeters')
-            .checkArgument('this')
-            .shouldBeRadians(this);
-        return this.radiansToDegrees().degreeToMeters();
-    }
-    metersToRadians() {
-        checkFunction('metersToRadians')
-            .checkArgument('this')
-            .shouldBeMeters(this);
-        return this.metersToDegree().degreeToRadians();
-    }
-    round() {
-        this.x = Math.round(this.x);
-        this.y = Math.round(this.y);
-        return this;
-    }
-    ceil() {
-        this.x = Math.ceil(this.x);
-        this.y = Math.ceil(this.y);
-        return this;
-    }
-    floor() {
-        this.x = Math.floor(this.x);
-        this.y = Math.floor(this.y);
-        return this;
-    }
-    toFixed(n = 2) {
-        this.x = parseFloat(this.x.toFixed(n));
-        this.y = parseFloat(this.y.toFixed(n));
-        return this;
-    }
-    abs() {
-        this.x = Math.abs(this.x);
-        this.y = Math.abs(this.y);
-        return this;
-    }
-    scale(x, y = x, z) {
-        let xV = 0;
-        let yV = 0;
-        let zV = undefined;
-        if (x instanceof DPoint) {
-            xV = this.x * x.x;
-            yV = this.y * x.y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
-                zV = this.z * x.z;
-            }
-        }
-        else {
-            xV = this.x * x;
-            yV = this.y * y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
-                zV = this.z * z;
-            }
-        }
-        this.x = xV;
-        this.y = yV;
-        if (isDefAndNotNull(zV)) {
-            this.z = zV;
-        }
-        return this;
-    }
-    divide(x, y = x, z) {
-        let xV = 0;
-        let yV = 0;
-        let zV = undefined;
-        if (x instanceof DPoint) {
-            xV = this.x / x.x;
-            yV = this.y / x.y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
-                zV = this.z / x.z;
-            }
-        }
-        else {
-            xV = this.x / x;
-            yV = this.y / y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
-                zV = this.z / z;
-            }
-        }
-        this.x = xV;
-        this.y = yV;
-        if (isDefAndNotNull(zV)) {
-            this.z = zV;
-        }
-        return this;
-    }
-    mod(x, y = x, z) {
-        let xV = 0;
-        let yV = 0;
-        let zV = undefined;
-        if (x instanceof DPoint) {
-            xV = this.x % x.x;
-            yV = this.y % x.y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
-                zV = this.z % x.z;
-            }
-        }
-        else {
-            xV = this.x % x;
-            yV = this.y % y;
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
-                zV = this.z % z;
-            }
-        }
-        this.x = xV;
-        this.y = yV;
-        if (isDefAndNotNull(zV)) {
-            this.z = zV;
-        }
-        return this;
-    }
-    div(x, y = x, z) {
-        let xV = 0;
-        let yV = 0;
-        let zV = undefined;
-        if (x instanceof DPoint) {
-            xV = div(this.x, x.x);
-            yV = div(this.y, x.y);
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
-                zV = div(this.z, x.z);
-            }
-        }
-        else {
-            xV = div(this.x, x);
-            yV = div(this.y, y);
-            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
-                zV = div(this.z, z);
-            }
-        }
-        this.x = xV;
-        this.y = yV;
-        if (isDefAndNotNull(zV)) {
-            this.z = zV;
-        }
-        return this;
-    }
-    equal(p) {
-        return this.x === p.x && this.y === p.y && this.z === p.z;
-    }
-    like(p, d = 0.001) {
-        var _a, _b, _c, _d;
-        if (this.equal(p)) {
-            return true;
-        }
-        const likeX = Math.abs(this.x - p.x) < d;
-        const likeY = Math.abs(this.y - p.y) < d;
-        const likeZ = Math.abs(((_b = (_a = this.z) !== null && _a !== void 0 ? _a : p.z) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = p.z) !== null && _c !== void 0 ? _c : this.z) !== null && _d !== void 0 ? _d : 0)) < d;
-        return likeX && likeY && likeZ;
-    }
-    flipVertically(size) {
-        let v = size;
-        if (size instanceof DPoint) {
-            v = size.y;
-        }
-        this.y = v - this.y;
-        return this;
-    }
-    get likeRadians() {
-        if (radiansPolygon.length === 0) {
-            radiansPolygon.push(new DPoint(-Math.PI, -Math.PI / 2), new DPoint(Math.PI, Math.PI / 2));
-        }
-        return radiansPolygon.simpleInclude(this);
-    }
-    get likeWorldGeodeticSystem() {
-        if (worldGeodeticPolygon.length === 0) {
-            worldGeodeticPolygon.push(new DPoint(-180, -90), new DPoint(180, 90));
-        }
-        return !this.likeRadians && worldGeodeticPolygon.simpleInclude(this);
-    }
-    get likePseudoMercator() {
-        if (pseudoMercatorPolygon.length === 0) {
-            pseudoMercatorPolygon.push(new DPoint(-20026376.39, -20048966.10), new DPoint(20026376.39, 20048966.10));
-        }
-        return !this.likeRadians && !this.likeWorldGeodeticSystem && pseudoMercatorPolygon.simpleInclude(this);
-    }
-    get w() {
-        return this.x;
-    }
-    set w(x) {
-        this.x = x;
-    }
-    get h() {
-        return this.y;
-    }
-    set h(y) {
-        this.y = y;
-    }
-    get area() {
-        checkFunction('area')
-            .checkArgument('this')
-            .shouldBeMeters(this);
-        return this.w * this.h;
-    }
-    get hip() {
-        checkFunction('hip')
-            .checkArgument('this')
-            .shouldBeMeters(this);
-        return Math.sqrt(this.w * this.w + this.h * this.h);
-    }
-    get min() {
-        return Math.min(this.x, this.y);
-    }
-    get max() {
-        return Math.max(this.x, this.y);
-    }
-    get hipPoint() {
-        const { hip } = this;
-        return new DPoint(hip, hip);
-    }
-    get xPoint() {
-        const { x } = this;
-        return new DPoint(x, x);
-    }
-    get yPoint() {
-        const { y } = this;
-        return new DPoint(y, y);
-    }
-    get wPoint() {
-        return this.xPoint;
-    }
-    get hPoint() {
-        return this.yPoint;
-    }
-    get lat() {
-        return this.y;
-    }
-    set lat(v) {
-        this.y = v;
-    }
-    get lng() {
-        return this.x;
-    }
-    set lng(v) {
-        this.x = v;
-    }
-    get lon() {
-        return this.x;
-    }
-    set lon(v) {
-        this.x = v;
-    }
-    get alt() {
-        return this.z;
-    }
-    set alt(v) {
-        this.z = v;
-    }
-    simple(xKey = 'x', yKey = 'y', zKey = 'z') {
-        return Object.assign({ [xKey]: this.x, [yKey]: this.y }, (isDefAndNotNull(this.z) ? {
-            [zKey]: this.z
-        } : {}));
-    }
-    setIfLessThan(p) {
-        this.x = Math.max(this.x, p.x);
-        this.y = Math.max(this.y, p.y);
-        return this;
-    }
-    setIfMoreThan(p) {
-        this.x = Math.min(this.x, p.x);
-        this.y = Math.min(this.y, p.y);
-        return this;
-    }
-    minus() {
-        return this.scale(-1);
-    }
-    orthodromicPath(point, pointsCount = 360) {
-        checkFunction('orthodromicPath')
-            .checkArgument('this')
-            .shouldBeDegree(this)
-            .checkArgument('point')
-            .shouldBeDegree(point);
-        const t = this.clone().degreeToRadians();
-        const p = point.clone().degreeToRadians();
-        const d = Math.sin(p.x - t.x);
-        const step = (p.x - t.x) / (pointsCount - 1);
-        return new DPolygon(createArray(pointsCount)
-            .map((v, i) => {
-            const x = t.x + step * i;
-            const y = Math.atan((Math.tan(t.y) * Math.sin(p.x - x)) / d +
-                (Math.tan(p.y) * Math.sin(x - t.x)) / d);
-            return new DPoint(x, y).radiansToDegrees();
-        }));
-    }
-    sortByDistance(p) {
-        return p
-            .clone()
-            .map((d, index) => {
-            d.properties.distance = d.distance(this);
-            d.properties.index = index;
-            return d;
-        })
-            .sort((a, b) => a.properties.distance - b.properties.distance);
-    }
-    calculateAltitudeByDistanceBetweenPoints(p1, p2) {
-        var _a, _b, _c, _d, _e;
-        if (p1.alt === p2.alt) {
-            this.alt = p1.alt;
-        }
-        else {
-            const minAlt = Math.min((_a = p1.alt) !== null && _a !== void 0 ? _a : 0, (_b = p2.alt) !== null && _b !== void 0 ? _b : 0);
-            const maxAlt = Math.max((_c = p1.alt) !== null && _c !== void 0 ? _c : 0, (_d = p2.alt) !== null && _d !== void 0 ? _d : 0);
-            const dAlt = maxAlt - minAlt;
-            const distance1 = this.distance(p1);
-            const distance2 = this.distance(p2);
-            const totalDistance = distance1 + distance2;
-            if (((_e = p1.alt) !== null && _e !== void 0 ? _e : 0) === minAlt) {
-                this.alt = minAlt + distance1 / totalDistance * dAlt;
-            }
-            else {
-                this.alt = minAlt + distance2 / totalDistance * dAlt;
-            }
-        }
-        return this;
-    }
-}