dgeoutils 2.4.6 → 2.4.9

package/dist/cjs/DPoint.d.ts

@@ -1,11 +1,13 @@
 import { DLine } from './DLine';
 import { DPolygon } from './DPolygon';
+import { Point } from 'geojson';
 export declare const EARTH_RADIUS_IN_METERS = 6371008.8;
 export declare type DCoord = [number, number] | [number, number, number];
 export interface LatLng {
     lat: number;
     lng?: number;
     lon?: number;
+    alt?: number;
 }
 export declare const HALF_PI_IN_DEGREE = 90;
 export declare const PI_IN_DEGREE = 180;
@@ -25,14 +27,15 @@ export declare class DPoint {
     constructor(x: number, y: number);
     constructor(x: number, y: number, z?: number);
     static zero(): DPoint;
-    static parse(c: LatLng | number[] | DCoord): DPoint;
+    static parse(c: LatLng | number[] | DCoord | Point, format?: string): DPoint;
     static parseFromWKT(wkt: string): DPoint;
     static random(): DPoint;
     static getTileFromQuadKey(quadKey: string): DPoint;
     getTileFromCoords(zoom?: number): DPoint;
     getQuadKeyFromTile(zoom?: number): string;
     getCoordsFromTile(zoom?: number): DPoint;
-    toCoords(): DCoord;
+    toCoords(format?: string): DCoord;
+    toGeoJSON(format?: string): Point;
     findLine(p: DPoint): DLine;
     findInnerAngle(p1: DPoint, p3: DPoint): number;
     toString(): string;
@@ -99,6 +102,10 @@ export declare class DPoint {
     get yPoint(): DPoint;
     get wPoint(): DPoint;
     get hPoint(): DPoint;
+    get lat(): number;
+    get lng(): number;
+    get lon(): number;
+    get alt(): number | undefined;
     simple(xKey?: string, yKey?: string): {
         [key: string]: number;
     };

package/dist/cjs/DPoint.js

@@ -57,13 +57,34 @@ var DPoint = (function () {
     DPoint.zero = function () {
         return new DPoint();
     };
-    DPoint.parse = function (c) {
-        var _a = c, lat = _a.lat, lon = _a.lon, _b = _a.lng, lng = _b === void 0 ? lon : _b;
+    DPoint.parse = function (c, format) {
+        if (format === void 0) { format = 'xyz'; }
+        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(lat, lng, 0);
+            return new DPoint(lng, lat, alt !== null && alt !== void 0 ? alt : 0);
         }
-        var _c = __read(c, 3), x = _c[0], y = _c[1], z = _c[2];
-        return new DPoint(x, y, z);
+        var t = c;
+        if (c.type === 'Point') {
+            t = c.coordinates;
+        }
+        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;
@@ -134,11 +155,23 @@ var DPoint = (function () {
         var y = exports.PI_IN_DEGREE / Math.PI * Math.atan((Math.exp(n) - Math.exp(-n)) / 2);
         return new DPoint(x, y, zoom);
     };
-    DPoint.prototype.toCoords = function () {
-        if (this.z === undefined) {
-            return [this.x, this.y];
-        }
-        return [this.x, this.y, this.z];
+    DPoint.prototype.toCoords = function (format) {
+        var _this = this;
+        if (format === void 0) { format = 'xyz'; }
+        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 = 'xyz'; }
+        return {
+            type: 'Point',
+            coordinates: this.toCoords(format)
+        };
     };
     DPoint.prototype.findLine = function (p) {
         (0, utils_1.checkFunction)('findLine')
@@ -562,6 +595,34 @@ var DPoint = (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(DPoint.prototype, "lat", {
+        get: function () {
+            return this.y;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPoint.prototype, "lng", {
+        get: function () {
+            return this.x;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPoint.prototype, "lon", {
+        get: function () {
+            return this.x;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPoint.prototype, "alt", {
+        get: function () {
+            return this.z;
+        },
+        enumerable: false,
+        configurable: true
+    });
     DPoint.prototype.simple = function (xKey, yKey) {
         var _a;
         if (xKey === void 0) { xKey = 'x'; }

package/dist/cjs/DPolygon.d.ts

@@ -3,12 +3,13 @@ import { DCoord, DPoint, LatLng } from './DPoint';
 import { DLine } from './DLine';
 import { DPolygonLoop } from './DPolygonLoop';
 import { True } from './utils';
+import { LineString, Polygon, Geometry as GeoJsonGeometry, Feature, FeatureCollection } from 'geojson';
+interface DeepArray<T> extends Array<T | DeepArray<T>> {
+}
 export declare const MIN_POINTS_IN_VALID_POLYGON = 3;
 export declare class DPolygon {
     private pPoints;
-    properties: {
-        [key: string]: any;
-    };
+    properties: Record<string, any>;
     holes: DPolygon[];
     private searchStore;
     constructor(pPoints?: DPoint[]);
@@ -93,10 +94,14 @@ export declare class DPolygon {
     onBorder(p: DPoint): boolean;
     nextStart(): DPolygon;
     removeDuplicates(): DPolygon;
-    static parse(a: LatLng[]): DPolygon;
-    static parse(a: number[][]): DPolygon;
-    static parse(a: DCoord[]): DPolygon;
-    toArrayOfCoords(): DCoord[];
+    static toGeoJSONFeatureCollection(polygons: DPolygon[], format?: string): FeatureCollection<LineString | Polygon, Record<string, any>>;
+    static parse(a: LatLng[], format?: string): DPolygon;
+    static parse(a: number[][], format?: string): DPolygon;
+    static parse(a: DCoord[], format?: string): DPolygon;
+    static parse(a: GeoJsonGeometry | Feature | FeatureCollection<LineString | Polygon>, format?: string): DPolygon | DeepArray<DPolygon>;
+    toArrayOfCoords(format?: string): DCoord[];
+    toGeoJSONFeature(format?: string): Feature<LineString | Polygon, Record<string, any>>;
+    toGeoJSON(format?: string): LineString | Polygon;
     divideToPieces(piecesCount: number, withAltitude?: boolean): DPolygon;
     prepareToFastSearch(): void;
     fastHas({ x, y, z }: DPoint): boolean;
@@ -122,3 +127,4 @@ export declare class DPolygon {
     private getJSTSGeometry;
     private simpleLogicFunction;
 }
+export {};

package/dist/cjs/DPolygon.js

@@ -1,4 +1,15 @@
 "use strict";
+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 __generator = (this && this.__generator) || function (thisArg, body) {
     var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
     return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
@@ -955,11 +966,96 @@ var DPolygon = (function () {
         }
         return this;
     };
-    DPolygon.parse = function (a) {
-        return new DPolygon(a.map(function (r) { return DPoint_1.DPoint.parse(r); }));
+    DPolygon.toGeoJSONFeatureCollection = function (polygons, format) {
+        if (format === void 0) { format = 'xyz'; }
+        return {
+            type: 'FeatureCollection',
+            features: polygons.map(function (polygon) { return polygon.toGeoJSONFeature(format); })
+        };
     };
-    DPolygon.prototype.toArrayOfCoords = function () {
-        return this.mapArray(function (r) { return r.toCoords(); });
+    DPolygon.parse = function (a, format) {
+        if (format === void 0) { format = 'xyz'; }
+        if (a.type) {
+            switch (a.type) {
+                case 'FeatureCollection':
+                    return a.features.reduce(function (ak, f) {
+                        var t = DPolygon.parse(f, format);
+                        if (Array.isArray(t)) {
+                            ak.push.apply(ak, __spreadArray([], __read(t), false));
+                        }
+                        else {
+                            ak.push(t);
+                        }
+                        return ak;
+                    }, []);
+                case 'Feature': {
+                    var t = DPolygon.parse(a.geometry, format);
+                    t.properties = __assign(__assign({}, a.properties), { id: a.id });
+                    return t;
+                }
+                case 'LineString':
+                case 'MultiPoint':
+                    return new DPolygon(a.coordinates.map(function (c) { return DPoint_1.DPoint.parse(c, format); }));
+                case 'Polygon':
+                    return a.coordinates.reduce(function (ak, line, index) {
+                        if (index === 0) {
+                            ak.points = line.map(function (c) { return DPoint_1.DPoint.parse(c, format); });
+                        }
+                        else {
+                            ak.holes.push(new DPolygon(line.map(function (c) { return DPoint_1.DPoint.parse(c, format); })));
+                        }
+                        return ak;
+                    }, new DPolygon());
+                case 'MultiLineString':
+                    return a.coordinates.reduce(function (ak, line) {
+                        ak.push(new DPolygon(line.map(function (c) { return DPoint_1.DPoint.parse(c, format); })));
+                        return ak;
+                    }, []);
+                case 'MultiPolygon':
+                    return a.coordinates.reduce(function (ak, coordinates) {
+                        ak.push(DPolygon.parse({
+                            type: 'Polygon',
+                            coordinates: coordinates
+                        }, format));
+                        return ak;
+                    }, []);
+                case 'GeometryCollection':
+                    return a.geometries.reduce(function (ak, line) {
+                        ak.push(DPolygon.parse(line, format));
+                        return ak;
+                    }, []);
+                default:
+            }
+        }
+        return new DPolygon(a
+            .map(function (r) { return DPoint_1.DPoint.parse(r, format); }));
+    };
+    DPolygon.prototype.toArrayOfCoords = function (format) {
+        if (format === void 0) { format = 'xyz'; }
+        return this.mapArray(function (r) { return r.toCoords(format); });
+    };
+    DPolygon.prototype.toGeoJSONFeature = function (format) {
+        if (format === void 0) { format = 'xyz'; }
+        return {
+            type: 'Feature',
+            properties: __assign({}, this.properties),
+            geometry: this.toGeoJSON(format)
+        };
+    };
+    DPolygon.prototype.toGeoJSON = function (format) {
+        if (format === void 0) { format = 'xyz'; }
+        if (this.closed) {
+            return {
+                type: 'Polygon',
+                coordinates: __spreadArray([
+                    this.toArrayOfCoords(format)
+                ], __read(this.holes.map(function (h) { return h.toArrayOfCoords(format); })), false)
+            };
+        }
+        return {
+            type: 'LineString',
+            coordinates: this.toArrayOfCoords(format)
+        };
     };
     DPolygon.prototype.divideToPieces = function (piecesCount, withAltitude) {
         var e_13, _a;

package/dist/es2015/DPoint.js

@@ -25,13 +25,33 @@ export class DPoint {
     static zero() {
         return new DPoint();
     }
-    static parse(c) {
-        const { lat, lon, lng = lon } = c;
+    static parse(c, format = 'xyz') {
+        const { lat, lon, lng = lon, alt } = c;
         if (lat && lng) {
-            return new DPoint(lat, lng, 0);
+            return new DPoint(lng, lat, alt !== null && alt !== void 0 ? alt : 0);
         }
-        const [x, y, z] = c;
-        return new DPoint(x, y, z);
+        let t = c;
+        if (c.type === 'Point') {
+            t = c.coordinates;
+        }
+        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;
@@ -99,11 +119,20 @@ export class DPoint {
         const y = PI_IN_DEGREE / Math.PI * Math.atan((Math.exp(n) - Math.exp(-n)) / 2);
         return new DPoint(x, y, zoom);
     }
-    toCoords() {
-        if (this.z === undefined) {
-            return [this.x, this.y];
-        }
-        return [this.x, this.y, this.z];
+    toCoords(format = 'xyz') {
+        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 = 'xyz') {
+        return {
+            type: 'Point',
+            coordinates: this.toCoords(format)
+        };
     }
     findLine(p) {
         checkFunction('findLine')
@@ -466,6 +495,18 @@ export class DPoint {
     get hPoint() {
         return this.yPoint;
     }
+    get lat() {
+        return this.y;
+    }
+    get lng() {
+        return this.x;
+    }
+    get lon() {
+        return this.x;
+    }
+    get alt() {
+        return this.z;
+    }
     simple(xKey = 'x', yKey = 'y') {
         return {
             [xKey]: this.x,

package/dist/es2015/DPolygon.js

@@ -618,11 +618,92 @@ export class DPolygon {
         }
         return this;
     }
-    static parse(a) {
-        return new DPolygon(a.map((r) => DPoint.parse(r)));
+    static toGeoJSONFeatureCollection(polygons, format = 'xyz') {
+        return {
+            type: 'FeatureCollection',
+            features: polygons.map((polygon) => polygon.toGeoJSONFeature(format))
+        };
+    }
+    static parse(a, format = 'xyz') {
+        if (a.type) {
+            switch (a.type) {
+                case 'FeatureCollection':
+                    return a.features.reduce((ak, f) => {
+                        const t = DPolygon.parse(f, format);
+                        if (Array.isArray(t)) {
+                            ak.push(...t);
+                        }
+                        else {
+                            ak.push(t);
+                        }
+                        return ak;
+                    }, []);
+                case 'Feature': {
+                    const t = DPolygon.parse(a.geometry, format);
+                    t.properties = Object.assign(Object.assign({}, a.properties), { id: a.id });
+                    return t;
+                }
+                case 'LineString':
+                case 'MultiPoint':
+                    return new DPolygon(a.coordinates.map((c) => DPoint.parse(c, format)));
+                case 'Polygon':
+                    return a.coordinates.reduce((ak, line, index) => {
+                        if (index === 0) {
+                            ak.points = line.map((c) => DPoint.parse(c, format));
+                        }
+                        else {
+                            ak.holes.push(new DPolygon(line.map((c) => DPoint.parse(c, format))));
+                        }
+                        return ak;
+                    }, new DPolygon());
+                case 'MultiLineString':
+                    return a.coordinates.reduce((ak, line) => {
+                        ak.push(new DPolygon(line.map((c) => DPoint.parse(c, format))));
+                        return ak;
+                    }, []);
+                case 'MultiPolygon':
+                    return a.coordinates.reduce((ak, coordinates) => {
+                        ak.push(DPolygon.parse({
+                            type: 'Polygon',
+                            coordinates
+                        }, format));
+                        return ak;
+                    }, []);
+                case 'GeometryCollection':
+                    return a.geometries.reduce((ak, line) => {
+                        ak.push(DPolygon.parse(line, format));
+                        return ak;
+                    }, []);
+                default:
+            }
+        }
+        return new DPolygon(a
+            .map((r) => DPoint.parse(r, format)));
     }
-    toArrayOfCoords() {
-        return this.mapArray((r) => r.toCoords());
+    toArrayOfCoords(format = 'xyz') {
+        return this.mapArray((r) => r.toCoords(format));
+    }
+    toGeoJSONFeature(format = 'xyz') {
+        return {
+            type: 'Feature',
+            properties: Object.assign({}, this.properties),
+            geometry: this.toGeoJSON(format)
+        };
+    }
+    toGeoJSON(format = 'xyz') {
+        if (this.closed) {
+            return {
+                type: 'Polygon',
+                coordinates: [
+                    this.toArrayOfCoords(format),
+                    ...this.holes.map((h) => h.toArrayOfCoords(format))
+                ]
+            };
+        }
+        return {
+            type: 'LineString',
+            coordinates: this.toArrayOfCoords(format)
+        };
     }
     divideToPieces(piecesCount, withAltitude = false) {
         const { fullLength } = this;

package/dist/esm/DPoint.js

@@ -54,13 +54,34 @@ var DPoint = (function () {
     DPoint.zero = function () {
         return new DPoint();
     };
-    DPoint.parse = function (c) {
-        var _a = c, lat = _a.lat, lon = _a.lon, _b = _a.lng, lng = _b === void 0 ? lon : _b;
+    DPoint.parse = function (c, format) {
+        if (format === void 0) { format = 'xyz'; }
+        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(lat, lng, 0);
+            return new DPoint(lng, lat, alt !== null && alt !== void 0 ? alt : 0);
         }
-        var _c = __read(c, 3), x = _c[0], y = _c[1], z = _c[2];
-        return new DPoint(x, y, z);
+        var t = c;
+        if (c.type === 'Point') {
+            t = c.coordinates;
+        }
+        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;
@@ -131,11 +152,23 @@ var DPoint = (function () {
         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 () {
-        if (this.z === undefined) {
-            return [this.x, this.y];
-        }
-        return [this.x, this.y, this.z];
+    DPoint.prototype.toCoords = function (format) {
+        var _this = this;
+        if (format === void 0) { format = 'xyz'; }
+        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 = 'xyz'; }
+        return {
+            type: 'Point',
+            coordinates: this.toCoords(format)
+        };
     };
     DPoint.prototype.findLine = function (p) {
         checkFunction('findLine')
@@ -559,6 +592,34 @@ var DPoint = (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(DPoint.prototype, "lat", {
+        get: function () {
+            return this.y;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPoint.prototype, "lng", {
+        get: function () {
+            return this.x;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPoint.prototype, "lon", {
+        get: function () {
+            return this.x;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPoint.prototype, "alt", {
+        get: function () {
+            return this.z;
+        },
+        enumerable: false,
+        configurable: true
+    });
     DPoint.prototype.simple = function (xKey, yKey) {
         var _a;
         if (xKey === void 0) { xKey = 'x'; }