egovamap 0.23.0 → 0.24.1

package/egovamap/GeometryTrans.js

@@ -0,0 +1,96 @@
+import RingsConvert from "./RingsConvert";
+function checkGeometryType(geometryType) {
+    let types = [
+        "Point",
+        "MultiPoint",
+        "LineString",
+        "MultiLineString",
+        "Polygon",
+        "MultiPolygon",
+    ];
+    return types.includes(geometryType);
+}
+let GeometryTrans = {
+    agsToWKT: function (geometry) {
+        var wktStr = "";
+        if (geometry["rings"] && geometry["rings"].length) {
+            geometry = RingsConvert(geometry["rings"]);
+            wktStr = JSON.stringify(geometry.coordinates);
+            wktStr = wktStr
+                .replace(/\[(-?\d+\.?\d*E?\d*),(-?\d+\.?\d*E?\d*)\]/g, "$1 $2")
+                .replace(/\[/g, "(")
+                .replace(/\]/g, ")");
+            if (geometry.type == "Polygon") {
+                wktStr = "POLYGON" + wktStr;
+            } else {
+                wktStr = "MULTIPOLYGON" + wktStr;
+            }
+        } else if (geometry["paths"] && geometry["paths"].length) {
+            wktStr = JSON.stringify(geometry["paths"]);
+            wktStr = wktStr.replace(
+                /\[(-?\d+\.?\d*E?\d*),(-?\d+\.?\d*E?\d*)\]/g,
+                "$1 $2"
+            );
+            wktStr = wktStr.replace(/\[/g, "(").replace(/\]/g, ")");
+            wktStr = "MULTILINESTRING" + wktStr;
+        } else if (geometry["x"] !== undefined && geometry["y"] !== undefined) {
+            wktStr = "POINT(" + geometry["x"] + " " + geometry["y"] + ")";
+        } else if (geometry["xmin"] != undefined) {
+            xmin = geometry["xmin"];
+            ymin = geometry["ymin"] || 0;
+            xmax = geometry["xmax"] || 0;
+            ymax = geometry["ymax"] || 0;
+            wktStr =
+                "POLYGON((" +
+                xmin +
+                " " +
+                ymin +
+                "," +
+                xmax +
+                " " +
+                ymin +
+                "," +
+                xmax +
+                " " +
+                ymax +
+                "," +
+                xmin +
+                " " +
+                ymax +
+                "," +
+                xmin +
+                " " +
+                ymin +
+                "))";
+        }
+        return wktStr;
+    },
+    geoJsonToWKT: function (geometry) {
+        let geometryType = geometry.type;
+        if (!geometryType || !checkGeometryType(geometryType)) {
+            return `${geometryType}是不支持的几何类型`;
+        }
+        let coordinates = geometry["coordinates"];
+        var wktStr = "";
+        wktStr = JSON.stringify(coordinates);
+        wktStr = wktStr.replace(
+            /\[(-?\d+\.?\d*E?\d*),(-?\d+\.?\d*E?\d*)\]/g,
+            "$1 $2"
+        );
+        wktStr = wktStr.replace(/\[/g, "(").replace(/\]/g, ")");
+        if (geometryType === 'Point') {
+            wktStr = geometryType.toUpperCase() + "(" + wktStr + ")";
+        } else {
+            wktStr = geometryType.toUpperCase() + wktStr;
+        }
+        return wktStr;
+    },
+    geometryToWKT: function (geometry) {
+        if (geometry["coordinates"]) {
+            return this.geoJsonToWKT(geometry)
+        } else {
+            return this.agsToWKT(geometry)
+        }
+    }
+};
+export default GeometryTrans;

package/egovamap/RingsConvert.js

@@ -0,0 +1,172 @@
+function isNumber(n) {
+    return !isNaN(parseFloat(n)) && isFinite(n);
+}
+
+function ringIsClockwise(ringToTest) {
+    var total = 0,
+        i = 0;
+    var rLength = ringToTest.length;
+    var pt1 = ringToTest[i];
+    var pt2;
+    for (i; i < rLength - 1; i++) {
+        pt2 = ringToTest[i + 1];
+        total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]);
+        pt1 = pt2;
+    }
+    return (total >= 0);
+}
+
+function closeRing(coordinates) {
+    if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) {
+        coordinates.push(coordinates[0]);
+    }
+    return coordinates;
+}
+
+// checks if 2 x,y points are equal
+function pointsEqual(a, b) {
+    for (var i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function coordinatesContainPoint(coordinates, point) {
+    var contains = false;
+    for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) {
+        if (((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1]) ||
+            (coordinates[j][1] <= point[1] && point[1] < coordinates[i][1])) &&
+            (point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0])) {
+            contains = !contains;
+        }
+    }
+    return contains;
+}
+
+function edgeIntersectsEdge(a1, a2, b1, b2) {
+    var ua_t = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);
+    var ub_t = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);
+    var u_b = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);
+
+    if (u_b !== 0) {
+        var ua = ua_t / u_b;
+        var ub = ub_t / u_b;
+
+        if (0 <= ua && ua <= 1 && 0 <= ub && ub <= 1) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function arraysIntersectArrays(a, b) {
+    if (isNumber(a[0][0])) {
+        if (isNumber(b[0][0])) {
+            for (var i = 0; i < a.length - 1; i++) {
+                for (var j = 0; j < b.length - 1; j++) {
+                    if (edgeIntersectsEdge(a[i], a[i + 1], b[j], b[j + 1])) {
+                        return true;
+                    }
+                }
+            }
+        } else {
+            for (var k = 0; k < b.length; k++) {
+                if (arraysIntersectArrays(a, b[k])) {
+                    return true;
+                }
+            }
+        }
+    } else {
+        for (var l = 0; l < a.length; l++) {
+            if (arraysIntersectArrays(a[l], b)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+function coordinatesContainCoordinates(outer, inner) {
+    var intersects = arraysIntersectArrays(outer, inner);
+    var contains = coordinatesContainPoint(outer, inner[0]);
+    if (!intersects && contains) {
+        return true;
+    }
+    return false;
+}
+
+function convertRingsToGeoJSON(rings) {
+    var outerRings = [];
+    var holes = [];
+    var x;
+    var outerRing;
+    var hole;
+
+    
+    for (var r = 0; r < rings.length; r++) {
+        var ring = closeRing(rings[r].slice(0));
+        if (ring.length < 4) {
+            continue;
+        }
+
+        if (ringIsClockwise(ring)) {
+            var polygon = [ring.slice().reverse()];
+            outerRings.push(polygon);
+        } else {
+            holes.push(ring.slice().reverse());
+        }
+    }
+
+    var uncontainedHoles = [];
+
+    while (holes.length) {
+        hole = holes.pop();
+        var contained = false;
+        for (x = outerRings.length - 1; x >= 0; x--) {
+            outerRing = outerRings[x][0];
+            if (coordinatesContainCoordinates(outerRing, hole)) {
+                outerRings[x].push(hole);
+                contained = true;
+                break;
+            }
+        }
+
+        if (!contained) {
+            uncontainedHoles.push(hole);
+        }
+    }
+
+    while (uncontainedHoles.length) {
+        hole = uncontainedHoles.pop();
+
+        var intersects = false;
+        for (x = outerRings.length - 1; x >= 0; x--) {
+            outerRing = outerRings[x][0];
+            if (arraysIntersectArrays(outerRing, hole)) {
+                outerRings[x].push(hole);
+                intersects = true;
+                break;
+            }
+        }
+
+        if (!intersects) {
+            outerRings.push([hole.reverse()]);
+        }
+    }
+
+    if (outerRings.length === 1) {
+        return {
+            type: 'Polygon',
+            coordinates: outerRings[0]
+        };
+    } else {
+        return {
+            type: 'MultiPolygon',
+            coordinates: outerRings
+        };
+    }
+}
+export default convertRingsToGeoJSON;

package/egovamap/egovaBI.js

@@ -1019,7 +1019,8 @@ var egovaBI = function(globeMap, gisMap, mapType){
                 maxZoom: options.visiblitySetting.endLevel,
                 layerId: options.layerName,
                 comCallbak: callback,
-                order: options.order
+                order: options.order,
+                inverse: options.inverse
                 // hLabelStyle: options.hLabelStyle, // 选中文字时效果，没用
             };
             if (options.labelSetting.labelZoomEnabled == 'show') {

package/egovamap/egovamap.js

@@ -8,7 +8,7 @@ import MapSwich from './mapswich';
 import EGovaScene from './EGovaScene';
 import MapUtils from './mapUtils';
 import './egovamap.css';
-
+import GeometryTrans from './GeometryTrans';
 var defaultMapID = null;
 var mapList = {};
 var mapArray = [];
@@ -4369,6 +4369,11 @@ var EGovaMap = function (containerID, callback, mapConfig, mapType, mapParam, co
 		  gisMap.agsToWKT(geometry, callback);
 		}
 	}
+
+	//geometyr转WKT
+	that.geometryToWKT = function(geometry){
+		return GeometryTrans.geometryToWKT(geometry)
+	}
 	that.initMap(containerID, callback, mapType, mapConfig);
 
 	// EGovaBI(globeMap).bind(this)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "egovamap",
-  "version": "0.23.0",
+  "version": "0.24.1",
   "description": "eUrbanGIS SDK",
   "main": "index.js",
   "scripts": {