deeptwins-engine-3d 0.1.43 → 0.1.44

package/dist/esm/graphicLayer/BaseSource.d.ts

@@ -15,7 +15,7 @@ export default class BaseSource {
     remove(): void;
     setData(data: any): this | undefined;
     _toDestroy(): void;
-    static analysisSourceType(data: any): "other" | "wkt" | "sourceId" | "sourceInstance" | "geoJson";
+    static analysisSourceType(data: any): "wkt" | "sourceId" | "sourceInstance" | "geoJson" | "other";
     static wktToGeoJon(wkt: string): any;
     static geoJsonToGeoCartesian3Array(geoJson: any): any[];
     static handleFeaturePoint(feature: any): any;

package/dist/esm/index.js

@@ -21,6 +21,7 @@ import Drawer from "./drawer/index";
 import "./global.css";
 import BarrierLayer from "./lowAltitude/BarrierLayer";
 import FlightPlanning from "./lowAltitude/FlightPlanning";
+// import FlightRiskEvaluation from './lowAltitude/FlightRiskEvaluation';
 import GridDraw from "./lowAltitude/GridDraw";
 import PoiLayer from "./lowAltitude/PoiLayer";
 import VisitLayer from "./lowAltitude/VisitLayer";
@@ -57,11 +58,11 @@ DEEP_TWINS_BASE_URL && (window.CESIUM_BASE_URL = DEEP_TWINS_BASE_URL);
 // 全局加载css
 loadCss(Cesium.buildModuleUrl('Widgets/widgets.css'));
 // 打印版本信息
-console.log('DeepTwinsEngine3D Version:', "0.1.43");
+console.log('DeepTwinsEngine3D Version:', "0.1.44");
 export var DeepTwinsEngine3D = /*#__PURE__*/_createClass(function DeepTwinsEngine3D() {
   _classCallCheck(this, DeepTwinsEngine3D);
 });
-_defineProperty(DeepTwinsEngine3D, "Version", "0.1.43");
+_defineProperty(DeepTwinsEngine3D, "Version", "0.1.44");
 _defineProperty(DeepTwinsEngine3D, "Map", Map);
 _defineProperty(DeepTwinsEngine3D, "GroundSkyBox", GroundSkyBox);
 _defineProperty(DeepTwinsEngine3D, "RasterLayer", RasterLayer);

package/dist/esm/lowAltitude/FlightPlanning.js

@@ -15,6 +15,7 @@ import * as Cesium from 'deeptwins-cesium';
 import { merge } from 'lodash';
 import { DEFAULT_FLIGHT_PLANNING_OPTIONS } from "../constant";
 import { ShapeSection } from "../tool/common";
+import fetch from "../tool/fetch";
 import * as utils from "../tool/utils";
 import GridDraw from "./GridDraw";
 var FlightPlanning = /*#__PURE__*/function () {
@@ -57,46 +58,30 @@ var FlightPlanning = /*#__PURE__*/function () {
     key: "createPlan",
     value: function () {
       var _createPlan = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(value) {
-        var payload, response, result, normalized, hasPoints;
+        var payload, _yield$fetch$post, result, normalized, hasPoints;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               payload = this._buildPayload(value);
               _context.next = 3;
-              return fetch(this.options.API_URL, {
-                method: 'POST',
-                headers: {
-                  'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(payload)
-              });
+              return fetch.post(this.options.API_URL, payload);
             case 3:
-              response = _context.sent;
-              if (response.ok) {
-                _context.next = 7;
-                break;
-              }
-              utils.error("\u63A5\u53E3\u8BF7\u6C42\u5931\u8D25\uFF0CHTTP ".concat(response.status));
-              return _context.abrupt("return");
-            case 7:
-              _context.next = 9;
-              return response.json();
-            case 9:
-              result = _context.sent;
+              _yield$fetch$post = _context.sent;
+              result = _yield$fetch$post.data;
               if (!(result.code !== 0)) {
-                _context.next = 13;
+                _context.next = 8;
                 break;
               }
               utils.error(result.message || '规划接口返回失败');
               return _context.abrupt("return");
-            case 13:
+            case 8:
               if (result.data) {
-                _context.next = 16;
+                _context.next = 11;
                 break;
               }
               utils.error('规划结果为空');
               return _context.abrupt("return");
-            case 16:
+            case 11:
               normalized = this._normalizeRouteData(result.data);
               if (this.options.isDraw) {
                 hasPoints = normalized && Array.isArray(normalized.points) && normalized.points.length > 0;
@@ -111,7 +96,7 @@ var FlightPlanning = /*#__PURE__*/function () {
                 }
               }
               return _context.abrupt("return", normalized);
-            case 19:
+            case 14:
             case "end":
               return _context.stop();
           }

package/dist/esm/lowAltitude/FlightRiskEvaluation.js

@@ -0,0 +1,383 @@
+// import { flatten, getCoords } from '@turf/turf';
+// import Cesium from 'deeptwins-cesium';
+// import { merge } from 'lodash';
+// import { DEFAULT_GRID_VT_OPTIONS } from '../constant';
+// import { MapContext } from '../map/Map';
+// import { ShapeSection, translateSource } from '../tool/common';
+// import fetch from '../tool/fetch';
+// import * as utils from '../tool/utils';
+//
+// const API_HOST = 'https://els-yunjing.amap.com';
+// const API_KEY = 'd1dc38f19b7bfc453e870a80be359cd5';
+// // 接口定义 - 明确各接口职责
+// const POINT_EVALUATION_URL = `${API_HOST}/data/risk/evaluation/point?key=${API_KEY}`; // 风险点评估接口 - 用于创建风险点标记
+// const SEGMENT_EVALUATION_URL = `${API_HOST}/data/risk/evaluation/segment?key=${API_KEY}`; // 航段评估接口 - 用于管道颜色和绘制
+// const ROUTE_EVALUATION_URL = `${API_HOST}/data/risk/evaluation/route?key=${API_KEY}`; // 航线评估接口 - 用于右侧面板数据
+// const GRID_RENDER_URL = `${API_HOST}/data/grid/render?key=${API_KEY}`; // 网格渲染接口 - 用于航迹点网格
+//
+// const TYPE_COLOR_MAP = {
+//   START: '#00ff00',
+//   END: '#ff0000',
+// }; // 点位颜色
+// const TYPE_LABEL_MAP = {
+//   START: '起点',
+//   END: '终点',
+// }; // 点位名称
+//
+// // 航线风险评估
+// class FlightRiskEvaluation {
+//   private readonly _mapContext: MapContext;
+//   public isDestroyed: boolean = false;
+//   public options: any = {};
+//   // 路线数据
+//   public routeSource: any = null;
+//   // 路线点位
+//   public routePointsLayer: any = null;
+//   // 路线点位文字
+//   public routePointsLabelLayer: any = null;
+//   // 规划管道
+//   public routePipelineLayer: any = null;
+//
+//   constructor(map: any, options: any = {}) {
+//     this._mapContext = map._mapContext;
+//     this.options = merge(DEFAULT_GRID_VT_OPTIONS(), options);
+//   }
+//
+//   // 是否能进行操作
+//   private _canOperate() {
+//     if (this.isDestroyed) {
+//       utils.error('SubmergenceAnalysis实例已销毁');
+//       return false;
+//     }
+//     return true;
+//   }
+//
+//   public getMap() {
+//     return this._mapContext && this._mapContext.getMap();
+//   }
+//
+//   // 开始评估
+//   public async start(
+//     geoJson: any = {
+//       type: 'Feature',
+//       geometry: {
+//         type: 'LineString',
+//         coordinates: [
+//           [114.269292, 22.692453, 95.75],
+//           [114.26916666666668, 22.693055555555556, 95.75],
+//           [114.27083333333334, 22.69472222222222, 95.75],
+//           [114.2713888888889, 22.69527777777778, 118.73],
+//           [114.27861111111112, 22.7025, 118.73],
+//           [114.28861111111111, 22.7025, 126.39],
+//           [114.28972222222222, 22.703611111111112, 118.73],
+//           [114.29583333333333, 22.703611111111112, 118.73],
+//           [114.302994, 22.707242, 80],
+//           [114.292009, 22.72269, 80],
+//           [114.27916666666667, 22.733055555555556, 80.43],
+//           [114.27665, 22.73299, 80],
+//         ],
+//       },
+//     },
+//   ) {
+//     if (!this._canOperate()) return;
+//     const translatedSource = translateSource(geoJson);
+//     this.routeSource = flatten(translatedSource);
+//     const points: any[] = [];
+//     this.routeSource.features.forEach((feature: any) => {
+//       const coords = getCoords(feature);
+//       points.push(
+//         ...coords.map((t: any) => ({ lng: t[0], lat: t[1], alt: t[2] || 0 })),
+//       );
+//     });
+//
+//     const [
+//       { data: pointEvaluationData },
+//       { data: segmentEvaluationData },
+//       { data: routeEvaluationData },
+//     ] = await Promise.all([
+//       fetch.post(POINT_EVALUATION_URL, { points }),
+//       fetch.post(SEGMENT_EVALUATION_URL, { points }),
+//       fetch.post(ROUTE_EVALUATION_URL, { points }),
+//     ]);
+//     this._createRoute();
+//     console.log(
+//       pointEvaluationData,
+//       segmentEvaluationData,
+//       routeEvaluationData,
+//     );
+//   }
+//
+//   // 创建航线（起点、终点、基础管道）
+//   private _createRoute() {
+//     if (!this._canOperate) return;
+//     this._clearRoute();
+//     const pointGeoJson: any = {
+//       type: 'FeatureCollection',
+//       features: [],
+//     };
+//     this.routeSource.features.forEach((feature: any, index: number) => {
+//       if (!index) {
+//         pointGeoJson.features.push({
+//           ...feature,
+//           properties: {
+//             ...feature.properties,
+//             text: TYPE_LABEL_MAP.START,
+//             color: TYPE_COLOR_MAP.START,
+//           },
+//         });
+//       }
+//       if (index === this.routeSource.features.length - 1) {
+//         pointGeoJson.features.push({
+//           ...feature,
+//           properties: {
+//             ...feature.properties,
+//             text: TYPE_LABEL_MAP.END,
+//             color: TYPE_COLOR_MAP.END,
+//           },
+//         });
+//       }
+//     });
+//     // 路线点位
+//     this.routePointsLayer = this.getMap().addGraphicLayer(pointGeoJson, {
+//       type: 'pointP',
+//       style: {
+//         pixelSize: 20,
+//         color: (p: any) => p.color,
+//         outlineColor: '#ffffff',
+//         outlineWidth: 3,
+//         disableDepthTestDistance: Number.POSITIVE_INFINITY,
+//       },
+//     });
+//     // 路线点位标签
+//     this.routePointsLabelLayer = this.getMap().addGraphicLayer(pointGeoJson, {
+//       type: 'labelP',
+//       style: {
+//         text: (p: any) => p.text,
+//         font: '16px "Microsoft YaHei", Arial, sans-serif',
+//         fillColor: '#ffffff',
+//         showBackground: true,
+//         backgroundColor: 'rgba(0,0,0,0.55)',
+//         pixelOffset: [0, -30],
+//         verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+//         disableDepthTestDistance: Number.POSITIVE_INFINITY,
+//       },
+//     });
+//     // 路线管道
+//     this.routePipelineLayer = this.getMap().addGraphicLayer(this.routeSource, {
+//       type: 'polylineVolumeP',
+//       style: {
+//         // 圆截面
+//         shapePositions: ShapeSection.circleSection(6, 48),
+//         cornerType: Cesium.CornerType.ROUNDED,
+//         color: 'rgba(0,255,255,0.85)',
+//       },
+//     });
+//   }
+//
+//   // 销毁航线
+//   private _clearRoute() {
+//     if (!this._canOperate) return;
+//     this.routePipelineLayer && this.routePipelineLayer.remove();
+//     this.routePipelineLayer = null;
+//     this.routePointsLayer && this.routePointsLayer.remove();
+//     this.routePointsLayer = null;
+//     this.routePointsLabelLayer && this.routePointsLabelLayer.remove();
+//     this.routePointsLabelLayer = null;
+//   }
+//
+//   // 获取航段颜色使用segment接口返回的数据）
+//   getSegmentColorFromEvaluation(evaluation: any) {
+//     const confidence = evaluation?.confidence;
+//     if (confidence == null) return Cesium.Color.fromCssColorString('#06b6d4');
+//     if (confidence < 0) return Cesium.Color.fromCssColorString('#ef4444');
+//     if (confidence < 0.5) return Cesium.Color.fromCssColorString('#f59e0b');
+//     return Cesium.Color.fromCssColorString('#10b981');
+//   }
+//
+//   // 创建航线实体（起点、终点、基础管道）
+//   // 注意：管道颜色由updateSegmentColors根据segment接口数据更新
+//   // 风险点标记由point接口数据创建
+//   private _createRouteEntity() {
+//     selectedSegmentEntity = null;
+//
+//     if (route.length < 2) return;
+//
+//     // 风险点聚合函数：将相近位置的风险点聚合在一起
+//     // threshold: 聚合距离阈值（度），默认0.0005度（约55米）
+//     function clusterRiskPoints(riskPointsData, threshold = 0.0005) {
+//       const clusters = [];
+//       const processed = new Set();
+//
+//       riskPointsData.forEach((point, idx) => {
+//         if (processed.has(idx)) return;
+//
+//         const cluster = {
+//           points: [point],
+//           indices: [idx],
+//           centerLng: point.lng,
+//           centerLat: point.lat,
+//           centerAlt: point.alt,
+//           totalRiskCount: point.riskCount,
+//           maxRiskCount: point.riskCount,
+//           evaluations: [point.evaluation],
+//         };
+//
+//         // 查找相近的风险点
+//         riskPointsData.forEach((otherPoint, otherIdx) => {
+//           if (idx === otherIdx || processed.has(otherIdx)) return;
+//
+//           const distance = Math.sqrt(
+//             Math.pow(point.lng - otherPoint.lng, 2) +
+//               Math.pow(point.lat - otherPoint.lat, 2),
+//           );
+//
+//           if (distance < threshold) {
+//             cluster.points.push(otherPoint);
+//             cluster.indices.push(otherIdx);
+//             processed.add(otherIdx);
+//
+//             // 更新聚合中心（使用平均值）
+//             cluster.centerLng =
+//               cluster.points.reduce((sum, p) => sum + p.lng, 0) /
+//               cluster.points.length;
+//             cluster.centerLat =
+//               cluster.points.reduce((sum, p) => sum + p.lat, 0) /
+//               cluster.points.length;
+//             cluster.centerAlt =
+//               cluster.points.reduce((sum, p) => sum + p.alt, 0) /
+//               cluster.points.length;
+//
+//             // 累加风险数量
+//             cluster.totalRiskCount += otherPoint.riskCount;
+//             if (otherPoint.riskCount > cluster.maxRiskCount) {
+//               cluster.maxRiskCount = otherPoint.riskCount;
+//             }
+//             cluster.evaluations.push(otherPoint.evaluation);
+//           }
+//         });
+//
+//         processed.add(idx);
+//         clusters.push(cluster);
+//       });
+//
+//       return clusters;
+//     }
+//
+//     // 创建风险点标记（使用point接口数据）
+//     // 先聚合密集的风险点，然后显示聚合后的点
+//     riskPoints = [];
+//     const allRiskPoints = [];
+//
+//     if (pointEvaluationData?.length) {
+//       // 第一步：收集所有风险点
+//       pointEvaluationData.forEach((item, idx) => {
+//         if (item.riskCount > 0) {
+//           const { lon, lat, alt, code } = item.grid;
+//           const pointAlt = alt;
+//           const evaluation = item.evaluation;
+//
+//           const riskPoint = {
+//             index: idx,
+//             lng: lon,
+//             lat: lat,
+//             alt: pointAlt, // 网格高度（来自grid.alt）
+//             riskCount: item.riskCount,
+//             evaluation: evaluation,
+//             gridCode: code, // 网格code
+//           };
+//           allRiskPoints.push(riskPoint);
+//         }
+//       });
+//
+//       // 第二步：聚合风险点
+//       const clusters = clusterRiskPoints(allRiskPoints, 0.005); // 约55米聚合距离
+//
+//       // 第三步：渲染聚合后的风险点
+//       clusters.forEach((cluster, clusterIdx) => {
+//         const isClustered = cluster.points.length > 1;
+//         const displayHeight = cluster.centerAlt + 20; // 管道上方20米
+//
+//         const clusterData = {
+//           index: clusterIdx,
+//           lng: cluster.centerLng,
+//           lat: cluster.centerLat,
+//           alt: cluster.centerAlt,
+//           displayHeight: displayHeight,
+//           riskCount: cluster.totalRiskCount,
+//           pointCount: cluster.points.length, // 聚合的点数量
+//           isClustered: isClustered,
+//           points: cluster.points, // 包含的所有风险点
+//           evaluation: cluster.evaluations[0], // 使用第一个点的评估数据
+//         };
+//
+//         riskPoints.push(clusterData);
+//
+//         // 创建聚合风险点标记
+//         // 如果是聚合点，使用更大的标记和不同的颜色
+//         const markerSize = isClustered ? 50 : 40;
+//         const markerColor = isClustered ? '#ef4444' : '#f59e0b'; // 聚合点用红色，单点用黄色
+//         const markerText = isClustered ? cluster.points.length : '!';
+//
+//         viewer.entities.add({
+//           name: `风险点-${clusterIdx}${isClustered ? '-聚合' : ''}`,
+//           position: CesiumNS.Cartesian3.fromDegrees(
+//             cluster.centerLng,
+//             cluster.centerLat,
+//             displayHeight,
+//           ),
+//           billboard: {
+//             image:
+//               'data:image/svg+xml;base64,' +
+//               btoa(
+//                 '<svg width="' +
+//                   markerSize +
+//                   '" height="' +
+//                   markerSize +
+//                   '" xmlns="http://www.w3.org/2000/svg">' +
+//                   '<circle cx="' +
+//                   markerSize / 2 +
+//                   '" cy="' +
+//                   markerSize / 2 +
+//                   '" r="' +
+//                   (markerSize / 2 - 2) +
+//                   '" fill="' +
+//                   markerColor +
+//                   '" stroke="#fff" stroke-width="2"/>' +
+//                   '<text x="' +
+//                   markerSize / 2 +
+//                   '" y="' +
+//                   (markerSize / 2 + 6) +
+//                   '" font-size="' +
+//                   (isClustered ? '14' : '16') +
+//                   '" font-weight="bold" fill="#fff" text-anchor="middle">' +
+//                   markerText +
+//                   '</text>' +
+//                   '</svg>',
+//               ),
+//             scale: 1.0,
+//             disableDepthTestDistance: Number.POSITIVE_INFINITY,
+//           },
+//           label: {
+//             text: `${cluster.totalRiskCount}`,
+//             font: '12px Arial',
+//             fillColor: CesiumNS.Color.WHITE,
+//             showBackground: true,
+//             backgroundColor: isClustered
+//               ? CesiumNS.Color.RED
+//               : CesiumNS.Color.ORANGE,
+//             pixelOffset: new CesiumNS.Cartesian2(
+//               markerSize / 2,
+//               -markerSize / 2 - 10,
+//             ),
+//             verticalOrigin: CesiumNS.VerticalOrigin.TOP,
+//             horizontalOrigin: CesiumNS.HorizontalOrigin.LEFT,
+//             disableDepthTestDistance: Number.POSITIVE_INFINITY,
+//           },
+//           riskPointData: clusterData,
+//         });
+//       });
+//     }
+//   }
+// }
+//
+// export default FlightRiskEvaluation;

package/dist/esm/tool/common.d.ts

@@ -36,3 +36,4 @@ export declare class ClampToGround {
         features: any[];
     }>;
 }
+export declare function translateSource(source: any): any;

package/dist/esm/tool/common.js

@@ -390,4 +390,16 @@ export var ClampToGround = /*#__PURE__*/function () {
     }()
   }]);
   return ClampToGround;
-}();
+}();
+
+// 数据类型转换
+export function translateSource(source) {
+  var sourceType = BaseSource.analysisSourceType(source);
+  if (sourceType === 'geoJson') {
+    return source;
+  } else if (sourceType === 'wkt') {
+    return BaseSource.wktToGeoJon(source);
+  } else {
+    throw new Error('数据格式错误');
+  }
+}

package/dist/esm/tool/fetch.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Fetch 请求配置选项
+ */
+export interface FetchUrlOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    headers?: Record<string, string>;
+    body?: any;
+    timeout?: number;
+    params?: Record<string, any>;
+    responseType?: 'json' | 'text' | 'blob' | 'arrayBuffer';
+    credentials?: RequestCredentials;
+}
+/**
+ * Fetch 请求响应
+ */
+export interface FetchUrlResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Headers;
+}
+/**
+ * 封装的 fetch 请求函数
+ * @param url 请求地址
+ * @param options 请求配置
+ * @returns Promise<FetchUrlResponse>
+ */
+export declare function fetchUrl<T = any>(url: string, options?: FetchUrlOptions): Promise<FetchUrlResponse<T>>;
+/**
+ * GET 请求快捷方法
+ */
+export declare function get<T = any>(url: string, params?: Record<string, any>, options?: Omit<FetchUrlOptions, 'method' | 'body' | 'params'>): Promise<FetchUrlResponse<T>>;
+/**
+ * POST 请求快捷方法
+ */
+export declare function post<T = any>(url: string, body?: any, options?: Omit<FetchUrlOptions, 'method' | 'body'>): Promise<FetchUrlResponse<T>>;
+/**
+ * PUT 请求快捷方法
+ */
+export declare function put<T = any>(url: string, body?: any, options?: Omit<FetchUrlOptions, 'method' | 'body'>): Promise<FetchUrlResponse<T>>;
+/**
+ * DELETE 请求快捷方法
+ */
+export declare function del<T = any>(url: string, body?: any, options?: Omit<FetchUrlOptions, 'method' | 'body'>): Promise<FetchUrlResponse<T>>;
+declare const _default: {
+    get: typeof get;
+    post: typeof post;
+    put: typeof put;
+    delete: typeof del;
+};
+export default _default;