dgeoutils 2.4.6 → 2.4.9

package/dist/esm/DPolygon.js

@@ -1,3 +1,14 @@
+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;
@@ -952,11 +963,96 @@ var DPolygon = (function () {
         }
         return this;
     };
-    DPolygon.parse = function (a) {
-        return new DPolygon(a.map(function (r) { return 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.parse(c, format); }));
+                case 'Polygon':
+                    return a.coordinates.reduce(function (ak, line, index) {
+                        if (index === 0) {
+                            ak.points = line.map(function (c) { return DPoint.parse(c, format); });
+                        }
+                        else {
+                            ak.holes.push(new DPolygon(line.map(function (c) { return 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.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.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;