qwc2
Version:
QGIS Web Client
594 lines (593 loc) • 29.1 kB
JavaScript
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
/**
* Copyright 2017-2024 Sourcepole AG
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
import geojsonBbox from 'geojson-bounding-box';
import isEmpty from 'lodash.isempty';
import { getDefaultImageStyle } from 'ol/format/KML';
import ol from 'openlayers';
import simplepolygon from 'simplepolygon';
import svgpath from 'svgpath';
import { v4 as uuidv4 } from 'uuid';
import ConfigUtils from '../utils/ConfigUtils';
import CoordinatesUtils from '../utils/CoordinatesUtils';
import { END_MARKERS, computeFeatureStyle } from '../utils/FeatureStyles';
var VectorLayerUtils = {
createPrintHighlighParams: function createPrintHighlighParams(layers, printCrs, printScale) {
var dpi = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 96;
var scaleFactor = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1.0;
var qgisServerVersion = ConfigUtils.getConfigProp("qgisServerVersion", null, 3);
var params = {
geoms: [],
styles: [],
labels: [],
labelFillColors: [],
labelOutlineColors: [],
labelOutlineSizes: [],
labelRotations: [],
labelSizes: [],
labelDist: []
};
var ensureHex = null;
if (qgisServerVersion >= 3) {
ensureHex = function ensureHex(rgb) {
return !Array.isArray(rgb) ? rgb : '#' + [255 - (rgb.length > 3 ? rgb[3] : 1) * 255].concat(_toConsumableArray(rgb.slice(0, 3))).map(function (v) {
return Math.round(v).toString(16).padStart(2, '0');
}).join('');
};
} else {
ensureHex = function ensureHex(rgb) {
return !Array.isArray(rgb) ? rgb : '#' + (0x1000000 + (rgb[2] | rgb[1] << 8 | rgb[0] << 16)).toString(16).slice(1);
};
}
var _iterator = _createForOfIteratorHelper(layers.slice(0).reverse()),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var layer = _step.value;
if (layer.type !== 'vector' || (layer.features || []).length === 0 || layer.visibility === false || layer.skipPrint === true) {
continue;
}
var features = layer.features.map(function (feature) {
var _feature$geometry;
if ((_feature$geometry = feature.geometry) !== null && _feature$geometry !== void 0 && _feature$geometry.coordinates) {
feature = _objectSpread(_objectSpread({}, feature), {}, {
geometry: _objectSpread(_objectSpread({}, feature.geometry), {}, {
coordinates: VectorLayerUtils.removeDuplicateNodes(feature.geometry.coordinates)
})
});
}
return VectorLayerUtils.simplifyFeature(feature);
}).flat();
var _iterator2 = _createForOfIteratorHelper(features),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var feature = _step2.value;
if (!VectorLayerUtils.validateGeometry(feature.geometry)) {
continue;
}
var styleOptions = computeFeatureStyle(layer, feature);
var properties = feature.properties || {};
var geometry = VectorLayerUtils.reprojectGeometry(feature.geometry, feature.crs || printCrs, printCrs);
if (feature.geometry.type === "LineString") {
// Generate arrow heads
if (styleOptions.headmarker) {
VectorLayerUtils.generateMarkerGeometry(params, styleOptions.headmarker, false, feature, layer, dpi, printScale, printCrs, scaleFactor);
}
if (styleOptions.tailmarker) {
VectorLayerUtils.generateMarkerGeometry(params, styleOptions.tailmarker, true, feature, layer, dpi, printScale, printCrs, scaleFactor);
}
}
if (feature.geometry.type === "LineString" && !isEmpty(properties.segment_labels)) {
// Split line into single segments and label them individually
var coords = geometry.coordinates;
for (var i = 0; i < coords.length - 1; ++i) {
var segment = {
type: "LineString",
coordinates: [coords[i], coords[i + 1]]
};
params.styles.push(VectorLayerUtils.createSld(segment.type, feature.styleName, styleOptions, layer.opacity, dpi, scaleFactor));
params.labels.push(properties.segment_labels[i] || " ");
params.geoms.push(VectorLayerUtils.geoJSONGeomToWkt(segment));
params.labelFillColors.push(ensureHex(styleOptions.textFill));
params.labelOutlineColors.push(ensureHex(styleOptions.textStroke));
params.labelOutlineSizes.push(scaleFactor);
params.labelSizes.push(Math.round(10 * scaleFactor));
params.labelDist.push("-5");
params.labelRotations.push("0");
}
} else {
params.styles.push(VectorLayerUtils.createSld(geometry.type, feature.styleName, styleOptions, layer.opacity, dpi, scaleFactor));
params.labels.push(properties.label || " ");
if (feature.styleName === "text") {
// Make point a tiny square, so that QGIS server centers the text inside the polygon when labelling
var x = geometry.coordinates[0];
var y = geometry.coordinates[1];
geometry = {
type: "Polygon",
coordinates: [[[x - 0.01, y - 0.01], [x + 0.01, y - 0.01], [x + 0.01, y + 0.01], [x - 0.01, y + 0.01], [x - 0.01, y - 0.01]]]
};
params.geoms.push(VectorLayerUtils.geoJSONGeomToWkt(geometry));
params.labelFillColors.push(ensureHex(styleOptions.fillColor));
params.labelOutlineColors.push(ensureHex(styleOptions.strokeColor));
params.labelOutlineSizes.push(scaleFactor * styleOptions.strokeWidth * 0.5);
params.labelSizes.push(Math.round(10 * styleOptions.strokeWidth * scaleFactor));
params.labelDist.push("5");
params.labelRotations.push(((properties.rotation || 0) / Math.PI * 180).toFixed(0));
} else {
params.geoms.push(VectorLayerUtils.geoJSONGeomToWkt(geometry));
params.labelFillColors.push(ensureHex(styleOptions.textFill));
params.labelOutlineColors.push(ensureHex(styleOptions.textStroke));
params.labelOutlineSizes.push(scaleFactor);
params.labelSizes.push(Math.round(10 * scaleFactor));
params.labelDist.push("-5");
params.labelRotations.push("0");
}
}
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
return params;
},
removeDuplicateNodes: function removeDuplicateNodes(coordinates) {
if (Array.isArray(coordinates[0][0])) {
return coordinates.map(VectorLayerUtils.removeDuplicateNodes);
} else if (Array.isArray(coordinates[0])) {
return coordinates.filter(function (item, pos, arr) {
return pos === 0 || item[0] !== arr[pos - 1][0] || item[1] !== arr[pos - 1][1];
});
} else {
return coordinates;
}
},
simplifyFeature: function simplifyFeature(feature) {
if (!feature.geometry) {
return feature;
} else if (feature.geometry.type === "MultiPolygon") {
return feature.geometry.coordinates.map(function (part) {
return VectorLayerUtils.simplifyFeature(_objectSpread(_objectSpread({}, feature), {}, {
geometry: {
type: "Polygon",
coordinates: part
}
}));
}).flat();
} else if (feature.geometry.type === "Polygon") {
return simplepolygon(feature).features.map(function (feat, idx, features) {
if (feat.properties.parent >= 0) {
features[feat.properties.parent].geometry.coordinates.push(feat.geometry.coordinates[0]);
return null;
}
return feat;
}).filter(function (x) {
return x;
}).map(function (feat) {
return _objectSpread(_objectSpread({}, feature), {}, {
geometry: feat.geometry
});
});
} else {
return feature;
}
},
validateGeometry: function validateGeometry(geometry) {
if (!geometry) {
return false;
}
if (geometry.type === "GeometryCollection") {
return geometry.geometries.every(VectorLayerUtils.validateGeometry);
}
if (geometry.type === "Point") {
return !isEmpty(geometry.coordinates);
}
var minLength = geometry.type.endsWith("LineString") ? 2 : 3;
var _isDegenerate = function isDegenerate(coordinates) {
if (Array.isArray(coordinates[0][0])) {
return coordinates.map(_isDegenerate).find(function (entry) {
return entry === false;
});
} else {
return coordinates.length < minLength;
}
};
return !_isDegenerate(geometry.coordinates);
},
createSld: function createSld(geometrytype, styleName, styleOptions, layerOpacity) {
var dpi = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 96;
var scaleFactor = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1.0;
var opts = {};
var dpiScale = dpi / 96 * scaleFactor;
// Special cases
if (styleName === 'text') {
// Make geometry transparent
opts = {
strokeColor: [0, 0, 0, 0],
fillColor: [0, 0, 0, 0]
};
} else if (styleName === 'marker') {
opts = {
strokeColor: [0, 0, 255, 1],
strokeWidth: 1 * dpiScale,
fillColor: [255, 255, 255, 1],
circleRadius: 2 * dpiScale
};
} else {
// Default style
opts = styleOptions;
}
var ensureHex = function ensureHex(rgb) {
return !Array.isArray(rgb) ? rgb : '#' + (0x1000000 + (rgb[2] | rgb[1] << 8 | rgb[0] << 16)).toString(16).slice(1);
};
var opacity = function opacity(rgb) {
if (Array.isArray(rgb) && rgb.length > 3) {
return rgb[3] * layerOpacity / 255;
}
return 1 * layerOpacity / 255;
};
var stroke = '<se:Stroke>' + '<se:SvgParameter name="stroke">' + ensureHex(opts.strokeColor) + '</se:SvgParameter>' + '<se:SvgParameter name="stroke-opacity">' + opacity(opts.strokeColor) + '</se:SvgParameter>' + '<se:SvgParameter name="stroke-width">' + opts.strokeWidth * dpiScale + '</se:SvgParameter>' + '<se:SvgParameter name="stroke-linejoin">round</se:SvgParameter>' + (!isEmpty(opts.strokeDash) ? '<se:SvgParameter name="stroke-dasharray">' + opts.strokeDash.map(function (x) {
return x * dpiScale;
}).join(' ') + '</se:SvgParameter>' : '') + '</se:Stroke>';
var fill = '<se:Fill>' + '<se:SvgParameter name="fill">' + ensureHex(opts.fillColor) + '</se:SvgParameter>' + '<se:SvgParameter name="fill-opacity">' + opacity(opts.fillColor) + '</se:SvgParameter>' + '</se:Fill>';
var rule = null;
if (geometrytype.endsWith("Point")) {
rule = '<se:PointSymbolizer>' + '<se:Graphic>' + '<se:Mark>' + '<se:WellKnownName>circle</se:WellKnownName>' + '<se:Stroke>' + '<se:SvgParameter name="stroke">' + ensureHex(opts.strokeColor) + '</se:SvgParameter>' + '<se:SvgParameter name="stroke-opacity">' + opacity(opts.strokeColor) + '</se:SvgParameter>' + '<se:SvgParameter name="stroke-width">' + opts.strokeWidth * dpiScale + '</se:SvgParameter>' + '</se:Stroke>' + fill + '</se:Mark>' + '<se:Size>' + 2 * opts.circleRadius * dpiScale + '</se:Size>' + '</se:Graphic>' + '</se:PointSymbolizer>';
} else if (geometrytype.endsWith("LineString")) {
rule = '<se:LineSymbolizer>' + stroke + '</se:LineSymbolizer>';
} else if (geometrytype.endsWith("Polygon")) {
rule = '<se:PolygonSymbolizer>' + stroke + fill + '</se:PolygonSymbolizer>';
}
if (rule) {
return '<?xml version="1.0" encoding="UTF-8"?>' + '<StyledLayerDescriptor xmlns="http://www.opengis.net/sld" xmlns:ogc="http://www.opengis.net/ogc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.1.0/StyledLayerDescriptor.xsd" xmlns:se="http://www.opengis.net/se">' + '<UserStyle>' + '<se:FeatureTypeStyle>' + '<se:Rule>' + rule + '</se:Rule>' + '</se:FeatureTypeStyle>' + '</UserStyle>' + '</StyledLayerDescriptor>';
}
return null;
},
generateMarkerGeometry: function generateMarkerGeometry(params, markername, tail, feature, layer, dpi, mapScale, printCrs, scaleFactor) {
if (!END_MARKERS[markername]) {
return;
}
var marker = END_MARKERS[markername];
// Read the SVG and generate a matching WKT geometry for the marker
var path = '';
var width = 0;
var height = 0;
try {
var parser = new DOMParser();
var svgSrc = atob(marker.src.slice(26));
var svgDoc = parser.parseFromString(svgSrc, "text/xml");
width = parseInt(svgDoc.getElementsByTagName("svg")[0].getAttribute("width"), 10);
height = parseInt(svgDoc.getElementsByTagName("svg")[0].getAttribute("height"), 10);
path = svgDoc.getElementsByTagName("path")[0].getAttribute("d");
} catch (e) {
/* eslint-disable-next-line */
console.warn("Could not parse path for marker " + markername);
return;
}
// [ Same as in FeatureStyles.js ] [ pixel to map units ]
var markerScaleFactor = 0.125 * (1 + feature.styleOptions.strokeWidth) / dpi * 0.0254 * mapScale * scaleFactor;
var origin = feature.geometry.coordinates[tail ? feature.geometry.coordinates.length - 1 : 0];
var p2 = feature.geometry.coordinates[tail ? feature.geometry.coordinates.length - 2 : 1];
var coordinates = [];
var angle = 0.5 * Math.PI + Math.atan2(origin[0] - p2[0], origin[1] - p2[1]);
var alpha = marker.baserotation / 180 * Math.PI + angle;
var cosa = Math.cos(alpha);
var sina = Math.sin(alpha);
svgpath(path).iterate(function (segment, index, x, y) {
// Skip move instructions
if (["m", "M"].includes(segment[0])) {
return;
}
var dx = (x - marker.anchor[0] * width) * markerScaleFactor;
var dy = (y - marker.anchor[1] * height) * markerScaleFactor;
var rx = cosa * dx + sina * dy;
var ry = -sina * dx + cosa * dy;
coordinates.push([origin[0] + rx, origin[1] + ry]);
});
// Closing coordinate
coordinates.push(coordinates[0]);
var geometry = {
type: "Polygon",
coordinates: [coordinates]
};
var styleOptions = {
strokeWidth: 1,
strokeDash: [],
strokeColor: feature.styleOptions.strokeColor,
fillColor: feature.styleOptions.strokeColor
};
params.styles.push(VectorLayerUtils.createSld(geometry.type, "default", styleOptions, layer.opacity, dpi, scaleFactor));
params.geoms.push(VectorLayerUtils.geoJSONGeomToWkt(geometry));
params.labels.push(" ");
params.labelFillColors.push("#FFF");
params.labelOutlineColors.push("#FFF");
params.labelOutlineSizes.push(scaleFactor);
params.labelSizes.push(Math.round(10 * scaleFactor));
params.labelDist.push("0");
},
reprojectGeometry: function reprojectGeometry(geometry, srccrs, dstcrs) {
if (srccrs === dstcrs || !srccrs || !dstcrs) {
return geometry;
}
if (geometry.type === "Point") {
var wgscoo = CoordinatesUtils.reproject(geometry.coordinates, srccrs, dstcrs);
return {
type: geometry.type,
coordinates: wgscoo
};
} else if (geometry.type === "LineString" || geometry.type === "MultiPoint") {
return {
type: geometry.type,
coordinates: geometry.coordinates.map(function (tuple) {
return CoordinatesUtils.reproject(tuple, srccrs, dstcrs);
})
};
} else if (geometry.type === "Polygon" || geometry.type === "MultiLineString") {
return {
type: geometry.type,
coordinates: geometry.coordinates.map(function (ring) {
return ring.map(function (tuple) {
return CoordinatesUtils.reproject(tuple, srccrs, dstcrs);
});
})
};
} else if (geometry.type === "MultiPolygon") {
return {
type: geometry.type,
coordinates: geometry.coordinates.map(function (part) {
return part.map(function (ring) {
return ring.map(function (tuple) {
return CoordinatesUtils.reproject(tuple, srccrs, dstcrs);
});
});
})
};
} else {
return geometry;
}
},
reprojectFeature: function reprojectFeature(feature, srccrs, dstcrs) {
if (srccrs === dstcrs || !srccrs || !dstcrs) {
return feature;
}
if (feature.features) {
return _objectSpread(_objectSpread({}, feature), {}, {
features: feature.features.map(function (f) {
return VectorLayerUtils.reprojectFeature(srccrs, dstcrs);
})
});
} else {
return _objectSpread(_objectSpread({}, feature), {}, {
geometry: VectorLayerUtils.reprojectGeometry(feature.geometry, srccrs, dstcrs)
});
}
},
wktToGeoJSON: function wktToGeoJSON(wkt, srccrs, dstcrs) {
var id = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : uuidv4();
wkt = wkt.replace(/Point(\w+)/i, "Point $1").replace(/LineString(\w+)/i, "LineString $1").replace(/Polygon(\w+)/i, "Polygon $1").replace(/MultiSurface(\w*)/i, "GeometryCollection $1");
try {
var feature = new ol.format.WKT().readFeature(wkt, {
dataProjection: srccrs,
featureProjection: dstcrs
});
var featureObj = new ol.format.GeoJSON().writeFeatureObject(feature);
featureObj.id = id;
return featureObj;
} catch (e) {
/* eslint-disable-next-line */
console.warn("Failed to parse geometry: " + wkt);
return null;
}
},
geoJSONGeomToWkt: function geoJSONGeomToWkt(gj) {
var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
if (precision === undefined) {
precision = ConfigUtils.getConfigProp("wmsWktPrecision", null, 4);
}
if (gj.type === 'Feature') {
gj = gj.geometry;
}
var wrapParens = function wrapParens(s) {
return '(' + s + ')';
};
var pairWKT = function pairWKT(c) {
return c.map(function (x) {
return x.toFixed(precision);
}).join(' ');
};
var ringWKT = function ringWKT(r) {
return r.map(pairWKT).join(', ');
};
var ringsWKT = function ringsWKT(r) {
return r.map(ringWKT).map(wrapParens).join(', ');
};
var multiRingsWKT = function multiRingsWKT(r) {
return r.map(ringsWKT).map(wrapParens).join(', ');
};
switch (gj.type) {
case 'Point':
return 'POINT (' + pairWKT(gj.coordinates) + ')';
case 'LineString':
return 'LINESTRING (' + ringWKT(gj.coordinates) + ')';
case 'Polygon':
return 'POLYGON (' + ringsWKT(gj.coordinates) + ')';
case 'MultiPoint':
return 'MULTIPOINT (' + ringWKT(gj.coordinates) + ')';
case 'MultiPolygon':
return 'MULTIPOLYGON (' + multiRingsWKT(gj.coordinates) + ')';
case 'MultiLineString':
return 'MULTILINESTRING (' + ringsWKT(gj.coordinates) + ')';
case 'GeometryCollection':
return 'GEOMETRYCOLLECTION (' + gj.geometries.map(function (x) {
return VectorLayerUtils.geoJSONGeomToWkt(x, precision);
}).join(', ') + ')';
default:
throw new Error('Invalid geometry object');
}
},
kmlToGeoJSON: function kmlToGeoJSON(kml) {
var kmlFormat = new ol.format.KML({
defaultStyle: [new ol.style.Style()]
});
var geojsonFormat = new ol.format.GeoJSON();
var features = [];
var _iterator3 = _createForOfIteratorHelper(kmlFormat.readFeatures(kml)),
_step3;
try {
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
var _feature$geometry2;
var olFeature = _step3.value;
var style = olFeature.getStyleFunction()(olFeature);
style = style[0] || style;
var styleOptions = {
strokeColor: style.getStroke() ? style.getStroke().getColor() : [0, 0, 0, 1],
strokeWidth: style.getStroke() ? style.getStroke().getWidth() : 1,
strokeDash: style.getStroke() ? style.getStroke().getLineDash() : [],
fillColor: style.getFill() ? style.getFill().getColor() : [255, 255, 255, 1],
textFill: style.getText() && style.getText().getFill() ? style.getText().getFill().getColor() : [0, 0, 0, 1],
textStroke: style.getText() && style.getText().getStroke() ? style.getText().getStroke().getColor() : [255, 255, 255, 1]
};
if (style.getImage() && style.getImage() !== getDefaultImageStyle() && style.getImage().getSrc()) {
// FIXME: Uses private members of ol.style.Icon, style.getImage().getAnchor() returns null because style.getImage.getSize() is null because the the image is not yet loaded
var anchor = style.getImage().anchor_ || [0.5, 0.5];
var anchorOrigin = (style.getImage().anchorOrigin_ || "").split("-");
if (anchorOrigin.includes("right")) {
anchor[0] = 1 - anchor[0];
}
if (anchorOrigin.includes("bottom")) {
anchor[1] = 1 - anchor[1];
}
styleOptions.iconSrc = style.getImage().getSrc();
styleOptions.iconAnchor = anchor;
}
var feature = geojsonFormat.writeFeatureObject(olFeature);
Object.assign(feature, {
styleName: styleOptions.iconSrc && ((_feature$geometry2 = feature.geometry) === null || _feature$geometry2 === void 0 ? void 0 : _feature$geometry2.type) === "Point" ? 'marker' : 'default',
styleOptions: styleOptions,
id: uuidv4(),
crs: "EPSG:4326",
properties: {}
});
var properties = olFeature.getProperties();
var excludedProperties = ['visibility', olFeature.getGeometryName()];
for (var _i = 0, _Object$keys = Object.keys(properties); _i < _Object$keys.length; _i++) {
var key = _Object$keys[_i];
if (!excludedProperties.includes(key)) {
feature.properties[key] = properties[key];
}
}
if (properties.name && feature.styleName === 'marker') {
feature.properties.label = properties.name;
}
features.push(feature);
}
} catch (err) {
_iterator3.e(err);
} finally {
_iterator3.f();
}
return features;
},
convert3dto2d: function convert3dto2d(entry) {
if (!Array.isArray(entry)) {
return entry;
} else if (entry.length >= 3 && !Array.isArray(entry[0])) {
return [entry[0], entry[1]];
} else if (Array.isArray(entry[0])) {
return entry.map(VectorLayerUtils.convert3dto2d);
}
return entry;
},
computeFeaturesBBox: function computeFeaturesBBox(features) {
var featureCrs = new Set();
features.forEach(function (feature) {
if (feature.crs) {
featureCrs.add(feature.crs);
}
});
var bboxCrs = featureCrs.size === 1 ? _toConsumableArray(featureCrs.keys())[0] : "EPSG:4326";
var bounds = geojsonBbox({
type: "FeatureCollection",
features: features.filter(function (feature) {
return feature.geometry;
}).map(function (feature) {
return _objectSpread(_objectSpread({}, feature), {}, {
geometry: feature.crs ? VectorLayerUtils.reprojectGeometry(feature.geometry, feature.crs, bboxCrs) : feature.geometry
});
})
});
// Discard z component
if (bounds.length === 6) {
bounds = [bounds[0], bounds[1], bounds[3], bounds[4]];
}
return {
crs: bboxCrs,
bounds: bounds
};
},
computeFeatureBBox: function computeFeatureBBox(feature) {
var bounds = geojsonBbox(feature);
// Discard z component
if (bounds.length === 6) {
bounds = [bounds[0], bounds[1], bounds[3], bounds[4]];
}
return bounds;
},
getFeatureCenter: function getFeatureCenter(feature) {
var geojson = new ol.format.GeoJSON().readFeature(feature);
var geometry = geojson.getGeometry();
var type = geometry.getType();
var center = null;
switch (type) {
case "Polygon":
center = geometry.getInteriorPoint().getCoordinates();
break;
case "MultiPolygon":
center = geometry.getInteriorPoints().getClosestPoint(ol.extent.getCenter(geometry.getExtent()));
break;
case "Point":
center = geometry.getCoordinates();
break;
case "MultiPoint":
center = geometry.getClosestPoint(ol.extent.getCenter(geometry.getExtent()));
break;
case "LineString":
center = geometry.getCoordinateAt(0.5);
break;
case "MultiLineString":
center = geometry.getClosestPoint(ol.extent.getCenter(geometry.getExtent()));
break;
case "Circle":
center = geometry.getCenter();
break;
default:
break;
}
return center;
}
};
export default VectorLayerUtils;