cesium-alpha-earth 1.0.72 → 1.0.74

package/dist/assets/geojson2Line-D52oeUm7.js

@@ -0,0 +1,165 @@
+(function() {
+  "use strict";
+  var earthRadius = 63710088e-1;
+  var factors = {
+    centimeters: earthRadius * 100,
+    centimetres: earthRadius * 100,
+    degrees: 360 / (2 * Math.PI),
+    feet: earthRadius * 3.28084,
+    inches: earthRadius * 39.37,
+    kilometers: earthRadius / 1e3,
+    kilometres: earthRadius / 1e3,
+    meters: earthRadius,
+    metres: earthRadius,
+    miles: earthRadius / 1609.344,
+    millimeters: earthRadius * 1e3,
+    millimetres: earthRadius * 1e3,
+    nauticalmiles: earthRadius / 1852,
+    radians: 1,
+    yards: earthRadius * 1.0936
+  };
+  function feature(geom, properties, options = {}) {
+    const feat = { type: "Feature" };
+    if (options.id === 0 || options.id) {
+      feat.id = options.id;
+    }
+    if (options.bbox) {
+      feat.bbox = options.bbox;
+    }
+    feat.properties = {};
+    feat.geometry = geom;
+    return feat;
+  }
+  function point(coordinates, properties, options = {}) {
+    if (!coordinates) {
+      throw new Error("coordinates is required");
+    }
+    if (!Array.isArray(coordinates)) {
+      throw new Error("coordinates must be an Array");
+    }
+    if (coordinates.length < 2) {
+      throw new Error("coordinates must be at least 2 numbers long");
+    }
+    if (!isNumber(coordinates[0]) || !isNumber(coordinates[1])) {
+      throw new Error("coordinates must contain numbers");
+    }
+    const geom = {
+      type: "Point",
+      coordinates
+    };
+    return feature(geom, properties, options);
+  }
+  function radiansToLength(radians, units = "kilometers") {
+    const factor = factors[units];
+    if (!factor) {
+      throw new Error(units + " units is invalid");
+    }
+    return radians * factor;
+  }
+  function degreesToRadians(degrees) {
+    const normalisedDegrees = degrees % 360;
+    return normalisedDegrees * Math.PI / 180;
+  }
+  function isNumber(num) {
+    return !isNaN(num) && num !== null && !Array.isArray(num);
+  }
+  function getCoord(coord) {
+    if (!coord) {
+      throw new Error("coord is required");
+    }
+    if (!Array.isArray(coord)) {
+      if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
+        return [...coord.geometry.coordinates];
+      }
+      if (coord.type === "Point") {
+        return [...coord.coordinates];
+      }
+    }
+    if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+      return [...coord];
+    }
+    throw new Error("coord must be GeoJSON Point or an Array of numbers");
+  }
+  function distance(from, to, options = {}) {
+    var coordinates1 = getCoord(from);
+    var coordinates2 = getCoord(to);
+    var dLat = degreesToRadians(coordinates2[1] - coordinates1[1]);
+    var dLon = degreesToRadians(coordinates2[0] - coordinates1[0]);
+    var lat1 = degreesToRadians(coordinates1[1]);
+    var lat2 = degreesToRadians(coordinates2[1]);
+    var a = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);
+    return radiansToLength(
+      2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)),
+      options.units
+    );
+  }
+  self.onmessage = (e) => {
+    let data = convertGeoJsonToGraph(e.data.geoJson, e.data.snapThreshold);
+    self.postMessage(data);
+  };
+  function convertGeoJsonToGraph(geoJson, snapThreshold) {
+    var _a;
+    let projectedFeatureCollection = {
+      features: [],
+      type: "FeatureCollection"
+    };
+    const nodes = /* @__PURE__ */ new Map();
+    let featureIndex = 0;
+    for (let feature2 of geoJson.features) {
+      if (!["LineString", "MultiLineString"].includes((_a = feature2.geometry) == null ? void 0 : _a.type)) {
+        console.warn(`Feature ${featureIndex} 不是线数据，跳过`);
+        return;
+      }
+      let coordinates = [];
+      if (feature2.geometry.type === "LineString") {
+        coordinates = [feature2.geometry.coordinates];
+      } else if (feature2.geometry.type === "MultiLineString") {
+        coordinates = feature2.geometry.coordinates;
+      }
+      for (const line of coordinates) {
+        let currentNodesLine = [];
+        for (const [index, position] of line.entries()) {
+          const [lng, lat] = position;
+          let currentNodeId = null;
+          let longitude = lng;
+          let latitude = lat;
+          if (index === 0 || index === line.length - 1) {
+            currentNodeId = findMatchedNode(nodes, [lng, lat], snapThreshold);
+            if (currentNodeId) {
+              let positionCoord = currentNodeId.split(",");
+              longitude = positionCoord[0];
+              latitude = positionCoord[1];
+            }
+          }
+          currentNodesLine.push([parseFloat(longitude), parseFloat(latitude)]);
+          projectedFeatureCollection.features.push({
+            type: "Feature",
+            geometry: {
+              type: "LineString",
+              coordinates: currentNodesLine
+            },
+            properties: {}
+          });
+          nodes.set(`${longitude},${latitude}`, {
+            id: `${longitude},${latitude}`,
+            coord: [longitude, latitude],
+            properties: feature2.properties
+          });
+        }
+      }
+      featureIndex += 1;
+    }
+    return projectedFeatureCollection;
+  }
+  function findMatchedNode(nodeCoordMap, coord, snapThreshold) {
+    let nearestNodeId = null;
+    nodeCoordMap.forEach((nodeId, coordKey) => {
+      const [lng, lat] = coordKey.split(",").map(Number);
+      const distance$1 = distance(point([lng, lat]), point(coord)) * 1e3;
+      if (distance$1 < snapThreshold) {
+        nearestNodeId = coordKey;
+      }
+    });
+    return nearestNodeId;
+  }
+})();

package/dist/assets/icon/geojson2Line.ts

@@ -0,0 +1,113 @@
+import createGraph from "ngraph.graph";
+import * as turf from "@turf/turf"
+import { FeatureCollection, LineString } from "geojson";
+import { NodeData } from "@/util/graphUtil/type";
+
+self.onmessage = (e: MessageEvent<{ geoJson: GeoJSON.FeatureCollection<GeoJSON.MultiLineString | GeoJSON.LineString>; snapThreshold: number }>) => {
+
+    let data:any = convertGeoJsonToGraph(e.data.geoJson, e.data.snapThreshold)
+
+    self.postMessage(data)
+
+}
+
+
+
+
+export function convertGeoJsonToGraph(
+    geoJson: GeoJSON.FeatureCollection<
+        GeoJSON.MultiLineString | GeoJSON.LineString
+    >,
+    snapThreshold: number
+) {
+    let projectedFeatureCollection: FeatureCollection<LineString> = {
+        features: [],
+        type: 'FeatureCollection'
+    }
+    //所有节点集合
+    const nodes = new Map<string, NodeData>();
+
+    let featureIndex = 0
+    for (let feature of geoJson.features) {
+        //判断类型
+        if (!['LineString', 'MultiLineString'].includes(feature.geometry?.type)) {
+            console.warn(`Feature ${featureIndex} 不是线数据，跳过`);
+            return;
+        }
+        //标准化坐标结构
+        let coordinates: any[] = [];
+
+        if (feature.geometry.type === 'LineString') {
+            coordinates = [feature.geometry.coordinates];
+        } else if (feature.geometry.type === 'MultiLineString') {
+            coordinates = feature.geometry.coordinates;
+        }
+
+        // 循环每一条线路 (替换forEach为for...of)
+        for (const line of coordinates) {
+            let currentNodesLine: any[] = [];
+
+            // 循环每一条线路的节点 (替换forEach为for...of，需要手动维护index)
+            for (const [index, position] of line.entries()) {
+                const [lng, lat] = position;
+                let currentNodeId: any = null;
+
+                let longitude = lng
+                let latitude = lat
+
+                // 判断是否是线路的第一个或最后一个节点
+                if (index === 0 || index === line.length - 1) {
+                    currentNodeId = findMatchedNode(nodes, [lng, lat], snapThreshold);
+                    if (currentNodeId) {
+                        let positionCoord = currentNodeId.split(',')
+                        longitude = positionCoord[0]
+                        latitude = positionCoord[1]
+                    }
+                }
+
+                currentNodesLine.push([parseFloat(longitude), parseFloat(latitude)])
+
+                projectedFeatureCollection.features.push({
+                    type: 'Feature',
+                    geometry: {
+                        type: 'LineString',
+                        coordinates: currentNodesLine
+                    },
+                    properties: {}
+                })
+
+
+
+                // 往nodes Map中添加节点数据
+                nodes.set(`${longitude},${latitude}`, {
+                    id: `${longitude},${latitude}`,
+                    coord: [longitude, latitude],
+                    properties: feature.properties
+                });
+            }
+
+
+        }
+
+        featureIndex += 1
+    }
+
+    return projectedFeatureCollection;
+
+}
+
+
+
+function findMatchedNode(nodeCoordMap: Map<string, NodeData>, coord: number[], snapThreshold: number) {
+    let nearestNodeId: string | null = null;
+
+    nodeCoordMap.forEach((nodeId, coordKey) => {
+        const [lng, lat] = coordKey.split(',').map(Number);
+        const distance = turf.distance(turf.point([lng, lat]), turf.point(coord)) * 1000;
+        if (distance < snapThreshold) {
+            nearestNodeId = coordKey
+        }
+    })
+
+    return nearestNodeId;
+}

package/dist/assets/icon/heightSimple.ts

@@ -0,0 +1,110 @@
+import { Cartesian3 } from "cesium";
+import * as THREE from "three";
+import {
+  computeBoundsTree,
+  disposeBoundsTree,
+  computeBatchedBoundsTree,
+  disposeBatchedBoundsTree,
+  acceleratedRaycast,
+} from "three-mesh-bvh";
+
+// Add the extension functions
+THREE.BufferGeometry.prototype.computeBoundsTree = computeBoundsTree;
+THREE.BufferGeometry.prototype.disposeBoundsTree = disposeBoundsTree;
+THREE.Mesh.prototype.raycast = acceleratedRaycast;
+
+THREE.BatchedMesh.prototype.computeBoundsTree = computeBatchedBoundsTree;
+THREE.BatchedMesh.prototype.disposeBoundsTree = disposeBatchedBoundsTree;
+THREE.BatchedMesh.prototype.raycast = acceleratedRaycast;
+
+self.onmessage = async (e: any) => {
+  let props: {
+    graphicsObjectUrl: string[];
+    rayPositions: Array<{
+      startPosition: Cartesian3;
+      endPosition: Cartesian3;
+      originPosition: Cartesian3;
+    }>;
+  } = e.data; 
+
+  
+  let graphicsObjectLoader = new THREE.ObjectLoader();
+
+  let graphicsObject3DCollection: THREE.Object3D<THREE.Object3DEventMap>[] = [];
+
+  
+  for (let index = 0; index < props.graphicsObjectUrl.length; index++) {
+    const url = props.graphicsObjectUrl[index];
+    let modelResolveFun: ((arg0: boolean) => void) | undefined = undefined;
+    //等待模型对象构建完成
+    graphicsObjectLoader.load(url, (modelGroup) => {
+      graphicsObject3DCollection.push(modelGroup);
+      if (modelResolveFun) {
+        modelResolveFun(true);
+      }
+    });
+    await new Promise((resolve) => (modelResolveFun = resolve));
+  }
+
+  let result = actionRay(props.rayPositions, graphicsObject3DCollection);
+  
+  self.postMessage(result)
+};
+
+function actionRay(
+  rayPositions: Array<{
+    startPosition: Cartesian3;
+    endPosition: Cartesian3;
+    originPosition: Cartesian3;
+  }>,
+  graphicsObject3D: THREE.Object3D<THREE.Object3DEventMap>[]
+) {
+  graphicsObject3D.forEach((obj) => {
+    obj.updateMatrixWorld();
+  });
+
+  let tilesGroundPositions: any[] = [];
+  let index = 0;
+  for (let info of rayPositions) {
+    const startPoint = new THREE.Vector3(
+      info.startPosition.x,
+      info.startPosition.y,
+      info.startPosition.z
+    ); // 起点坐标
+    const endPoint = new THREE.Vector3(
+      info.endPosition.x,
+      info.endPosition.y,
+      info.endPosition.z
+    ); // 终点坐标
+    const direction = new THREE.Vector3().subVectors(endPoint, startPoint);
+    direction.normalize();
+    const raycaster = new THREE.Raycaster();
+    raycaster.far=999999999
+    raycaster.near=0
+    raycaster.params.Line={
+      threshold:0.1
+    }
+    raycaster.params.Line2 = {
+      threshold: 0.1, // 检测阈值，数值越大检测范围越宽
+    };
+    raycaster.set(startPoint, direction);
+
+    let point = raycaster.intersectObjects([...graphicsObject3D]);
+    
+    if (point.length > 0) {
+      tilesGroundPositions.push({
+        index,
+        position: point[0].point,
+      });
+    }else{
+      tilesGroundPositions.push({
+        index,
+        undefined,
+      });
+    }
+
+    index += 1;
+  }
+
+  return tilesGroundPositions;
+}

package/dist/cesium-alpha-earth.css

@@ -3002,7 +3002,7 @@ canvas[data-v-b994ab5a] {
     --el-button-active-bg-color: rgba(40, 40, 60, 0.8);
     --el-button-active-border-color: rgba(60, 60, 80, 0.5);
 }
-.component-ui[data-v-7c97192c] {
+.component-ui[data-v-acaf6e87] {
   border-radius: 8px;
   padding: 16px;
   position: absolute;
@@ -3017,37 +3017,37 @@ canvas[data-v-b994ab5a] {
   width: 330px;
   font-family: "Microsoft YaHei", sans-serif;
 }
-.component-ui .header[data-v-7c97192c] {
+.component-ui .header[data-v-acaf6e87] {
   display: flex;
   justify-content: space-between;
   align-items: center;
   width: 100%;
   margin-bottom: 12px;
 }
-.component-ui .header span[data-v-7c97192c] {
+.component-ui .header span[data-v-acaf6e87] {
   font-size: 18px;
   font-weight: 600;
 }
-.component-ui .header .tip-icon[data-v-7c97192c] {
+.component-ui .header .tip-icon[data-v-acaf6e87] {
   width: 16px;
   height: 16px;
   margin: -2px 8px;
   cursor: help;
   color: #ccc;
 }
-.component-ui .header .tip-icon[data-v-7c97192c]:hover {
+.component-ui .header .tip-icon[data-v-acaf6e87]:hover {
   color: #fff;
 }
-.component-ui .header .closeBth[data-v-7c97192c] {
+.component-ui .header .closeBth[data-v-acaf6e87] {
   width: 24px;
   height: 24px;
   cursor: pointer;
   color: #ccc;
 }
-.component-ui .header .closeBth[data-v-7c97192c]:hover {
+.component-ui .header .closeBth[data-v-acaf6e87]:hover {
   color: #fff;
 }
-.component-ui .container[data-v-7c97192c] {
+.component-ui .container[data-v-acaf6e87] {
   display: flex;
   flex-direction: column;
   width: 100%;
@@ -3055,27 +3055,27 @@ canvas[data-v-b994ab5a] {
   align-items: center;
   justify-content: center;
 }
-.fileSelectContainer[data-v-7c97192c] {
+.fileSelectContainer[data-v-acaf6e87] {
   display: flex;
   flex-direction: column;
 }
-.treeContainer[data-v-7c97192c] {
+.treeContainer[data-v-acaf6e87] {
   min-width: 300px;
   margin-top: 15px;
 }
-.treeContainer .icon[data-v-7c97192c] {
+.treeContainer .icon[data-v-acaf6e87] {
   color: aqua;
   width: 20px;
   height: 20px;
   cursor: pointer;
 }
-.treeContainer[data-v-7c97192c] .el-tree__empty-block {
+.treeContainer[data-v-acaf6e87] .el-tree__empty-block {
   background-color: rgb(0, 0, 0);
 }
-.treeContainer[data-v-7c97192c] .el-tree-node__content {
+.treeContainer[data-v-acaf6e87] .el-tree-node__content {
   background-color: rgb(0, 0, 0);
 }
-[data-v-7c97192c] .el-button {
+[data-v-acaf6e87] .el-button {
   --el-button-text-color: #f0f0f0;
   --el-button-bg-color: rgba(60, 60, 80, 0.8);
   --el-button-border-color: rgba(80, 80, 100, 0.5);