dgeoutils 2.4.48 → 2.4.52

package/dist/esm/DPoint.js

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