deeptwins-engine-3d 0.1.32 → 0.1.34

package/dist/esm/measure/utils.d.ts

@@ -1,23 +1,117 @@
-import type { Cartesian2, Cartesian3, HeightReference, Viewer } from 'deeptwins-cesium';
-export type PickResult = {
-    cartesian: Cartesian3;
-    CartesianModel: Cartesian3;
-    cartesianTerrain: Cartesian3;
-    windowCoordinates: Cartesian2;
-    altitudeMode: HeightReference;
-};
-export declare function pickCartesian3(viewer: Viewer, position: Cartesian2): Cartesian3 | undefined;
+import { Polygon } from '@turf/helpers';
+import { Cartesian2, Cartesian3, type Viewer } from 'deeptwins-cesium';
+/**
+ * 从地图中拾取指定屏幕坐标对应的三维笛卡尔坐标
+ * @param map - Cesium Viewer实例，用于访问地图场景和相机
+ * @param position - 屏幕坐标位置，使用Cartesian2表示
+ * @returns 返回拾取到的三维笛卡尔坐标，如果未拾取到则返回undefined
+ */
+export declare function pickCartesian3(map: Viewer, position: Cartesian2): Cartesian3 | undefined;
+/**
+ * 计算给定点集合的边界范围
+ * @param points - 二维笛卡尔坐标点数组
+ * @returns 返回边界范围数组，格式为[left, top, right, bottom]
+ */
 export declare function getBounds(points: Cartesian2[]): number[];
 /**
  * 格式化显示长度
  * @param length 单位米
- * @param unit 目标单位
  */
-export declare function formatLength(length: number, unitedLength: number): string;
+export declare function formatLength(length: number): string;
 /**
  * 格式化显示面积
  * @param area 单位米
- * @param unit 目标单位
  */
-export declare function formatArea(area: number, unitedArea: number): string;
-export declare function mean(array: number[]): number;
+export declare function formatArea(area: number): string;
+/**
+ * 计算两点之间的距离
+ * @param {Cartesian3} start 点位1
+ * @param {Cartesian3} end 点位2
+ * @returns {number} 距离/米
+ */
+export declare function getDistance(start: Cartesian3, end: Cartesian3): number;
+/**
+ * 计算线段的表面距离
+ * @param map 地图实例
+ * @param startPoint 线段起点的屏幕坐标
+ * @param endPoint 线段终点的屏幕坐标
+ * @param splitNum 分段数
+ * @returns 表面距离
+ */
+export declare function calculateSurfaceDistance(map: Viewer, startPoint: Cartesian2, endPoint: Cartesian2, splitNum?: number): number;
+/**
+ * 计算给定三维坐标点围成区域的面积
+ * @param map 地图对象，用于坐标转换
+ * @param positions 三维笛卡尔坐标点数组
+ * @returns 返回计算得到的区域面积
+ */
+export declare function getArea(map: any, positions: Cartesian3[]): number;
+/**
+ * 将笛卡尔坐标转换为经纬度坐标
+ * @param map - 地图对象，用于获取场景和椭球体信息
+ * @param positions - 笛卡尔坐标数组
+ * @returns 经纬度坐标数组，每个元素为[经度, 纬度]格式
+ */
+export declare function cartesian2LngLat(map: any, positions: Cartesian3[]): number[][];
+/**
+ * 获取线段上距起点一定距离出的线上点坐标（屏幕坐标）
+ * @param startPosition 线段起点（屏幕坐标）
+ * @param endPosition 线段终点（屏幕坐标）
+ * @param interval 距起点距离
+ * @returns -结果坐标（屏幕坐标）
+ */
+export declare function findWindowPositionByPixelInterval(startPosition: Cartesian2, endPosition: Cartesian2, interval: number): Cartesian2;
+/**
+ * 计算细分后的，每一小段的笛卡尔坐标距离（也就是大地坐标系距离）
+ * @param map 地图实例
+ * @param startPoint 每一段线段起点
+ * @param endPoint 每一段线段终点
+ * @returns 表面距离
+ */
+export declare function calculateDetailSurfaceLength(map: Viewer, startPoint: Cartesian2, endPoint: Cartesian2): number;
+/**
+ * 计算给定区域的表面积
+ *
+ * @param map - Viewer对象，用于地图操作
+ * @param positions - Cartesian2坐标数组，定义区域边界
+ * @param splitNum - 分割数量，默认为50，用于控制计算精度
+ * @returns 返回计算得到的表面积数值
+ */
+export declare function calculateSurfaceArea(map: Viewer, positions: Cartesian2[], splitNum?: number): number;
+/**
+ * 将Cartesian2坐标数组转换为turf.js的Polygon几何对象
+ * @param positions - Cartesian2坐标点数组，用于构建多边形
+ * @returns 返回对应的Polygon几何对象
+ */
+export declare function Cartesian2turfPolygon(positions: Cartesian2[]): Polygon;
+/**
+ * 计算两个多边形的交集区域
+ * @param poly1 - 第一个多边形
+ * @param poly2 - 第二个多边形
+ * @returns 交集区域的顶点坐标数组，如果没有交集则返回空数组
+ */
+export declare function getIntersect(poly1: Polygon, poly2: Polygon): Cartesian2[];
+/**
+ * 将Turf.js的Polygon对象转换为Cesium的Cartesian2数组
+ *
+ * @param polygon - Turf.js的Polygon对象，包含经纬度坐标信息
+ * @returns 返回一个Cartesian2数组，每个元素对应polygon外环坐标点的二维笛卡尔坐标
+ */
+export declare function turfPolygon2CartesianArr(polygon: Polygon): Cartesian2[];
+/**
+ * 计算地图上指定位置围成区域的表面积
+ * @param map - 地图查看器实例
+ * @param positions - 屏幕坐标点数组
+ * @returns 返回世界坐标系中围成区域的表面积
+ */
+export declare function calculateDetailSurfaceArea(map: Viewer, positions: Cartesian2[]): number;
+/**
+ * 计算一组世界坐标点所围成区域的面积。
+ *
+ * 该函数通过将三维笛卡尔坐标转换为地理坐标（经纬度），然后计算相邻点之间的大地测量距离，
+ * 并利用平面近似方法估算这些点在地球表面围成的多边形区域的面积。
+ *
+ * @param positions - 表示多边形顶点的世界坐标数组，每个元素是 Cartesian3 类型。
+ * @returns 返回由输入点围成区域的近似面积（单位：平方米）。
+ */
+export declare function getWorldPositionsArea(positions: Cartesian3[]): number;

package/dist/esm/measure/utils.js

@@ -4,13 +4,30 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-export function pickCartesian3(viewer, position) {
-  // We use `viewer.scene.pickPosition` here instead of `viewer.camera.pickEllipsoid` so that
-  // we get the correct point when mousing over terrain.
-  var ray = viewer.camera.getPickRay(position);
-  if (ray) return viewer.scene.globe.pick(ray, viewer.scene);
+import area from '@turf/area';
+import { polygon } from '@turf/helpers';
+import intersect from '@turf/intersect';
+import { randomPoint } from '@turf/random';
+import voronoi from '@turf/voronoi';
+import { Math as CMath, Cartesian2, Cartesian3, Cartographic, EllipsoidGeodesic } from 'deeptwins-cesium';
+
+/**
+ * 从地图中拾取指定屏幕坐标对应的三维笛卡尔坐标
+ * @param map - Cesium Viewer实例，用于访问地图场景和相机
+ * @param position - 屏幕坐标位置，使用Cartesian2表示
+ * @returns 返回拾取到的三维笛卡尔坐标，如果未拾取到则返回undefined
+ */
+export function pickCartesian3(map, position) {
+  var ray = map.camera.getPickRay(position);
+  if (ray) return map.scene.globe.pick(ray, map.scene);
   return undefined;
 }
+
+/**
+ * 计算给定点集合的边界范围
+ * @param points - 二维笛卡尔坐标点数组
+ * @returns 返回边界范围数组，格式为[left, top, right, bottom]
+ */
 export function getBounds(points) {
   var left = Math.min.apply(Math, _toConsumableArray(points.map(function (item) {
     return item.x;
@@ -24,35 +41,260 @@ export function getBounds(points) {
   var bottom = Math.min.apply(Math, _toConsumableArray(points.map(function (item) {
     return item.y;
   })));
-  var bounds = [left, top, right, bottom];
-  return bounds;
+  return [left, top, right, bottom];
 }
 
 /**
  * 格式化显示长度
  * @param length 单位米
- * @param unit 目标单位
  */
-export function formatLength(length, unitedLength) {
+export function formatLength(length) {
   if (length < 1000) {
-    return length + '米';
+    return length.toFixed(2) + '米';
   }
-  return unitedLength + '千米';
+  return (length / 1000).toFixed(2) + '千米';
 }
 
 /**
  * 格式化显示面积
  * @param area 单位米
- * @param unit 目标单位
  */
-export function formatArea(area, unitedArea) {
-  if (area < 1000000) {
-    return area + '平方米';
+export function formatArea(area) {
+  if (area < 10000) {
+    return area.toFixed(2) + '平方米';
+  }
+  return (area / 1000000).toFixed(2) + '平方千米';
+}
+
+/**
+ * 计算两点之间的距离
+ * @param {Cartesian3} start 点位1
+ * @param {Cartesian3} end 点位2
+ * @returns {number} 距离/米
+ */
+export function getDistance(start, end) {
+  return Cartesian3.distance(start, end);
+}
+
+/**
+ * 计算线段的表面距离
+ * @param map 地图实例
+ * @param startPoint 线段起点的屏幕坐标
+ * @param endPoint 线段终点的屏幕坐标
+ * @param splitNum 分段数
+ * @returns 表面距离
+ */
+export function calculateSurfaceDistance(map, startPoint, endPoint) {
+  var splitNum = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 20;
+  var resultDistance = 0;
+  var sampleWindowPoints = [startPoint];
+  var interval = Math.sqrt(Math.pow(endPoint.x - startPoint.x, 2) + (endPoint.y - startPoint.y, 2)) / splitNum;
+  for (var ii = 1; ii <= splitNum; ii += 1) {
+    var tempPositon = findWindowPositionByPixelInterval(startPoint, endPoint, ii * interval);
+    sampleWindowPoints.push(tempPositon);
+  }
+  sampleWindowPoints.push(endPoint);
+  for (var jj = 0; jj < sampleWindowPoints.length - 1; jj += 1) {
+    resultDistance += calculateDetailSurfaceLength(map, sampleWindowPoints[jj + 1], sampleWindowPoints[jj]);
+  }
+  return resultDistance;
+}
+
+/**
+ * 计算给定三维坐标点围成区域的面积
+ * @param map 地图对象，用于坐标转换
+ * @param positions 三维笛卡尔坐标点数组
+ * @returns 返回计算得到的区域面积
+ */
+export function getArea(map, positions) {
+  var lngLats = cartesian2LngLat(map, positions);
+  var pg = polygon([[].concat(_toConsumableArray(lngLats), [lngLats[0]])]);
+  return area(pg);
+}
+
+/**
+ * 将笛卡尔坐标转换为经纬度坐标
+ * @param map - 地图对象，用于获取场景和椭球体信息
+ * @param positions - 笛卡尔坐标数组
+ * @returns 经纬度坐标数组，每个元素为[经度, 纬度]格式
+ */
+export function cartesian2LngLat(map, positions) {
+  return positions.map(function (pos) {
+    var cartographic = map.scene.globe.ellipsoid.cartesianToCartographic(pos);
+    var lon = +CMath.toDegrees(cartographic.longitude);
+    var lat = +CMath.toDegrees(cartographic.latitude);
+    return [lon, lat];
+  });
+}
+
+/**
+ * 获取线段上距起点一定距离出的线上点坐标（屏幕坐标）
+ * @param startPosition 线段起点（屏幕坐标）
+ * @param endPosition 线段终点（屏幕坐标）
+ * @param interval 距起点距离
+ * @returns -结果坐标（屏幕坐标）
+ */
+export function findWindowPositionByPixelInterval(startPosition, endPosition, interval) {
+  var result = new Cartesian2(0, 0);
+  var length = Math.sqrt(Math.pow(endPosition.x - startPosition.x, 2) + Math.pow(endPosition.y - startPosition.y, 2));
+  if (length < interval) {
+    return result;
+  } else {
+    var x = interval / length * (endPosition.x - startPosition.x) + startPosition.x;
+    //alert(interval/length)
+    var y = interval / length * (endPosition.y - startPosition.y) + startPosition.y;
+    result.x = x;
+    result.y = y;
+  }
+  return result;
+}
+
+/**
+ * 计算细分后的，每一小段的笛卡尔坐标距离（也就是大地坐标系距离）
+ * @param map 地图实例
+ * @param startPoint 每一段线段起点
+ * @param endPoint 每一段线段终点
+ * @returns 表面距离
+ */
+export function calculateDetailSurfaceLength(map, startPoint, endPoint) {
+  var innerS = 0;
+  var surfaceStartCartesian3 = pickCartesian3(map, startPoint);
+  var surfaceEndCartesian3 = pickCartesian3(map, endPoint);
+  if (surfaceStartCartesian3 && surfaceEndCartesian3) {
+    var cartographicStart = Cartographic.fromCartesian(surfaceStartCartesian3);
+    var cartographicEnd = Cartographic.fromCartesian(surfaceEndCartesian3);
+    var geoD = new EllipsoidGeodesic();
+    geoD.setEndPoints(cartographicStart, cartographicEnd);
+    innerS = geoD.surfaceDistance;
+    innerS = Math.sqrt(Math.pow(innerS, 2) + Math.pow(cartographicStart.height - cartographicEnd.height, 2));
+  }
+  return innerS;
+}
+
+/**
+ * 计算给定区域的表面积
+ *
+ * @param map - Viewer对象，用于地图操作
+ * @param positions - Cartesian2坐标数组，定义区域边界
+ * @param splitNum - 分割数量，默认为50，用于控制计算精度
+ * @returns 返回计算得到的表面积数值
+ */
+export function calculateSurfaceArea(map, positions) {
+  var splitNum = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 20;
+  var result = 0;
+  // 获取边界范围
+  var bounds = getBounds(positions);
+  // 生成随机点
+  var points = randomPoint(splitNum, {
+    bbox: [bounds[0], bounds[1], bounds[2], bounds[3]]
+  });
+  // 转换为主多边形
+  var mainPoly = Cartesian2turfPolygon(positions);
+  // 生成Voronoi多边形
+  var voronoiPolygons = voronoi(points, {
+    bbox: [bounds[0], bounds[1], bounds[2], bounds[3]]
+  });
+  // 遍历Voronoi多边形计算相交区域的表面积
+  voronoiPolygons.features.forEach(function (element) {
+    var intersectPoints = getIntersect(mainPoly, element.geometry);
+    result += calculateDetailSurfaceArea(map, intersectPoints);
+  });
+  return result;
+}
+
+/**
+ * 将Cartesian2坐标数组转换为turf.js的Polygon几何对象
+ * @param positions - Cartesian2坐标点数组，用于构建多边形
+ * @returns 返回对应的Polygon几何对象
+ */
+export function Cartesian2turfPolygon(positions) {
+  var coordinates = [[]];
+  positions.forEach(function (element) {
+    coordinates[0].push([element.x, element.y]);
+  });
+  coordinates[0].push([positions[0].x, positions[0].y]);
+  var pg = polygon(coordinates);
+  return pg.geometry;
+}
+
+/**
+ * 计算两个多边形的交集区域
+ * @param poly1 - 第一个多边形
+ * @param poly2 - 第二个多边形
+ * @returns 交集区域的顶点坐标数组，如果没有交集则返回空数组
+ */
+export function getIntersect(poly1, poly2) {
+  var intersection = intersect(poly1, poly2);
+  if ((intersection === null || intersection === void 0 ? void 0 : intersection.geometry) !== undefined) {
+    return turfPolygon2CartesianArr(intersection === null || intersection === void 0 ? void 0 : intersection.geometry);
+  } else {
+    return [];
   }
-  return unitedArea + '平方千米';
 }
-export function mean(array) {
-  return array.reduce(function (accumulator, currentValue) {
-    return accumulator + currentValue;
-  }, 0) / array.length;
+
+/**
+ * 将Turf.js的Polygon对象转换为Cesium的Cartesian2数组
+ *
+ * @param polygon - Turf.js的Polygon对象，包含经纬度坐标信息
+ * @returns 返回一个Cartesian2数组，每个元素对应polygon外环坐标点的二维笛卡尔坐标
+ */
+export function turfPolygon2CartesianArr(polygon) {
+  return polygon.coordinates[0].map(function (item) {
+    return new Cartesian2(item[0], item[1]);
+  });
+}
+
+/**
+ * 计算地图上指定位置围成区域的表面积
+ * @param map - 地图查看器实例
+ * @param positions - 屏幕坐标点数组
+ * @returns 返回世界坐标系中围成区域的表面积
+ */
+export function calculateDetailSurfaceArea(map, positions) {
+  var worldPositions = [];
+  positions.forEach(function (element) {
+    var pickResult = pickCartesian3(map, element);
+    if (pickResult) worldPositions.push(pickResult);
+  });
+  return getWorldPositionsArea(worldPositions);
+}
+
+/**
+ * 计算一组世界坐标点所围成区域的面积。
+ *
+ * 该函数通过将三维笛卡尔坐标转换为地理坐标（经纬度），然后计算相邻点之间的大地测量距离，
+ * 并利用平面近似方法估算这些点在地球表面围成的多边形区域的面积。
+ *
+ * @param positions - 表示多边形顶点的世界坐标数组，每个元素是 Cartesian3 类型。
+ * @returns 返回由输入点围成区域的近似面积（单位：平方米）。
+ */
+export function getWorldPositionsArea(positions) {
+  var x = [0];
+  var y = [0];
+  var geodesic = new EllipsoidGeodesic();
+  var radiansPerDegree = Math.PI / 180.0; //角度转化为弧度(rad)
+  //数组x,y分别按顺序存储各点的横、纵坐标值
+  for (var i = 0; i < positions.length - 1; i += 1) {
+    var p1 = positions[i];
+    var p2 = positions[i + 1];
+    var point1cartographic = Cartographic.fromCartesian(p1);
+    var point2cartographic = Cartographic.fromCartesian(p2);
+    geodesic.setEndPoints(point1cartographic, point2cartographic);
+    var s = Math.sqrt(Math.pow(geodesic.surfaceDistance, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
+    var lat1 = point2cartographic.latitude * radiansPerDegree;
+    var lon1 = point2cartographic.longitude * radiansPerDegree;
+    var lat2 = point1cartographic.latitude * radiansPerDegree;
+    var lon2 = point1cartographic.longitude * radiansPerDegree;
+    var angle = -Math.atan2(Math.sin(lon1 - lon2) * Math.cos(lat2), Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon1 - lon2));
+    if (angle < 0) {
+      angle += Math.PI * 2.0;
+    }
+    y.push(Math.sin(angle) * s + y[i]);
+    x.push(Math.cos(angle) * s + x[i]);
+  }
+  var sum = 0;
+  for (var _i = 0; _i < x.length - 1; _i += 1) {
+    sum += x[_i] * y[_i + 1] - x[_i + 1] * y[_i];
+  }
+  return Math.abs(sum + x[x.length - 1] * y[0] - x[0] * y[y.length - 1]) / 2;
 }

package/dist/esm/plot/create/CreateAssemble.d.ts

@@ -0,0 +1,2 @@
+declare const CreateAssemble: (viewer: any, handler: any, resultList: any[], options: any, callback?: ((assemble: any) => void) | undefined) => void;
+export default CreateAssemble;

package/dist/esm/plot/create/CreateAssemble.js

@@ -0,0 +1,63 @@
+/**
+ * 集结地标绘功能
+ */
+import * as Cesium from 'deeptwins-cesium';
+import { getCatesian3FromPX } from "../utils/Coordinate";
+import { computeAssemblePoints, newSessionid } from "../utils/PlotCommon";
+import CreateRemindertip from "../utils/ReminderTip";
+var CreateAssemble = function CreateAssemble(viewer, handler, resultList, options, callback) {
+  var id = options.id || newSessionid();
+  var color = options.color ? Cesium.Color.fromCssColorString(options.color) : Cesium.Color.BLUE.withAlpha(0.4);
+  var onground = options.onground || true;
+  if (viewer.entities.getById(id)) throw new Error('the id parameter is an unique value');
+  window.toolTip = '左键点击开始绘制';
+  var anchorpoints = [];
+  var assemblePolygon = undefined;
+  // 左键点击事件
+  handler.setInputAction(function (event) {
+    window.toolTip = '左键双击键结束绘制';
+    var pos = getCatesian3FromPX(viewer, event.position);
+    if (!pos || Cesium.defined(assemblePolygon)) return;
+    anchorpoints.push(pos);
+    var dynamicPositions = new Cesium.CallbackProperty(function () {
+      var points = computeAssemblePoints(anchorpoints);
+      return new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArrayHeights(points));
+    }, false);
+    assemblePolygon = viewer.entities.add({
+      name: 'AssemblePolygon',
+      id: id,
+      polygon: {
+        hierarchy: dynamicPositions,
+        material: color,
+        outline: true,
+        outlineColor: Cesium.Color.GREEN,
+        heightReference: onground ? Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.HeightReference.NONE
+      }
+    });
+    assemblePolygon.GeoType = 'AssemblePolygon'; //记录对象的类型，用户后续编辑等操作
+    assemblePolygon.Editable = true; //代表当前对象可编辑,false状态下不可编辑
+  }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+  // 鼠标移动事件
+  handler.setInputAction(function (movement) {
+    //console.log('鼠标移动事件监测：------创建集结地------');
+    var endPos = movement.endPosition;
+    CreateRemindertip(window.toolTip, endPos, true);
+    var endCartesian = getCatesian3FromPX(viewer, endPos);
+    if (!endCartesian || !Cesium.defined(assemblePolygon)) return;
+    if (anchorpoints.length === 2) {
+      anchorpoints.pop();
+    }
+    anchorpoints.push(endCartesian);
+  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+  // 左键双击事件
+  handler.setInputAction(function () {
+    assemblePolygon.polygon.hierarchy = new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArrayHeights(computeAssemblePoints(anchorpoints)));
+    assemblePolygon.PottingPoint = Cesium.clone(anchorpoints, true);
+    assemblePolygon.EditingPoint = Cesium.clone(anchorpoints, true);
+    resultList.push(assemblePolygon);
+    handler.destroy();
+    CreateRemindertip(window.toolTip, null, false);
+    if (typeof callback == 'function') callback(assemblePolygon);
+  }, Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
+};
+export default CreateAssemble;

package/dist/esm/plot/create/CreateAttackArrow.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 创建攻击箭头
+ */
+declare const CreateAttackArrow: (viewer: any, handler: any, resultList: any[], options: any, callback?: ((attackArrow: any) => void) | undefined) => void;
+export default CreateAttackArrow;

package/dist/esm/plot/create/CreateAttackArrow.js

@@ -0,0 +1,75 @@
+/**
+ * 创建攻击箭头
+ */
+
+import * as Cesium from 'deeptwins-cesium';
+import { getCatesian3FromPX } from "../utils/Coordinate";
+import { getAttackArrowPoints, newSessionid } from "../utils/PlotCommon";
+import CreateRemindertip from "../utils/ReminderTip";
+var CreateAttackArrow = function CreateAttackArrow(viewer, handler, resultList, options, callback) {
+  var id = options.id || newSessionid();
+  if (viewer.entities.getById(id)) throw new Error('the id parameter is an unique value');
+  var color = options.color ? Cesium.Color.fromCssColorString(options.color) : Cesium.Color.RED;
+  var onground = options.onground || true;
+  var anchorpoints = [];
+  var attackArrow = undefined;
+  window.toolTip = '左键点击开始绘制';
+  //左键点击事件
+  handler.setInputAction(function (event) {
+    window.toolTip = '左键添加点，右键撤销，左键双击结束绘制';
+    var cartesian = getCatesian3FromPX(viewer, event.position);
+    if (!cartesian) return;
+    anchorpoints.push(cartesian);
+  }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+  //鼠标移动事件
+  handler.setInputAction(function (move) {
+    //console.log('鼠标移动事件监测：------创建攻击箭头------');
+    var endPos = move.endPosition;
+    CreateRemindertip(window.toolTip, endPos, true);
+    var cartesian = getCatesian3FromPX(viewer, endPos);
+    if (!cartesian) return;
+    if (anchorpoints.length >= 2) {
+      var dynamicPositions = new Cesium.CallbackProperty(function () {
+        var pointlist = getAttackArrowPoints(anchorpoints);
+        return new Cesium.PolygonHierarchy(pointlist);
+      }, false);
+      if (!Cesium.defined(attackArrow)) {
+        anchorpoints.push(cartesian);
+        attackArrow = viewer.entities.add({
+          id: id,
+          name: 'AttackArrow',
+          polygon: new Cesium.PolygonGraphics({
+            hierarchy: dynamicPositions,
+            show: true,
+            fill: true,
+            material: color,
+            heightReference: onground ? Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.HeightReference.NONE
+          })
+        });
+        attackArrow.GeoType = 'AttackArrow'; //记录对象的类型，用户后续编辑等操作
+        attackArrow.Editable = true; //代表当前对象可编辑,false状态下不可编辑
+      } else {
+        anchorpoints.pop();
+        anchorpoints.push(cartesian);
+      }
+    }
+  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+  //左键双击事件
+  handler.setInputAction(function (event) {
+    anchorpoints.pop();
+    anchorpoints.pop(); //因为是双击结束，所以要pop两次，一次是move的结果，一次是单击结果
+    attackArrow.PottingPoint = Cesium.clone(anchorpoints, true); //记录对象的节点数据，用户后续编辑等操作
+    attackArrow.EditingPoint = Cesium.clone(anchorpoints, true); //记录复杂对象的编辑的节点数据，用户后续编辑等操作
+    var pointlist = getAttackArrowPoints(anchorpoints);
+    attackArrow.polygon.hierarchy = new Cesium.PolygonHierarchy(pointlist);
+    resultList.push(attackArrow);
+    handler.destroy();
+    CreateRemindertip(window.toolTip, event.position, false);
+    if (typeof callback == 'function') callback(attackArrow);
+  }, Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
+  // 右键摁下事件
+  handler.setInputAction(function () {
+    anchorpoints.pop();
+  }, Cesium.ScreenSpaceEventType.RIGHT_DOWN);
+};
+export default CreateAttackArrow;

package/dist/esm/plot/create/CreateBillboard.d.ts

@@ -0,0 +1,2 @@
+declare const CreateBillboard: (viewer: any, handler: any, resultList: any[], options: any, callback?: ((billboard: any) => void) | undefined) => void;
+export default CreateBillboard;

package/dist/esm/plot/create/CreateBillboard.js

@@ -0,0 +1,47 @@
+/**
+ * 广告牌标绘功能
+ */
+import * as Cesium from 'deeptwins-cesium';
+import * as utils from "../../tool/utils";
+import { getCatesian3FromPX } from "../utils/Coordinate";
+import { newSessionid } from "../utils/PlotCommon";
+import CreateRemindertip from "../utils/ReminderTip";
+var CreateBillboard = function CreateBillboard(viewer, handler, resultList, options, callback) {
+  var id = options.id || newSessionid();
+  var onground = options.onground || true;
+  var image = options.image || utils.getDeepTwinsFile('Image/f_point.png');
+  if (viewer.entities.getById(id)) throw new Error('the id parameter is an unique value');
+  window.toolTip = '左键点击选择点位';
+  handler.setInputAction(function (event) {
+    var pixPos = event.position;
+    var cartesian = getCatesian3FromPX(viewer, pixPos);
+    var billboard = viewer.entities.add({
+      id: id,
+      name: 'Billboard',
+      position: cartesian,
+      billboard: {
+        image: image,
+        scale: 1,
+        horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+        verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+        scaleByDistance: new Cesium.NearFarScalar(1.5e1, 1.5, 1.5e5, 0.4),
+        heightReference: onground ? Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.HeightReference.NONE,
+        disableDepthTestDistance: 15000 //解决遮挡显示一半的问题
+      }
+    });
+    billboard.GeoType = 'Billboard'; //记录对象的类型，用户后续编辑等操作
+    billboard.PottingPoint = cartesian; //记录对象的节点数据，用户后续编辑等操作
+    billboard.EditingPoint = cartesian; //记录对象的节点数据，用户后续编辑等操作
+    billboard.Editable = true; //代表当前对象可编辑,false状态下不可编辑
+    resultList.push(billboard);
+    handler.destroy();
+    CreateRemindertip(window.toolTip, event.position, false);
+    if (callback && typeof callback == 'function') callback(billboard);
+  }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+  handler.setInputAction(function (movement) {
+    //console.log('鼠标移动事件监测：------创建点------');
+    var endPos = movement.endPosition;
+    CreateRemindertip(window.toolTip, endPos, true);
+  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+};
+export default CreateBillboard;

package/dist/esm/plot/create/CreateBow.d.ts

@@ -0,0 +1,2 @@
+declare const CreateBow: (viewer: any, handler: any, resultList: any[], options: any, callback?: ((bow: any) => void) | undefined) => void;
+export default CreateBow;