/**
 * 创建者：王成
 * 操作系统：MAC
 * 创建日期：2022年11月10日
 * 描述：该类主要是为了创建三维地图通用绘制工具类
 */

/* 引入Cesium */
// import * as Cesium from 'Cesium';

/* 扩展 Cesium.GroundPrimitive 给其添加objId属性*/

/**
 * 设置关联的图元
 * @ignore
 * @param {JSON} geometry 图元信息
 * @param {Array<Cesium.Cartesian3>} geometry.cPoints 世界坐标系坐标集合
 * @param {Array<JSON>} geometry.gPoints 经纬度坐标集合  
 */
Cesium.Primitive.prototype.setUseGeometry = function(geometry) {
	this._useGeometry = geometry;
}

/**
 * 获取设置的图元信息
 * @ignore
 */
Cesium.Primitive.prototype.getUseGeometry = function() {
	return this._useGeometry;
}

/**
 * 绘图工具
 */
class SketchViewModel {
	/**
	 * 默认初始化
	 * @param {Object} viewer 三维场景
	 * @param {JSON} [options] 配置项
	 * @param {Boolean} [options.isDrawPoint] 是否绘制参考点
	 * @param {Boolean} [options.isRetainDrawPoint] 绘制完成，是否保留绘制参考点
	 * @param {SketchViewModel.SketchIconType} options.iconType 点图标类型 
	 */
	constructor(viewer, options) {
		/* 赋值三维视图 */
		this._viewer = viewer;
		/* 初始化 */
		this._init(options);
	}

	/**
	 * @ignore
	 * @param {JSON} options [配置项]
	 * @param {Boolean} options.isDrawPoint 是否绘标记点
	 * @param {Boolean} options.isRetainDrawPoint 绘制完成，是否保留绘制点
	 * @param {SketchViewModel.SketchIconType} options.iconType 点图标类型 
	 */
	_init(options) {
		/* 开启地形检测 必须开启 否则会导致获取地形高度时异常 导致鼠标移动时位置哆嗦 */
		this._viewer.scene.globe.depthTestAgainstTerrain = true;
		/* 取消地图右键点击事件 */
		this._viewer.cesiumWidget.screenSpaceEventHandler.removeInputAction(Cesium.ScreenSpaceEventType
			.LEFT_DOUBLE_CLICK);
		/* 实体数据集 */
		this._entities = this._viewer.entities;
		this._pointEntitys = [];
		/* 草图工具绘制的点图片 */
		this._sketchPointImage = undefined;
		this._iconNormal =
			'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABwAAAAcEAYAAAAinQPXAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAB2FJREFUWMO9mHtQlNcZxn/nW65GxHtEqTEajUxVoLYRSIyipHG4qG0lajtxVIRFubgqXuOI28ZE7FAvCLKLSNKxg/FSIzdvqNE62kaRitqpYMxovBGigo4I4n6nfwjsCrsLrtjnn53vnPe87/Oc9/2+854VdBhCd6ZP6dMHlAXO/lOngrzMLz/8EEQ0ASNGANNY2aOHxYIdfHr3LuBCwPnzQIKcf/AgiJ8pQV99BfmvR4+orHxZVsLxpZFT0qd07gyP7zqrej3IInF47lwQkTLV3d1xv3KXWPT4MYhLzMzIgHpn10+Sk+Gw74w+jx79HwSGnzUYhg4FED4FBcBq/jtokOOC2oSb0FZUgHpKVoeHQ9GtGM/y8lcgMLxf5juDBwNDlOWnTgGvUdWz5wsQ7c179fUWzz9y0tX1BdZPILeqCpTtil9QEOT9c876K1faWqS07XeMzJFuboCXkpaX1w5hqxl14QJIKYRWCzLV5OXtDQXbon3c3c2/TeMoYvncucAgPrl40Y7fA0zv1QtMydKwb58FL7toRwbDYo3/0utB3OD8qlX2hIkLqalwO0b9+fLlUHJOG9vQ0P4EjfyFIdPZGfqsURampIBIlxsWLLBtL/NltF4PhUIrVq92QGDIeEOmpye4pYju164Bq6n29LTiopy8tDTIL48pSExsDq/Oj9is/eAD4CRbli1DMEFUBAYCewnUaJD8jr2lpQjpJ7M2bBBi0+L47Tt2mP2G5xhNaWnAHrLj461tKF1rasA0rW5b//6w/0rigQcPWhrZKVFXP8TkybaFyb3kXbkCbiO6fpyU1Dwq58vNG3U6BJvEiYMHEcwQW8aNA3pT7O4OaPmTiwuCnlwcNQrEDRGYmytloilj5vr1Zv+mNXVhSUnmOFYEVnt6gtM9t+8mTbKlwo5AoWdySIjteWUcIwwG2LX7o6lPnkiZULTlj/7+wEThm5oKbCBeCOANUisqkNRxLCEBSSzrYmOB3jw6c8Yi3kL5K51OyvkZGXUTJz7LSH09CIPwMBpt85CHhMf48Q4IJFPofHzsbMAAJfjIEQtXC9TZWi0wkEuKAmjEyspKpNN2pyVBQULZaIjbvXmzUDb6xF0zGJCqv+no6NGAK5fLyiz8JssVcXEWgQLUsZZxWmGbrLTN057Agfh7eNiefhpRb7h922LgOzFp2DDzxnJXrsvLE0rqOW3sTz+12h4lLfRZhuQybuXmWmQkgPzhwy0o1jlV37ljh+e3/L1LF0cEXqX04UPb0075rlovLwtBHuqZ5845T5Z37UqbEAPkzOfsUvlHXZ35saFnQ4++fe04eIfftv64tEfgdvkXeweprFIvBQaaebJH+f3x4xbPvsRPnixlQlHGtDFjWq2Wuqj0yz4+QKk4FxNjMVXD2998Y0FRKEsCAuzwzBKv2eZpR6DspxQcPWpnvrNYoNNBZOTOnRoN0ilJMzYjA3ibsKoqoIxezs6gLJbpxcVSTbyePurwYSkT76VPKSgAWQslJcAmenTrBszgP7W1wBlRmZICY2SydHIC8ZCvdTo7Ak+ri44dcySDNDTs2mVufluhThoGD4bHp6or4uOb3zWJnoqwMGAVLnfuACHscHJCiFRmhISA0BMcFob52PDC/8EDkLfkR5GRQmycN8/t8mXw8O73WVwctnvdJ3SqrQXNSJeY3bttaWhHJxMxzDh97VqQAwheutR2IC6pm/z8oOBm7LcVFVJNKNo0oUsXhBKmGR0VBfI0vkFBINzExxoNEKP+ePYsktefFmVnC2Vjvm5SZSVEpGUNefNNUH8ti8rKQCziaOfOVuL2563PP4eCjJhxK1a8hMCJJ7NTPDxAXWIaefEi0J2r/ftbMfyryDhxAkZ2u1EaHAx6oReq2rb/JiTLZKkoUHLf2//YMWCGnPf++1YM7zHw+nVQ1mlKhg2DvPeiltr+GLaj2W524Kd6zZ4NhGOQ0ophI6GSkr4Gq61VGyjx7vdZQoIdYY1xVZ06RKttS1gTHLkPLjVmGo3AJZToaCsGjSWrPFBKfH3bvta0uyR3ySlGIxS4a7trte1l244MtoRpT93XSUk0l0oruFDbqROYUtQ9X3xhLr2WaBpX4+WnOTl2hHkw9eZN0Li5dLP6Dehogc1dexslK/7MynffhbNDvZXnWq9GNJWyiKC69TlphvobtWbOHNgnZonq6hdl+xL/yTQhbKUxeOtWEP9melSUFYMWJSv/IAtNprZLUu4Rf9u6FQpdo49bfRXaBQcy2BL1p+XURYtAZrLwhx+sGDSWrDpc3ZeVBbJMPt22zY6wRj/1oep08zXMUXRABpsQFmqcHhICYiLlhw4BBWiFA/5FOXmhoc8u0Pv3vyyrDshgEwqLYnKLi4FO5OfkvPh66UdudnZHCXsFAptQ96XMW7jQTsm2xAF23roFlD6NXLy4o9m8AoHFR7SxNTWgjGOsVovtxqBxXAzEbc4cKCycN+/+/Y7n88oRvjarcNYsCDtprP/+ewjvZ1xz9SpERBp3zpz5qqP/D5zQE33tptaiAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDIyLTA0LTA5VDE2OjQyOjI5KzA4OjAwjRBbGwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAyMi0wNC0wOVQxNjo0MjoyOSswODowMPxN46cAAABKdEVYdHN2ZzpiYXNlLXVyaQBmaWxlOi8vL2hvbWUvYWRtaW4vaWNvbi1mb250L3RtcC9pY29uXzJhcHo1b3VpcnV4L2Rpbmd3ZWkuc3ZncY9vkgAAAABJRU5ErkJggg==';
		this._iconBlue =
			'data:image/png;base64,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';
		this._iconGreen =
			'data:image/png;base64,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';
		this._iconViolet =
			'data:image/png;base64,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';
		/* 创建的临时实体的名称 该名称通用 为了后期统一删除 */
		this._sketchEntityName = 'sketchEntity';
		/* 存储的点集合 */
		this._sketchTempPoints = []; //临时点集合 主要为了存储鼠标移动事件临时存储点
		this._sketchPoints = []; //正式点集合 主要为了绘制正式图形
		this._sketchOutputPoints = []; //输出点集合 主要为了存储输出的经纬度坐标点集合
		/* 创建的临时线 主要为了响应鼠标移动事件 */
		this._sketchTempPolyline = undefined;
		/* 创建的正式线 */
		this._sketchPolyline = undefined;
		/* 创建的临时面 主要为了响应鼠标移动事件 */
		this._sketchTempPolygon = undefined;
		/* 创建正式面 */
		this._sketchPolygon = undefined;
		/* 高度临时高度线 主要为了相应鼠标事件 */
		this._sketchTempAltituePolyline = undefined;
		/* 高度正式高度线 */
		this._sketchAltitudePolyline = undefined;
		/* 高度起始点的初始高度 */
		this._sketchAltitudeInitHeight = 0;
		/* 创建空间临时线 主要为了相应鼠标事件 */
		this._sketchTempSpatialPolyline = undefined;
		/* 创建空间正式线 */
		this._sketchSpatialPolyline = undefined;
		/* 创建临时圆 主要为了相应鼠标事件 */
		this._sketchTempCircle = undefined;
		/* 创建正式圆 */
		this._sketchCircle = undefined;
		/* 创建临时矩形 主要为了相应鼠标事件 */
		this._sketchTempRectangle = undefined;
		/* 创建正式矩形 */
		this._sketchRectangle = undefined;
		/* 创建临时三角形高度线 主要为了响应高度事件*/
		this._sketchTempTriangleAltitudePolyline = undefined;
		/* 创建三角形正式高度线 */
		this._sketchTriangleAltituePolyline = undefined;
		/* 创建临时空间三角形 主要是为了响应鼠标移动事件 */
		this._sketchTempSpatialTriangle = undefined;
		/* 创建正式空间三角形 */
		this._sketchSpatialTriangle = undefined;
		/* 点线标注 */
		this._lineLabel = undefined;
		this._polygonLabel = undefined;

		options = options || {};

		/* 配置是否绘制点 */
		if (options.isDrawPoint) {
			this._isDrawPoint = options.isDrawPoint;
		} else {
			this._isDrawPoint = false;
		}
		/* 配置绘制完成是否保留绘制点 */
		if (options.isRetainDrawPoint) {
			this._isRetainDrawPoint = options.isRetainDrawPoint;
		} else {
			this._isRetainDrawPoint = false;
		}

		/* 通用参数集合 */
		this._param = {
			moveLineWidth: 2, //移动线的宽度
			lineWidth: 2, //正是线的宽度
			moveAltitudeLineWidth: 2, //移动高度线宽度
			altitudeLineWidth: 2, //正式高度线的宽度
			spatialLineWidth: 2, //空间线的宽度
			moveEllipseColor: [0, 255, 0, 0.5], //移动绘制圆的颜色
			moveEllipseOutline: true, //移动绘制圆是否有边界线
			moveEllipseOutlineColor: [255, 0, 0, 0.5], //移动绘制圆边界线的颜色
			moveEllipseOutlineWidth: 1, //移动绘制圆边界线的宽度
			spatialLineWidth: 2, //空间线宽度
			ellipseColor: [0, 0, 255, 0.5], //正式圆的颜色
			ellipseOutline: true, //移动绘制圆是否有边界线
			ellipseOutlineColor: [255, 0, 0, 0.5], //移动绘制圆边界线的颜色
			ellipseOutlineWidth: 1, //移动绘制圆边界线的宽度
		}
		/* 各种材质及相关样式的初始化 */
		this._setMoveLineStyle(undefined);
		this._setLineStyle(undefined);
		this._setMovePolygonStyle(undefined);
		this._setPolygonStyle(undefined);
		this._setMoveAltitudeLineStyle(undefined);
		this._setAltitudeLineStyle(undefined);
		this._setMoveEllipseStyle(undefined);
		this._setEllipseStyle(undefined);
		this._setSpatialLineStyle(undefined);
		/* 设置点符号类型 */
		if (options && options.iconType) {
			switch (options.iconType) {
				case SketchViewModel.SketchIconType.Normal:
					this._sketchPointImage = this._iconNormal;
					break;
				case SketchViewModel.SketchIconType.Blue:
					this._sketchPointImage = this._iconBlue;
					break;
				case SketchViewModel.SketchIconType.Green:
					this._sketchPointImage = this._iconGreen;
					break;
				case SketchViewModel.SketchIconType.Violet:
					this._sketchPointImage = this._iconViolet;
					break;
				default:
					this._sketchPointImage = this._iconNormal;
					break;
			}
		} else {
			this._sketchPointImage = this._iconNormal;
		}
	}

	/**
	 * 弧度转度
	 * @ignore
	 * @param {Number} arc 弧度
	 * @return {Number} 角度
	 */
	_arcToDegree(arc) {
		return arc / Math.PI * 180;
	}

	/**
	 * 普通颜色值转换为Cesium颜色
	 * @ignore
	 * @param {int} red 红色[0~255]
	 * @param {int} green 绿色[0~255]
	 * @param {int} blue 蓝色[0~255]
	 * @param {int} alpha 透明度[0~1]
	 * @return {Cesium.Color} Cesium格式的颜色
	 */
	_toColor(red, green, blue, alpha) {
		let normalColor = new Cesium.Color(0, 0, 0, 1.0);
		if (typeof red != 'number') return normalColor;
		if (typeof green != 'number') return normalColor;
		if (typeof blue != 'number') return normalColor;
		if (typeof alpha != 'number') return normalColor;
		if (red < 0 || red > 255 || green < 0 || green > 255 || blue < 0 || blue > 255 || alpha < 0 || alpha > 1)
			return normalColor;
		return new Cesium.Color(red / 255.0, green / 255.0, blue / 255.0, alpha);
	}

	/**
	 * 通过颜色数组转换为Cesium颜色
	 * @ignore
	 * @param {Array} array 颜色数组
	 * @return {Cesium.Color} Cesium格式的颜色
	 */
	_toColorFromArray(array) {
		if (!array || array.length === undefined || array.length === 0) return new Cesium.Color(255 / 255.0, 255 /
			255.0, 255 / 255.0, 1.0);
		let r = 255,
			g = 255,
			b = 255,
			a = 1.0;
		if (array.length === 1) {
			r = parseInt(array[0]);
		} else if (array.length === 2) {
			r = parseInt(array[0]);
			g = parseInt(array[1]);
		} else if (array.length === 3) {
			r = parseInt(array[0]);
			g = parseInt(array[1]);
			b = parseInt(array[2]);
		} else if (array.length >= 4) {
			r = parseInt(array[0]);
			g = parseInt(array[1]);
			b = parseInt(array[2]);
			a = parseFloat(array[3]);
		}
		return new Cesium.Color(r / 255.0, g / 255.0, b / 255.0, a);
	}

	/**
	 * 刷新场景 刷新一帧
	 * @ignore
	 */
	_updateScene() {
		this._viewer.scene.requestRender();
	}

	/**
	 * 根据地形或实景或模型检测当前屏幕位置的世界坐标系位置
	 * @ignore
	 * @param {JSON} screenPosition 屏幕坐标
	 * @param {Number} screenPosition.x 屏幕坐标x
	 * @param {Number} screenPosition.y 屏幕坐标y
	 * @return {JSON} 位置信息{x,y,z}
	 */
	_getScreenClickPosition(screenPosition) {
		let resCartesian = undefined;
		let ray = this._viewer.scene.camera.getPickRay(screenPosition);
		let position = this._viewer.scene.globe.pick(ray, this._viewer.scene);
		let cartographic = Cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
		if (Cesium.defined(position)) {
			resCartesian = {
				x: position.x,
				y: position.y,
				z: position.z,
			}
		}
		return resCartesian;
	}

	/**
	 * 根据地形或实景或模型检测当前屏幕位置的经纬度及高度
	 * @ignore
	 * @param {JSON} screenPoint 屏幕坐标
	 * @param {Number} screenPoint.x 屏幕坐标x
	 * @param {Number} screenPoint.y 屏幕坐标y
	 * @return {JSON} 位置信息{lng,lat,height}
	 */
	_getScreenClickPositionAndHeight(screenPoint) {
		var lng = undefined,
			lat = undefined,
			height = undefined;
		/* 从相机位置到 windowPosition 处的像素创建射线在世界坐标系中 */
		var ray = this._viewer.scene.camera.getPickRay(screenPoint);
		/* 找到射线与渲染的地球表面之间的交点 */
		var position = this._viewer.scene.globe.pick(ray, this._viewer.scene);
		/* 获取地理位置的制图表达 */
		var cartographic = Cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
		/* 查询屏幕位置的要素 */
		var feature = this._viewer.scene.pick(screenPoint);
		if (feature == undefined) {
			lng = this._arcToDegree(cartographic.longitude);
			lat = this._arcToDegree(cartographic.latitude);
			height = cartographic.height;
		} else {
			var cartesian = this._viewer.scene.pickPosition(screenPoint);
			if (Cesium.defined(cartesian)) {
				var cartographic = Cesium.Cartographic.fromCartesian(cartesian);
				lng = this._arcToDegree(cartographic.longitude);
				lat = this._arcToDegree(cartographic.latitude);
				height = cartographic.height;
			}
		}
		/* 返回结果 */
		return {
			lng: lng,
			lat: lat,
			height: height,
		}
	}

	/**
	 * 屏幕位置转换为经纬度位置及空间位置
	 * @ignore
	 * @param {Cesium.Cartesian2} screenPosition 屏幕位置
	 * @return {JSON} 经纬度位置及空间位置
	 */
	_transfromFromScreenPoint(screenPosition) {
		/* 根据屏幕位置获取经度、纬度和高度信息 */
		let location = this._getScreenClickPositionAndHeight(screenPosition);
		/* 经纬度位置转换为三维坐标 */
		var cartesian = Cesium.Cartesian3.fromDegrees(location.lng, location.lat, location
			.height);
		/* 返回 */
		return {
			gLocation: location,
			sLocation: cartesian,
		}
	}

	/**
	 * 根据Entity的名称批量删除Entity
	 * @ignore
	 * @param {String} entityName 实体名称
	 */
	_removeEntityByName(entityName) {
		/* 获取实体集合 */
		var entities = this._entities;
		/* 如果不存在实体集合或集合中没有数据 则返回 */
		if (!entities || !entities.values) return;
		var delEntitys = [];
		/* 循环获取当前集合中的所有实体 */
		for (var i = 0; i < entities.values.length; i++) {
			if (entities.values[i].name == entityName) {
				delEntitys.push(entities.values[i]);
			}
		}
		/* 删除符合条件的所有实体 */
		for (var i = 0; i < delEntitys.length; i++) {
			entities.remove(delEntitys[i]);
		}
		/* 更新场景 */
		this._updateScene();
	}

	/**
	 * 移除实体
	 * @ignore
	 * @param {Object} objEntity 实体
	 */
	_removeEntityByObject(objEntity) {
		if (!Cesium.defined(objEntity)) return;
		this._entities.remove(objEntity);
	}

	/**
	 * 绘制点
	 * @ignore
	 * @param {Cesium.Cartesian3} coord 坐标
	 * @param {Number} coord.x 空间坐标x
	 * @param {Number} coord.y 空间坐标y
	 * @param {Number} coord.z 空间坐标z
	 * @param {String} label [点上面显示的文字标注]
	 */
	_createPoint(coord, label) {
		let _self = this;
		/* 创建点实体 */
		let entity = new Cesium.Entity({
			name: _self._sketchEntityName + "_Point",
			position: coord,
			billboard: {
				image: _self._sketchPointImage,
				horizontalOrigin: Cesium.HorizontalOrigin.center,
				verticalOrigin: Cesium.VerticalOrigin.bottom,
				scale: 0.5,
				pixelOffset: new Cesium.Cartesian2(0, -11),
				disableDepthTestDistance: Number.POSITIVE_INFINITY,
			}
		});
		/* 判断是否需要绘制文字 */
		if (label) {
			entity.label = {
				text: label,
				font: '12px sans-serif',
				fillColor: this._toColor(255, 255, 255, 1.0),
				outlineColor: this._toColor(0, 154, 94, 1.0),
				style: Cesium.LabelStyle.FILL_AND_OUTLINE,
				outlineWidth: 1.0,
				verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
				pixelOffset: new Cesium.Cartesian2(0, -28),
				showBackground: true,
				backgroundColor: this._toColor(0, 0, 0, 0.6),
				disableDepthTestDistance: Number.POSITIVE_INFINITY,
			}
		}
		/* 加入集合中 */
		this._entities.add(entity);
		/* 加入点集合数组中 */
		this._pointEntitys.push(entity);
		this._updateScene();
	}

	/**
	 * 删除全部点
	 * @ignore
	 */
	_removePointEntitys() {
		/* 清除所有绘制的点实体 */
		this._removeEntityByName(this._sketchEntityName + "_Point");
		/* 清除用于临时存储的点实体集合 */
		this._pointEntitys = [];
	}

	/**
	 * 创建临时线
	 * @ignore
	 */
	_createTempPolyline() {
		let _self = this;
		/* 创建临时线 */
		if (!Cesium.defined(this._sketchTempPolyline)) {
			this._sketchTempPolyline = new Cesium.Entity({
				name: _self._sketchEntityName,
				polyline: {
					show: true,
					positions: new Cesium.CallbackProperty(function() {
						return _self._sketchTempPoints;
					}, false),
					material: _self._tempLineMaterial,
					width: _self._param.moveLineWidth,
					clampToGround: true, //开启贴地 如果有模型则贴模型
				}
			})
			this._entities.add(this._sketchTempPolyline);
			this._updateScene();
		}
	}

	/**
	 * 创建正式线
	 * @ignore
	 */
	_createPolyline() {
		let _self = this;
		if (!Cesium.defined(this._sketchPolyline)) {
			this._sketchPolyline = new Cesium.Entity({
				name: _self._sketchEntityName,
				polyline: {
					show: true,
					positions: _self._sketchPoints,
					material: _self._lineMaterial,
					width: _self._param.lineWidth,
					clampToGround: true, //开启贴地 如果有模型则贴模型
				}
			})
			this._entities.add(this._sketchPolyline);
			this._updateScene();
		}
	}

	/**
	 * 创建临时空间线
	 * @ignore
	 */
	_createTempSpatialPolyline() {
		let _self = this;
		if (!Cesium.defined(this._sketchTempSpatialPolyline)) {
			this._sketchTempSpatialPolyline = new Cesium.Entity({
				name: _self._sketchEntityName,
				polyline: {
					show: true,
					positions: new Cesium.CallbackProperty(function() {
						return _self._sketchTempPoints;
					}, false),
					material: _self._tempLineMaterial,
					width: _self._param.moveLineWidth,
					clampToGround: false, //由于是空间线禁止贴地或贴模型
				}
			})
			this._entities.add(this._sketchTempSpatialPolyline);
			this._updateScene();
		}
	}

	/**
	 * 创建正式空间线
	 * @ignore
	 */
	_createSpatialPolyline() {
		let _self = this;
		if (!Cesium.defined(this._sketchSpatialPolyline)) {
			this._sketchSpatialPolyline = new Cesium.Entity({
				name: _self._sketchEntityName,
				polyline: {
					show: true,
					positions: _self._sketchPoints,
					material: _self._spatialLineMaterial,
					width: _self._param.spatialLineWidth,
					clampToGround: false, //由于是空间线禁止贴地或贴模型
				}
			})
			this._entities.add(this._sketchSpatialPolyline);
			this._updateScene();
		}
	}

	/**
	 * 创建临时面
	 * @ignore
	 */
	_createTempPolygon() {
		let _self = this;
		if (!Cesium.defined(this._sketchTempPolygon)) {
			this._sketchTempPolygon = new Cesium.Entity({
				name: _self._sketchEntityName,
				polygon: {
					show: true,
					hierarchy: new Cesium.CallbackProperty(function() {
						return {
							positions: _self._sketchTempPoints,
						};
					}, false),
					material: _self._tempPolygonMaterial,
					classificationType: Cesium.ClassificationType.BOTH,
				}
			})
			this._entities.add(this._sketchTempPolygon);
			this._updateScene();
		}
	}

	/**
	 * 创建正式面
	 * @ignore
	 */
	_createPolygon() {
		let _self = this;
		if (!Cesium.defined(this._sketchPolygon)) {
			this._sketchPoints.push(this._sketchPoints[0]);
			this._sketchPolygon = new Cesium.Entity({
				name: _self._sketchEntityName,
				polygon: {
					show: true,
					hierarchy: {
						positions: _self._sketchPoints,
					},
					material: _self._polygonMaterial,
					classificationType: Cesium.ClassificationType.BOTH,
				},
				polyline: {
					show: true,
					positions: _self._sketchPoints,
					material: _self._lineMaterial,
					width: _self._param.lineWidth,
					clampToGround: true, //开启贴地 如果有模型则贴模型
				}
			})
			this._entities.add(this._sketchPolygon);
			this._updateScene();
		}
	}

	/**
	 * 创建正式拉伸体
	 * @ignore
	 * @param {JSON} options 配置项
	 */
	_createPolygonBody(options) {
		let _self = this;
		/* 体的高度 */
		let appendHeight = parseFloat(100);
		if (options && options.height && typeof options.height === 'number') appendHeight = parseFloat(options
			.height);
		/* 墙和体的颜色 */
		let wallColor = [255, 255, 0, 1.0];
		let polygonColor = [0, 0, 255, 0.65];
		if (options && options.color && this._checkColorAndAlpha(options.color)) polygonColor = this
			._checkColorAndAlpha(options.color);
		/* 创建体 */
		if (!Cesium.defined(this._sketchPolygon)) {
			/* 墙的片元着色器源码 */
			let shaderSource =
				'czm_material czm_getMaterial(czm_materialInput materialInput){\n' +
				'  czm_material material = czm_getDefaultMaterial(materialInput);\n' +
				'  vec2 st = materialInput.st;\n' +
				'  vec3 str = materialInput.str;\n' +
				// '  vec4 colorImage = texture2D(image, vec2(st.s, fract((st.t - speed * czm_frameNumber * 0.001))));\n' +
				// '  vec4 colorImage = texture2D(image, vec2(fract(st.s - speed * czm_frameNumber * 0.001), st.t));\n' +
				// '  vec4 colorImage = texture2D(image, vec2(fract((st.t - speed*czm_frameNumber*0.003)), st.t));\n' +
				// '  vec4 colorImage = texture2D(image,vec2(str.t,str.r));\n' +
				// '  material.alpha = colorImage.a * color.a;\n' +
				// '  material.diffuse = 1.2 * color.rgb;\n' +
				// '  float time = fract(czm_frameNumber * speed /1000.0);\n' +
				'  material.diffuse = color.rgb;\n' +
				// '  material.alpha = color.a * fract(time - st.s);\n' +
				'  material.alpha = color.a;\n' +
				'  return material;\n' +
				'}';

			/* 创建墙的材质 */
			let wallMaterial = new Cesium.Material({
				fabric: {
					type: 'wallMaterial',
					uniforms: {
						color: _self._toColorFromArray(wallColor),
						speed: 100,
					},
					source: shaderSource,
				}
			});
			/* 创建墙的外观*/
			let wallAppearance = new Cesium.MaterialAppearance({
				material: wallMaterial,
			});

			/* 创建体的外观 */
			let polygonAppearance = new Cesium.MaterialAppearance({
				material: new Cesium.Material({
					fabric: {
						type: 'Color',
						uniforms: {
							color: _self._toColorFromArray(polygonColor),
						}
					}
				}),
			});

			/* 设置墙的最小、最大高度 */
			let wallMinimumHeights = [];
			let wallMaximumHeights = [];
			for (let i = 0; i < _self._sketchOutputPoints.length; i++) {
				let height = parseFloat(_self._sketchOutputPoints[i].height);
				wallMinimumHeights.push(height);
				wallMaximumHeights.push(height + appendHeight);
			}
			/* 追加第一个点 */
			let height = parseFloat(_self._sketchOutputPoints[0].height);
			wallMinimumHeights.push(height);
			wallMaximumHeights.push(height + appendHeight);

			/* 创建临时数组 */
			let tempPoints = [];
			for (let i = 0; i < _self._sketchPoints.length; i++) {
				tempPoints.push(_self._sketchPoints[i]);
			}
			/* 追加第一个点 */
			tempPoints.push(_self._sketchPoints[0]);
			/* 创建墙几何图元 */
			let wllGeometry = new Cesium.WallGeometry({
				positions: tempPoints,
				maximumHeights: wallMaximumHeights,
				minimumHeights: wallMinimumHeights,
			})

			/* 创建区域体底部对象 */
			let polygonGeometry = new Cesium.PolygonGeometry({
				polygonHierarchy: new Cesium.PolygonHierarchy(tempPoints),
				perPositionHeight: true,
				extrudedHeight: Math.max.apply(null, wallMaximumHeights),
			})

			/* 创建面拉伸要素 */
			let polygonPrimitive = new Cesium.Primitive({
				geometryInstances: new Cesium.GeometryInstance({
					geometry: polygonGeometry,
				}),
				appearance: polygonAppearance,
				releaseGeometryInstances: false,
			});
			/* 追加属性 */
			polygonPrimitive.setUseGeometry({
				cPoints: _self._sketchPoints,
				gPoints: _self._sketchOutputPoints,
				height: appendHeight,
				color: polygonColor,
			})
			/* 添加要素 */
			this._viewer.scene.primitives.add(polygonPrimitive);

			/* 添加墙要素 */
			// this._viewer.scene.primitives.add(new Cesium.Primitive({
			// 	geometryInstances: new Cesium.GeometryInstance({
			// 		geometry: wllGeometry,
			// 	}),
			// 	appearance: wallAppearance,
			// }));
		}
	}

	/**
	 * 调用更新椭圆中心点位置信息
	 * @ignore
	 */
	_callUpdaeEllipseCenterPosition() {
		let _self = this;
		return function() {
			let point1cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[0]);
			let point2cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[1]);
			_self._sketchEllipseCenterPosition = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(point1cartographic.longitude), Cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);
			return _self._sketchEllipseCenterPosition;
		}
	}

	/**
	 * 调用更新高度线的点集合信息
	 * @ignore
	 */
	_callUpdateAltitudePolylinePositions() {
		let _self = this;
		return function() {
			_self._sketchAltitudePolylinePostions = [];
			_self._sketchAltitudePolylinePostions.push(_self._sketchTempPoints[0]);
			let point1cartographic = Cesium.Cartographic.fromCartesian(_self
				._sketchTempPoints[0]);
			let point2cartographic = Cesium.Cartographic.fromCartesian(_self
				._sketchTempPoints[1]);
			let point_temp = Cesium.Cartesian3.fromDegrees(Cesium.Math
				.toDegrees(
					point1cartographic
					.longitude), Cesium.Math.toDegrees(point1cartographic
					.latitude),
				point2cartographic.height);
			_self._sketchAltitudePolylinePostions.push(point_temp);
			return _self._sketchAltitudePolylinePostions;
		}
	}

	/**
	 * 椭圆-长短半轴大小变化回调
	 * @ignore
	 */
	_callUpdateEllipseMinorAxis() {
		let _self = this;
		return function() {
			let point1cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[0]);
			let point2cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[1]);
			/* 计算距离 */
			let geodesic = new Cesium.EllipsoidGeodesic();
			geodesic.setEndPoints(point1cartographic, point2cartographic);
			_self._sketchEllipseRadius = geodesic.surfaceDistance;
			if (_self._sketchEllipseRadius <= 0) _self._sketchEllipseRadius = 1;
			return _self._sketchEllipseRadius;
		}
	}

	/**
	 * 调用更新椭圆高度信息
	 * @ignore
	 */
	_callUpdateEllipseHeight() {
		let _self = this;
		return function() {
			let cartographic = Cesium.Cartographic.fromCartesian(_self
				._sketchTempPoints[0]);
			let cartographic1 = Cesium.Cartographic.fromCartesian(_self
				._sketchTempPoints[1]);
			let height_temp = cartographic1.height - cartographic.height;
			_self._sketchEllipseHeight = height_temp + _self._sketchAltitudeInitHeight;
			return _self._sketchEllipseHeight;
		}
	}

	/**
	 * 创建临时高度线
	 * @ignore
	 */
	_createTempAltitudePolyline() {
		let _self = this;
		if (!Cesium.defined(this._sketchTempAltituePolyline)) {
			this._sketchTempAltituePolyline = new Cesium.Entity({
				name: _self._sketchEntityName,
				position: new Cesium.CallbackProperty(_self._callUpdaeEllipseCenterPosition(),
					false),
				polyline: {
					show: true,
					positions: new Cesium.CallbackProperty(_self._callUpdateAltitudePolylinePositions(),
						false),
					material: _self._tempAlititudeLineMaterial,
					width: _self._param.moveAltitudeLineWidth,
					clampToGround: false, //禁止贴地或模型 否则为平面线
				},
				ellipse: {
					show: true,
					semiMinorAxis: new Cesium.CallbackProperty(_self._callUpdateEllipseMinorAxis(), false),
					semiMajorAxis: new Cesium.CallbackProperty(_self._callUpdateEllipseMinorAxis(), false),
					height: new Cesium.CallbackProperty(_self._callUpdateEllipseHeight(), false),
					material: _self._toColorFromArray(_self._param.moveEllipseColor),
					outline: _self._param.moveEllipseOutline,
					outlineWidth: _self._param.moveEllipseOutlineWidth,
					outlineColor: _self._toColorFromArray(_self._param.moveEllipseOutlineColor),
				},
			})
			_self._entities.add(_self._sketchTempAltituePolyline);
		}
	}

	/**
	 * 创建正式高度线
	 * @ignore
	 */
	_createAltitudePolyline() {
		let _self = this;
		if (!Cesium.defined(this._sketchAltitudePolyline)) {
			this._sketchAltitudePolyline = new Cesium.Entity({
				name: _self._sketchEntityName,
				position: _self._sketchEllipseCenterPosition,
				polyline: {
					show: true,
					positions: _self._sketchAltitudePolylinePostions,
					material: _self._altitudeLineMaterial,
					width: _self._param.altitudeLineWidth,
					clampToGround: false, //禁止贴地或模型 否则为平面线
				},
				ellipse: {
					show: true,
					semiMinorAxis: _self._sketchEllipseRadius,
					semiMajorAxis: _self._sketchEllipseRadius,
					height: _self._sketchEllipseHeight,
					material: _self._toColorFromArray(_self._param.ellipseColor),
					outline: _self._param.ellipseOutline,
					outlineWidth: _self._param.ellipseOutlineWidth,
					outlineColor: _self._toColorFromArray(_self._param.ellipseOutlineColor),
				},
			})
			_self._entities.add(_self._sketchAltitudePolyline);
		}
	}

	/**
	 * 圆边界点变更回调
	 * @ignore
	 */
	_callEllipseOutlineCoordinate() {
		let _self = this;
		return function() {
			let positionCenter = _self._sketchEllipseCenterPosition;
			let positionRotate = _self._sketchTempPoints[1];
			_self._ellipseOutlineCoordinates = [];
			for (let angle = 5; angle < 360;) {
				let newPosition = _self._rotatedPointByAngle(positionRotate, positionCenter, angle);
				_self._ellipseOutlineCoordinates.push(newPosition);
				angle = angle + 5;
			}
			_self._ellipseOutlineCoordinates.push(_self._ellipseOutlineCoordinates[0]);
			return _self._ellipseOutlineCoordinates;
		}
	}

	/**
	 * 创建临时圆
	 * @ignore
	 * @param {Cesium.Cartesian3} centerPosition 圆的中心点位置
	 */
	_createTempCircle(centerPosition) {
		let _self = this;
		if (!Cesium.defined(this._sketchTempCircle)) {
			/* 存储椭圆中心点位置 */
			_self._sketchEllipseCenterPosition = centerPosition.clone();
			this._sketchTempCircle = new Cesium.Entity({
				name: _self._sketchEntityName,
				position: centerPosition,
				polyline: {
					show: true,
					positions: new Cesium.CallbackProperty(_self._callEllipseOutlineCoordinate(), false),
					material: _self._tempLineMaterial,
					width: _self._param.moveLineWidth,
					clampToGround: true, //开启贴地 如果有模型则贴模型
				},
				ellipse: {
					show: true,
					semiMinorAxis: new Cesium.CallbackProperty(_self._callUpdateEllipseMinorAxis(), false),
					semiMajorAxis: new Cesium.CallbackProperty(_self._callUpdateEllipseMinorAxis(), false),
					material: _self._tempPolygonMaterial,
					classificationType: Cesium.ClassificationType.BOTH,
				},
			})
			_self._entities.add(_self._sketchTempCircle);
		}
	}

	/**
	 * position_A绕position_B逆时针旋转angle度（角度）得到新点
	 * @ignore
	 * @param {Cesium.Cartesian3} position_A 动点
	 * @param {Cesium.Cartesian3} position_B 中心点
	 * @param {Number} angle 旋转角度
	 */
	_rotatedPointByAngle(position_A, position_B, angle) {
		//以B点为原点建立局部坐标系（东方向为x轴,北方向为y轴,垂直于地面为z轴），得到一个局部坐标到世界坐标转换的变换矩阵
		var localToWorld_Matrix = Cesium.Transforms.eastNorthUpToFixedFrame(position_B);
		//求世界坐标到局部坐标的变换矩阵
		var worldToLocal_Matrix = Cesium.Matrix4.inverse(localToWorld_Matrix, new Cesium.Matrix4());
		//B点在局部坐标的位置，其实就是局部坐标原点
		var localPosition_B = Cesium.Matrix4.multiplyByPoint(worldToLocal_Matrix, position_B, new Cesium
			.Cartesian3());
		//A点在以B点为原点的局部的坐标位置
		var localPosition_A = Cesium.Matrix4.multiplyByPoint(worldToLocal_Matrix, position_A, new Cesium
			.Cartesian3());
		//根据数学公式A点逆时针旋转angle度后在局部坐标系中的x,y,z位置
		var new_x = localPosition_A.x * Math.cos(Cesium.Math.toRadians(angle)) + localPosition_A.y * Math.sin(Cesium
			.Math.toRadians(angle));
		var new_y = localPosition_A.y * Math.cos(Cesium.Math.toRadians(angle)) - localPosition_A.x * Math.sin(Cesium
			.Math.toRadians(angle));
		var new_z = localPosition_A.z;
		//最后应用局部坐标到世界坐标的转换矩阵求得旋转后的A点世界坐标
		return Cesium.Matrix4.multiplyByPoint(localToWorld_Matrix, new Cesium.Cartesian3(new_x, new_y, new_z),
			new Cesium.Cartesian3());
	}

	/**
	 * 创建正式圆
	 * @ignore
	 */
	_createCircle() {
		let _self = this;
		if (!Cesium.defined(this._sketchCircle)) {
			this._sketchCircle = new Cesium.Entity({
				name: _self._sketchEntityName,
				position: _self._sketchEllipseCenterPosition,
				polyline: {
					show: true,
					positions: _self._ellipseOutlineCoordinates,
					material: _self._lineMaterial,
					width: _self._param.lineWidth,
					clampToGround: true, //开启贴地 如果有模型则贴模型
				},
				ellipse: {
					show: true,
					semiMinorAxis: _self._sketchEllipseRadius,
					semiMajorAxis: _self._sketchEllipseRadius,
					material: _self._polygonMaterial,
					classificationType: Cesium.ClassificationType.BOTH,
				},
			})
			_self._entities.add(_self._sketchCircle);
		}
	}

	/**
	 * 更新矩形坐标
	 * @ignore
	 */
	_callUpdateRectangleCoordinates() {
		let _self = this;
		return function() {
			let lng0 = parseFloat(_self._sketchTempPoints[0].lng);
			let lat0 = parseFloat(_self._sketchTempPoints[0].lat);
			let lng1 = parseFloat(_self._sketchTempPoints[1].lng);
			let lat1 = parseFloat(_self._sketchTempPoints[1].lat);
			_self._rectangleCoordinates = [0, 0, 1, 1];
			if (lng0 < lng1) {
				_self._rectangleCoordinates[0] = lng0;
				_self._rectangleCoordinates[2] = lng1;
			} else {
				_self._rectangleCoordinates[0] = lng1;
				_self._rectangleCoordinates[2] = lng0;
			}
			if (lat0 < lat1) {
				_self._rectangleCoordinates[1] = lat0;
				_self._rectangleCoordinates[3] = lat1;
			} else {
				_self._rectangleCoordinates[1] = lat1;
				_self._rectangleCoordinates[3] = lat0;
			}
			let rectangle = Cesium.Rectangle.fromDegrees(_self._rectangleCoordinates[0], _self
				._rectangleCoordinates[1],
				_self._rectangleCoordinates[2], _self._rectangleCoordinates[3]);
			/* 计算并返回矩形的边界线坐标数组 */
			let res = _self._calculateRectangleOutlineCoordinates(rectangle);
			_self._rectangleOutlineCoordinates = res.cPoints;
			_self._sketchOutputPoints = res.gPoints;
			return rectangle;
		}
	}

	/**
	 * 计算矩形的外围坐标串
	 * @ignore
	 * @param {Cesium.Rectangle} rectangle 矩形
	 * @return {Array<Cesium.Cartesian3>} 坐标串集合
	 */
	_calculateRectangleOutlineCoordinates(rectangle) {
		/* 计算东南角 */
		let south_east = Cesium.Rectangle.southeast(rectangle);
		let se = Cesium.Cartographic.toCartesian(south_east);
		/* 计算西南角 */
		let south_west = Cesium.Rectangle.southwest(rectangle);
		let sw = Cesium.Cartographic.toCartesian(south_west);
		/* 计算东北角 */
		let north_east = Cesium.Rectangle.northeast(rectangle);
		let ne = Cesium.Cartographic.toCartesian(north_east);
		/* 计算西北角 */
		let north_west = Cesium.Rectangle.northwest(rectangle);
		let nw = Cesium.Cartographic.toCartesian(north_west);
		/* 经纬度坐标数组 */
		let gPoints = [];
		gPoints.push({
			lng: Cesium.Math.toDegrees(south_west.longitude),
			lat: Cesium.Math.toDegrees(south_west.latitude),
			height: south_west.height,
		});
		gPoints.push({
			lng: Cesium.Math.toDegrees(south_east.longitude),
			lat: Cesium.Math.toDegrees(south_east.latitude),
			height: south_east.height,
		});
		gPoints.push({
			lng: Cesium.Math.toDegrees(north_east.longitude),
			lat: Cesium.Math.toDegrees(north_east.latitude),
			height: north_east.height,
		});
		gPoints.push({
			lng: Cesium.Math.toDegrees(north_west.longitude),
			lat: Cesium.Math.toDegrees(north_west.latitude),
			height: north_west.height,
		});
		gPoints.push({
			lng: Cesium.Math.toDegrees(south_west.longitude),
			lat: Cesium.Math.toDegrees(south_west.latitude),
			height: south_west.height,
		});
		/* 返回坐标串 */
		return {
			cPoints: [sw, se, ne, nw, sw],
			gPoints: gPoints,
		};
	}

	/**
	 * 矩形外边框轮廓线调用
	 * @ignore
	 */
	_callUpdateRectangleOutlineCoordinates() {
		let _self = this;
		return function() {
			return _self._rectangleOutlineCoordinates;
		}
	}

	/**
	 * 创建临时矩形
	 * @ignore
	 */
	_createTempRectangle() {
		let _self = this;
		if (!Cesium.defined(this._sketchTempRectangle)) {
			this._sketchTempRectangle = new Cesium.Entity({
				name: _self._sketchEntityName,
				polyline: {
					show: true,
					positions: new Cesium.CallbackProperty(_self._callUpdateRectangleOutlineCoordinates(), false),
					material: _self._tempLineMaterial,
					width: _self._param.moveLineWidth,
					clampToGround: true, //开启贴地 如果有模型则贴模型
				},
				rectangle: {
					show: true,
					coordinates: new Cesium.CallbackProperty(_self._callUpdateRectangleCoordinates(), false),
					material: _self._tempPolygonMaterial,
					classificationType: Cesium.ClassificationType.BOTH,
				},
			})
			_self._entities.add(_self._sketchTempRectangle);
		}
	}

	/**
	 * 创建矩形
	 * @ignore
	 */
	_createRectangle() {
		let _self = this;
		if (!Cesium.defined(this._sketchRectangle)) {
			this._sketchRectangle = new Cesium.Entity({
				name: _self._sketchEntityName,
				polyline: {
					show: true,
					positions: _self._rectangleOutlineCoordinates,
					material: _self._lineMaterial,
					width: _self._param.lineWidth,
					clampToGround: true, //开启贴地 如果有模型则贴模型
				},
				rectangle: {
					show: true,
					coordinates: Cesium.Rectangle.fromDegrees(_self._rectangleCoordinates[0], _self._rectangleCoordinates[1], _self._rectangleCoordinates[2], _self._rectangleCoordinates[3]),
					material: _self._polygonMaterial,
					classificationType: Cesium.ClassificationType.BOTH,
				},
			})
			_self._entities.add(_self._sketchRectangle);
		}
	}

	/**
	 * 调用更新三角形高度线椭圆中心点位置信息
	 * @ignore
	 */
	_callUpdaeTriangleEllipseCenterPosition() {
		let _self = this;
		return function() {
			let point1cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[1]);
			let point2cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[2]);
			_self._sketchEllipseCenterPosition = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(point1cartographic.longitude), Cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);
			return _self._sketchEllipseCenterPosition;
		}
	}

	/**
	 * 调用更新三角形高度线的点集合信息
	 * @ignore
	 */
	_callUpdateTriangleAltitudePolylinePositions() {
		let _self = this;
		return function() {
			_self._sketchAltitudePolylinePostions = [];
			_self._sketchAltitudePolylinePostions.push(_self._sketchTempPoints[1]);
			let point1cartographic = Cesium.Cartographic.fromCartesian(_self
				._sketchTempPoints[1]);
			let point2cartographic = Cesium.Cartographic.fromCartesian(_self
				._sketchTempPoints[2]);
			let point_temp = Cesium.Cartesian3.fromDegrees(Cesium.Math
				.toDegrees(
					point1cartographic
					.longitude), Cesium.Math.toDegrees(point1cartographic
					.latitude),
				point2cartographic.height);
			_self._sketchAltitudePolylinePostions.push(point_temp);
			return _self._sketchAltitudePolylinePostions;
		}
	}

	/**
	 * 调用更新三角形高度线椭圆-长短半轴大小变化回调
	 * @ignore
	 */
	_callUpdateTriangleEllipseMinorAxis() {
		let _self = this;
		return function() {
			let point1cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[1]);
			let point2cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[2]);
			/* 计算距离 */
			let geodesic = new Cesium.EllipsoidGeodesic();
			geodesic.setEndPoints(point1cartographic, point2cartographic);
			_self._sketchEllipseRadius = geodesic.surfaceDistance;
			if (_self._sketchEllipseRadius <= 0) _self._sketchEllipseRadius = 1;
			return _self._sketchEllipseRadius;
		}
	}

	/**
	 * 调用更新三角形高度线椭圆高度信息
	 * @ignore
	 */
	_callUpdateTriangleEllipseHeight() {
		let _self = this;
		return function() {
			let cartographic = Cesium.Cartographic.fromCartesian(_self
				._sketchTempPoints[1]);
			let cartographic1 = Cesium.Cartographic.fromCartesian(_self
				._sketchTempPoints[2]);
			let height_temp = cartographic1.height - cartographic.height;
			_self._sketchEllipseHeight = height_temp + _self._sketchAltitudeInitHeight;
			return _self._sketchEllipseHeight;
		}
	}

	/**
	 * 调用空间三角形空间线位置回调
	 * @ignore
	 */
	_callUpdateTriangleSpatialPolylinePositions() {
		let _self = this;
		return function() {
			_self._sketchTriangleSpatialPolylinePositions = [];
			_self._sketchTriangleSpatialPolylinePositions.push(_self._sketchTempPoints[0]);
			_self._sketchTriangleSpatialPolylinePositions.push(_self._sketchEllipseCenterPosition);
			return _self._sketchTriangleSpatialPolylinePositions;
		}
	}

	/**
	 * 创建三角形空间线
	 * @ignore
	 */
	_createTriangleSpatialPolyline() {
		let _self = this;
		/* 创建空间线实例 */
		this._sketchSpatialPolyline = new Cesium.Entity({
			name: _self._sketchEntityName,
			polyline: {
				show: true,
				positions: _self._sketchTriangleSpatialPolylinePositions,
				material: _self._spatialLineMaterial,
				width: _self._param.spatialLineWidth,
				clampToGround: false, //开启贴地 如果有模型则贴模型
			}
		});
		/* 加入实体集合 */
		this._entities.add(this._sketchSpatialPolyline);
	}

	/**
	 * 创建三角形临时高度线和空间线
	 * @ignore
	 */
	_createTempTriangleAltitudePolylineAndSpatialPolyline() {
		let _self = this;
		if (!Cesium.defined(this._sketchTempTriangleAltitudePolyline) && !Cesium.defined(this
				._sketchTempSpatialPolyline)) {
			/* 创建高度线实例 */
			this._sketchTempTriangleAltitudePolyline = new Cesium.Entity({
				name: _self._sketchEntityName,
				position: new Cesium.CallbackProperty(_self._callUpdaeTriangleEllipseCenterPosition(),
					false),
				polyline: {
					show: true,
					positions: new Cesium.CallbackProperty(_self
						._callUpdateTriangleAltitudePolylinePositions(),
						false),
					material: _self._tempAlititudeLineMaterial,
					width: _self._param.moveAltitudeLineWidth,
					clampToGround: false, //禁止贴地或贴模型
				},
				ellipse: {
					show: true,
					semiMinorAxis: new Cesium.CallbackProperty(_self._callUpdateTriangleEllipseMinorAxis(), false),
					semiMajorAxis: new Cesium.CallbackProperty(_self._callUpdateTriangleEllipseMinorAxis(), false),
					height: new Cesium.CallbackProperty(_self._callUpdateTriangleEllipseHeight(), false),
					material: _self._toColorFromArray(_self._param.moveEllipseColor),
					outline: _self._param.moveEllipseOutline,
					outlineWidth: _self._param.moveEllipseOutlineWidth,
					outlineColor: _self._toColorFromArray(_self._param.moveEllipseOutlineColor),
				},
			});
			/* 加入实体集合 */
			_self._entities.add(_self._sketchTempTriangleAltitudePolyline);
			/* 创建空间线实例 */
			_self._sketchTempSpatialPolyline = new Cesium.Entity({
				name: _self._sketchEntityName,
				polyline: {
					show: true,
					positions: new Cesium.CallbackProperty(_self
						._callUpdateTriangleSpatialPolylinePositions(), false),
					material: _self._tempLineMaterial,
					width: _self._param.moveLineWidth,
					clampToGround: false, //禁止贴地或贴模型
				}
			});
			/* 加入实体集合 */
			_self._entities.add(_self._sketchTempSpatialPolyline);
		}
	}

	/**
	 * 创建临时空间三角形
	 * @ignore
	 */
	_createTempSpatialTriangle() {
		let _self = this;
		/* 创建临时线 */
		if (!Cesium.defined(this._sketchTempSpatialTriangle)) {
			this._sketchTempSpatialTriangle = new Cesium.Entity({
				name: _self._sketchEntityName,
				polyline: {
					show: true,
					positions: new Cesium.CallbackProperty(function() {
						/* 为了成功绘制 需要对点数据进行处理 */
						_self._sketchSpatialTrianglePositions = [];
						_self._sketchSpatialTrianglePositions.push(_self._sketchTempPoints[0].clone());
						_self._sketchSpatialTrianglePositions.push(_self._sketchTempPoints[1].clone());
						let point1cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[0]);
						let point2cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[1]);
						let point_temp = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(point1cartographic.longitude), Cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);
						_self._sketchSpatialTrianglePositions.push(point_temp);
						_self._sketchSpatialTrianglePositions.push(_self._sketchTempPoints[0].clone());
						return _self._sketchSpatialTrianglePositions;
					}, false),
					material: _self._tempLineMaterial,
					width: _self._param.moveLineWidth,
					clampToGround: false, //为了绘制空间三角形 禁止贴地
				}
			})
			this._entities.add(this._sketchTempSpatialTriangle);
			this._updateScene();
		}
	}

	/**
	 * 创建正式空间三角形
	 * @ignore
	 */
	_createSpatialTriangle() {
		let _self = this;
		/* 创建临时线 */
		if (!Cesium.defined(this._sketchSpatialTriangle)) {
			this._sketchSpatialTriangle = new Cesium.Entity({
				name: _self._sketchEntityName,
				polyline: {
					show: true,
					positions: _self._sketchSpatialTrianglePositions,
					material: _self._lineMaterial,
					width: _self._param.lineWidth,
					clampToGround: false, //为了绘制空间三角形 禁止贴地
				}
			})
			this._entities.add(this._sketchSpatialTriangle);
			this._updateScene();
		}
	}

	/**
	 * 设置移动线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Boolean} options.outline 是否有边框，有边框则为实线，否则为虚线
	 * @param {Array<Number>} options.outlineColor 移动线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 移动线描边宽度
	 * @param {Number} options.power 亮度[0~1],如果需要使用虚线，请将该值设置为undefined
	 */
	_setMoveLineStyle(options) {
		let _self = this;
		let color = [255, 255, 255, 1.0];
		let lineWidth = 3;
		let isOutline = false;
		let power = 0.2;
		let outlineColor = [255, 0, 0, 1.0];
		let outlineWidth = 1;
		if (options && options.color && options.color.length === 4) color = options.color;
		if (options && options.outline && typeof options.outline === 'boolean') isOutline = options.outline;
		if (options && options.outlineColor && options.outlineColor.length === 4) outlineColor = options
			.outlineColor;
		if (options && options.outlineWidth && typeof options.outlineWidth === 'number') outlineWidth =
			options.outlineWidth;
		if (options && options.lineWidth && typeof options.lineWidth === 'number') lineWidth = options
			.lineWidth;
		/* 设置亮度 */
		if (options && options.power) power = options.power;
		if (isOutline) {
			this._tempLineMaterial = new Cesium.PolylineOutlineMaterialProperty({
				color: _self._toColorFromArray(color),
				outlineColor: _self._toColorFromArray(outlineColor),
				outlineWidth: outlineWidth,
			});
		} else {
			if (power === undefined) {
				this._tempLineMaterial = new Cesium.PolylineDashMaterialProperty({
					color: _self._toColorFromArray(color),
				});
			} else {
				this._tempLineMaterial = new Cesium.PolylineGlowMaterialProperty({
					color: _self._toColorFromArray(color),
					glowPower: power,
				});
			}
		}
		/* 设置移动线宽 */
		this._param.moveLineWidth = lineWidth;
	}

	/**
	 * 设置线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Array<Number>} options.outlineColor 线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 线描边宽度
	 */
	_setLineStyle(options) {
		let _self = this;
		let color = [255, 255, 255, 1.0];
		let lineWidth = 2;
		let outlineColor = [0, 255, 0, 0.6];
		let outlineWidth = 1;
		if (options && options.color && options.color.length === 4) color = options.color;
		if (options && options.outlineColor && options.outlineColor.length === 4) outlineColor = options
			.outlineColor;
		if (options && options.outlineWidth && typeof options.outlineWidth === 'number') outlineWidth =
			options.outlineWidth;
		if (options && options.lineWidth && typeof options.lineWidth === 'number') lineWidth = options
			.lineWidth;
		this._lineMaterial = new Cesium.PolylineOutlineMaterialProperty({
			color: _self._toColorFromArray(color),
			outlineColor: _self._toColorFromArray(outlineColor),
			outlineWidth: outlineWidth,
		});
		/* 设置线宽 */
		this._param.lineWidth = lineWidth;
	}

	/**
	 * 设置空间线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Array<Number>} options.outlineColor 线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 线描边宽度
	 */
	_setSpatialLineStyle(options) {
		let _self = this;
		let color = [255, 255, 0, 1.0];
		let lineWidth = 2;
		let outlineColor = [255, 255, 255, 1.0];
		let outlineWidth = 1;
		if (options && options.color && options.color.length === 4) color = options.color;
		if (options && options.outlineColor && options.outlineColor.length === 4) outlineColor = options
			.outlineColor;
		if (options && options.outlineWidth && typeof options.outlineWidth === 'number') outlineWidth =
			options.outlineWidth;
		if (options && options.lineWidth && typeof options.lineWidth === 'number') lineWidth = options
			.lineWidth;
		this._spatialLineMaterial = new Cesium.PolylineOutlineMaterialProperty({
			color: _self._toColorFromArray(color),
			outlineColor: _self._toColorFromArray(outlineColor),
			outlineWidth: outlineWidth,
		});
		/* 设置线宽 */
		this._param.spatialLineWidth = lineWidth;
	}

	/**
	 * 设置移动绘制的区域样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动面颜色[0~255,0~255,0~255,0~1]
	 */
	_setMovePolygonStyle(options) {
		let polygonColor = [255, 0, 0, 0.3];
		if (options && options.color && options.color.length === 4) polygonColor = options.color;
		/* 临时面材质 */
		this._tempPolygonMaterial = new Cesium.ColorMaterialProperty(this._toColorFromArray(polygonColor));
	}

	/**
	 * 设置区域样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动面颜色[0~255,0~255,0~255,0~1]
	 */
	_setPolygonStyle(options) {
		let polygonColor = [0, 0, 255, 0.3];
		if (options && options.color && options.color.length === 4) polygonColor = options.color;
		/* 临时面材质 */
		this._polygonMaterial = new Cesium.ColorMaterialProperty(this._toColorFromArray(polygonColor));
	}

	/**
	 * 设置移动高度线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Boolean} options.outline 是否有边框，有边框则为实线，否则为虚线
	 * @param {Array<Number>} options.outlineColor 移动线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 移动线描边宽度
	 */
	_setMoveAltitudeLineStyle(options) {
		let _self = this;
		let color = [255, 255, 255, 1.0];
		let lineWidth = 2;
		let isOutline = true;
		let outlineColor = [255, 255, 0, 1.0];
		let outlineWidth = 1;
		if (options && options.color && options.color.length === 4) color = options.color;
		if (options && options.outline && typeof options.outline === 'boolean') isOutline = options.outline;
		if (options && options.outlineColor && options.outlineColor.length === 4) outlineColor = options
			.outlineColor;
		if (options && options.outlineWidth && typeof options.outlineWidth === 'number') outlineWidth =
			options.outlineWidth;
		if (options && options.lineWidth && typeof options.lineWidth === 'number') lineWidth = options
			.lineWidth;
		if (isOutline) {
			this._tempAlititudeLineMaterial = new Cesium.PolylineOutlineMaterialProperty({
				color: _self._toColorFromArray(color),
				outlineColor: _self._toColorFromArray(outlineColor),
				outlineWidth: outlineWidth,
			});
		} else {
			this._tempAlititudeLineMaterial = new Cesium.PolylineDashMaterialProperty({
				color: _self._toColorFromArray(color),
			});
		}
		/* 设置移动线宽 */
		this._param.moveAltitudeLineWidth = lineWidth;
	}

	/**
	 * 设置高度线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Array<Number>} options.outlineColor 线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 线描边宽度
	 */
	_setAltitudeLineStyle(options) {
		let _self = this;
		let color = [255, 255, 255, 1.0];
		let lineWidth = 2;
		let outlineColor = [0, 0, 255, 1.0];
		let outlineWidth = 1;
		if (options && options.color && options.color.length === 4) color = options.color;
		if (options && options.outlineColor && options.outlineColor.length === 4) outlineColor = options
			.outlineColor;
		if (options && options.outlineWidth && typeof options.outlineWidth === 'number') outlineWidth =
			options.outlineWidth;
		if (options && options.lineWidth && typeof options.lineWidth === 'number') lineWidth = options
			.lineWidth;
		this._altitudeLineMaterial = new Cesium.PolylineOutlineMaterialProperty({
			color: _self._toColorFromArray(color),
			outlineColor: _self._toColorFromArray(outlineColor),
			outlineWidth: outlineWidth,
		});
		/* 设置线宽 */
		this._param.altitudeLineWidth = lineWidth;
	}

	/**
	 * 设置移动圆的样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动圆的颜色[0~255,0~255,0~255,0~1]
	 * @param {Boolean} options.outline 是否有边框
	 * @param {Array<Number>} options.outlineColor 描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 描边宽度
	 */
	_setMoveEllipseStyle(options) {
		if (options && options.color && options.color.length === 4) this._param.moveEllipseColor = options
			.color;
		if (options && options.outlineWidth && typeof options.outlineWidth === 'number') this._param
			.moveEllipseOutlineWidth = options.outlineWidth;
		if (options && options.outline && typeof options.outline === 'boolean') this._param
			.moveEllipseOutline =
			options.outline;
		if (options && options.outlineColor && options.outlineColor.length === 4) this._param
			.moveEllipseOutlineColor = options.outlineColor;
	}

	/**
	 * 设置圆的样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 圆的颜色[0~255,0~255,0~255,0~1]
	 * @param {Boolean} options.outline 是否有边框
	 * @param {Array<Number>} options.outlineColor 描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 描边宽度
	 */
	_setEllipseStyle(options) {
		if (options && options.color && options.color.length === 4) this._param.ellipseColor = options
			.color;
		if (options && options.outlineWidth && typeof options.outlineWidth === 'number') this._param
			.ellipseOutlineWidth = options.outlineWidth;
		if (options && options.outline && typeof options.outline === 'boolean') this._param.ellipseOutline =
			options.outline;
		if (options && options.outlineColor && options.outlineColor.length === 4) this._param
			.ellipseOutlineColor = options.outlineColor;
	}

	/**
	 * 清理资源
	 * @ignore
	 * @param {Boolean} isAll 是否删除已经绘制的全部实体
	 */
	_clear(isAll) {
		if (isAll != undefined && isAll === true) {
			this._removeEntityByName(this._sketchEntityName);
			this._removePointEntitys();
		}
		/* 重置数组变量 */
		this._sketchTempPoints = [];
		this._sketchPoints = [];
		this._sketchOutputPoints = [];
		/* 重置绘制线变量 */
		this._sketchTempPolyline = undefined;
		this._sketchPolyline = undefined;
		/* 重置绘制面变量 */
		this._sketchTempPolygon = undefined;
		this._sketchPolygon = undefined;
		/* 重置高度线变量 */
		this._sketchTempAltituePolyline = undefined;
		this._sketchAltitudePolyline = undefined;
		/* 重置空间线变量 */
		this._sketchTempSpatialPolyline = undefined;
		this._sketchSpatialPolyline = undefined;
		/* 重置圆变量 */
		this._sketchTempCircle = undefined;
		this._sketchCircle = undefined;
		/* 重置矩形变量 */
		this._sketchTempRectangle = undefined;
		this._sketchRectangle = undefined;
		/* 重置三角形 */
		this._sketchTempTriangleAltitudePolyline = undefined;
		this._sketchTriangleAltituePolyline = undefined;
		/* 重置空间三角形 */
		this._sketchTempSpatialTriangle = undefined;
		this._sketchSpatialTriangle = undefined;
	}

	/**
	 * 检测程序运行环境
	 * @ignore
	 * @return {SketchViewModel.RuntimeEnvironment}
	 */
	_checkAppOrWeb() {
		if (window.navigator.userAgent.match(
				/(phone|pad|pod|iPhone|iPod|ios|iPad|Android|Mobile|BlackBerry|IEMobile|MQQBrowser|JUC|Fennec|wOSBrowser|BrowserNG|WebOS|Symbian|Windows Phone)/i
			)) {
			return SketchViewModel.RuntimeEnvironment.App;
		} else {
			return SketchViewModel.RuntimeEnvironment.Web;
		}
	}

	/**
	 * 是否是运行于App
	 * @ignore
	 */
	_isRuntimeApp() {
		if (this._checkAppOrWeb() === SketchViewModel.RuntimeEnvironment.App) {
			return true;
		}
		return false;
	}
}

/**
 * 设置方法
 */
Object.assign(SketchViewModel.prototype, {
	/**
	 * 设置移动线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Boolean} options.outline 是否有边框，有边框则为实线，否则为虚线
	 * @param {Array<Number>} options.outlineColor 移动线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 移动线描边宽度
	 * @param {Number} options.power 亮度[0~1],如果需要使用虚线，请将该值设置为undefined
	 */
	setMoveLineStyle: function(options) {
		this._setMoveLineStyle(options);
	},

	/**
	 * 设置线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Array<Number>} options.outlineColor 线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 线描边宽度 
	 */
	setLineStyle: function(options) {
		this._setLineStyle(options);
	},

	/**
	 * 设置空间线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Array<Number>} options.outlineColor 线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 线描边宽度
	 */
	setSpatialLineStyle: function() {
		this._setSpatialLineStyle(options);
	},

	/**
	 * 设置移动绘制的区域样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动面颜色[0~255,0~255,0~255,0~1]
	 */
	setMovePolygonStyle: function(options) {
		this._setMovePolygonStyle(options);
	},

	/**
	 * 设置区域样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动面颜色[0~255,0~255,0~255,0~1]
	 */
	setPolygonStyle: function(options) {
		this._setPolygonStyle(options)
	},

	/**
	 * 设置移动高度线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Boolean} options.outline 是否有边框，有边框则为实线，否则为虚线
	 * @param {Array<Number>} options.outlineColor 移动线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 移动线描边宽度
	 */
	setMoveAltitudeLineStyle: function(options) {
		this._setMoveAltitudeLineStyle(options);
	},

	/**
	 * 设置高度线样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 线颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.lineWidth 移动线的宽度 
	 * @param {Array<Number>} options.outlineColor 线描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 线描边宽度
	 */
	setAltitudeLineStyle: function(options) {
		this._setAltitudeLineStyle(options);
	},

	/**
	 * 设置移动圆的样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 移动圆的颜色[0~255,0~255,0~255,0~1]
	 * @param {Boolean} options.outline 是否有边框
	 * @param {Array<Number>} options.outlineColor 描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 描边宽度
	 */
	setMoveEllipseStyle: function(options) {
		this._setMoveEllipseStyle(options);
	},

	/**
	 * 设置圆的样式
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color 圆的颜色[0~255,0~255,0~255,0~1]
	 * @param {Boolean} options.outline 是否有边框
	 * @param {Array<Number>} options.outlineColor 描边颜色[0~255,0~255,0~255,0~1]
	 * @param {Number} options.outlineWidth 描边宽度
	 */
	setEllipseStyle: function(options) {
		this._setEllipseStyle(options);
	},

	/**
	 * 设置点击点显示的标记
	 * @ignore
	 * @param {JSNO} options 配置项
	 * @param {String} options.lineLabel 线点文字标注
	 * @param {String} options.polygonLabel 面点文字标注
	 */
	setLabel: function(options) {
		if (!options) {
			options = {
				lineLabel: undefined,
				polygonLabel: undefined,
			}
		}
		if (options.lineLabel) this._lineLabel = options.lineLabel;
		if (options.polygonLabel) this._lineLabel = options.polygonLabel;
	}
})

/**
 * 事件相关
 */
Object.assign(SketchViewModel.prototype, {

	/**
	 * 注册鼠标左键点击事件
	 * @ignore
	 * @param {Cesium.ScreenSpaceEventHandler} handler 事件句柄
	 * @param {Function} callChange 回调callChange(event)
	 */
	_registerLeftClickEvent: function(handler, callChange) {
		let _self = this;
		if (!handler) return;
		handler.setInputAction(function(event) {
			/* 锁定点击事件 以免和移动事件冲突 */
			_self._lock = true;
			if (_self._timer != null) clearTimeout(_self._timer);
			_self._timer = setTimeout(function() {
				if (callChange) callChange(event);
				/* 解除锁定 */
				_self._lock = false;
			}, 200);
		}, Cesium.ScreenSpaceEventType.LEFT_CLICK);
	},

	/**
	 * 注册鼠标左键双击事件
	 * @ignore
	 * @param {Cesium.ScreenSpaceEventHandler} handler 事件句柄
	 * @param {Function} callChange 回调callChange(event)
	 */
	_registerLeftDoubleClickEvent: function(handler, callChange) {
		let _self = this;
		if (!handler) return;
		handler.setInputAction(function(event) {
			if (_self._timer != null) clearTimeout(_self._timer);
			/* 解除锁定 */
			_self._lock = false;
			if (callChange) callChange(event);
		}, Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
	},

	/**
	 * 注册鼠标移动事件
	 * @ignore
	 * @param {Cesium.ScreenSpaceEventHandler} handler 事件句柄
	 * @param {Function} callChange 回调callChange(event)
	 */
	_registerMouseMoveEvent: function(handler, callChange) {
		let _self = this;
		if (!handler) return;

		handler.setInputAction(function(event) {
			if (_self._lock === undefined || _self._lock === false) {
				if (callChange) callChange(event);
			}
		}, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
	},

	/**
	 * 注册鼠标右键点击事件
	 * @ignore
	 * @param {Cesium.ScreenSpaceEventHandler} handler 事件句柄
	 * @param {Function} callChange 回调callChange(event)
	 */
	_registerRightClickEvent: function(handler, callChange) {
		if (!handler) return;
		handler.setInputAction(function(event) {
			if (callChange) callChange(event);
		}, Cesium.ScreenSpaceEventType.RIGHT_CLICK);
	},

	/**
	 * 清除事件
	 * @ignore
	 * @param {Cesium.ScreenSpaceEventHandler} handler
	 */
	_clearEvent: function(handler) {
		if (!handler) return;
		/* 干掉事件句柄 释放资源 */
		handler.destroy();
		handler = null;
	},
})

/**
 * 对外方法-绘制
 */
Object.assign(SketchViewModel.prototype, /** @lends SketchViewModel.prototype */ {
	/**
	 * 绘制点工具
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onComplete(cPoint, gPoint)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回到 可选
	 */
	_sketchDrawPoint(handler, options) {
		let _self = this;
		/* 注册鼠标左键点击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;
			/* 绘制点 */
			if (_self._isDrawPoint) {
				_self._createPoint(loc.sLocation, _self._lineLabel);
			}
			/* 干掉事件句柄 释放资源 */
			_self._clearEvent(handler);
			/* 监听输出 */
			if (options.onComplete) options.onComplete(loc.sLocation, loc.gLocation);
		})
	},

	/**
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onAdded(cPoinit,gPoint)] 添加回调 可选
	 * @param {Function} [options.onUndo()] 撤销回调 可选 
	 * @param {Function} [options.onComplete(cPoints,gPoints)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回调 可选 
	 */
	_sketchDrawMultiplePoint(handler, options) {
		let _self = this;
		/* 注册鼠标左键点击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;
			/* 绘制点 */
			if (_self._isDrawPoint) {
				_self._createPoint(loc.sLocation, _self._lineLabel);
			}
			_self._sketchPoints.push(loc.sLocation);
			_self._sketchOutputPoints.push(loc.gLocation);
			/* 监听输出 */
			if (options.onAdded) options.onAdded(loc.sLocation, loc.gLocation);
		})
		/* 注册鼠标右键事件 */
		this._registerRightClickEvent(handler, function(event) {
			if (_self._sketchPoints.length > 0) {
				_self._sketchPoints.pop();
				_self._sketchOutputPoints.pop();
				if (options.onUndo) options.onUndo();
			}
		})
		/* 注册鼠标左键双击事件 */
		this._registerLeftDoubleClickEvent(handler, function(event) {
			/* 干掉事件句柄 释放资源 */
			_self._clearEvent();
			/* 回调 */
			if (options.onComplete) options.onComplete(_self._sketchPoints, _self._sketchOutputPoints);
		})
	},

	/**
	 * 绘制线工具
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onAdded(cPoints,gPoints)] 添加回调 可选
	 * @param {Function} [options.onMoving(cPoint)] 移动回调 可选
	 * @param {Function} [options.onUndo()] 撤销回调 可选 
	 * @param {Function} [options.onComplete(cPoints,gPoints)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回调 可选 
	 */
	_sketchDrawPolyline(handler, options) {
		let _self = this;
		/* 注册鼠标左键点击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;
			/* 绘制点 */
			if (_self._isDrawPoint) {
				_self._createPoint(loc.sLocation, _self._lineLabel);
			}
			/* 第一点击的时候绘制线 */
			if (_self._sketchTempPoints.length === 0) {
				_self._createTempPolyline();
				_self._sketchTempPoints.push(loc.sLocation.clone());
			}
			_self._sketchTempPoints.push(loc.sLocation);
			/* 存储正式绘制点集合 */
			_self._sketchPoints.push(loc.sLocation.clone());
			/* 存储输出经纬度点集合 */
			_self._sketchOutputPoints.push(loc.gLocation);
			/* 监听输出 */
			if (options.onAdded) options.onAdded(_self._sketchPoints, _self._sketchOutputPoints);
		})
		/* 注册鼠标移动事件 */
		this._registerMouseMoveEvent(handler, function(event) {

			/* 如果运行环境是App 则禁止使用移动事件 */
			if (_self._isRuntimeApp()) return;

			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.endPosition);
			if (!Cesium.defined(loc.sLocation)) return;
			if (Cesium.defined(_self._sketchTempPolyline)) {
				_self._sketchTempPoints.pop();
				_self._sketchTempPoints.push(loc.sLocation);
				/* 监听输出 */
				if (options.onMoving) options.onMoving(loc.sLocation);
			}
		});
		/* 注册鼠标右键点击事件 */
		this._registerRightClickEvent(handler, function(event) {
			if (_self._sketchTempPoints.length > 2) {
				/* 移除正式点最有一个元素 */
				_self._sketchPoints.pop();
				/* 移除临时点倒数第二个元素 */
				_self._sketchTempPoints.splice(_self._sketchTempPoints.length - 2, 1);
				/* 如果绘制了点 则删除最后一个 */
				if (_self._isDrawPoint) {
					let lastPointEntity = _self._pointEntitys[_self._pointEntitys.length - 1];
					_self._entities.remove(lastPointEntity);
					/* 移除点实体数据中的最后一条数据 */
					_self._pointEntitys.pop();
				}
				if (options.onUndo) options.onUndo();
			}
		});
		/* 注册鼠标左键双击事件 */
		this._registerLeftDoubleClickEvent(handler, function(event) {
			/* 如果运行环境是App 则禁止使用双击结束事件 */
			if (_self._isRuntimeApp()) return;
			
			if (_self._sketchPoints.length < 2) {
				if (options.onError) options.onError('点数少于两个，禁止结束绘制！');
				return;
			}
			/* 删除临时线 */
			_self._removeEntityByObject(_self._sketchTempPolyline);
			/* 绘制正式线 */
			_self._createPolyline();
			/* 删除标记点 */
			if (!_self._isRetainDrawPoint) _self._removePointEntitys();
			/* 干掉事件句柄 释放资源*/
			_self._clearEvent(handler);
			/* 监听输出 */
			if (options.onComplete) options.onComplete(_self._sketchPoints, _self._sketchOutputPoints);
		})
	},

	/**
	 * 绘制空间线工具
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onAdded(cPoints,gPoints)] 添加回调 可选
	 * @param {Function} [options.onMoving(cPoint)] 移动回调 可选
	 * @param {Function} [options.onUndo()] 撤销回调 可选 
	 * @param {Function} [options.onComplete(cPoints,gPoints)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回到 可选
	 */
	_sketchDrawSpatialPolyline(handler, options) {
		let _self = this;
		/* 注册鼠标左键单击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;
			/* 绘制点 */
			if (_self._isDrawPoint) {
				_self._createPoint(loc.sLocation, _self._lineLabel);
			}
			/* 第一点击的时候绘制线 */
			if (_self._sketchTempPoints.length === 0) {
				_self._createTempSpatialPolyline();
				_self._sketchTempPoints.push(loc.sLocation.clone());
			}
			_self._sketchTempPoints.push(loc.sLocation);
			/* 存储正式绘制点集合 */
			_self._sketchPoints.push(loc.sLocation.clone());
			/* 存储输出经纬度点集合 */
			_self._sketchOutputPoints.push(loc.gLocation);
			/* 监听输出 */
			if (options.onAdded) options.onAdded(_self._sketchPoints, _self._sketchOutputPoints);
		})
		/* 注册鼠标移动事件 */
		this._registerMouseMoveEvent(handler, function(event) {
			/* 如果运行环境是App 则禁止使用移动事件 */
			if (_self._isRuntimeApp()) return;

			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.endPosition);
			if (!Cesium.defined(loc.sLocation)) return;
			if (Cesium.defined(_self._sketchTempSpatialPolyline)) {
				_self._sketchTempPoints.pop();
				_self._sketchTempPoints.push(loc.sLocation);
				/* 监听输出 */
				if (options.onMoving) options.onMoving(loc.sLocation);
			}
		})
		/* 注册鼠标左键双击事件 */
		this._registerLeftDoubleClickEvent(handler, function(event) {
			/* 如果运行环境是App 则禁止使用双击结束事件 */
			if (_self._isRuntimeApp()) return;
			
			if (_self._sketchPoints.length < 2) {
				if (options.onError) options.onError('绘制点少于2个，禁止结束绘制！');
				return;
			}
			/* 删除临时空间线 */
			_self._removeEntityByObject(_self._sketchTempSpatialPolyline);
			/* 绘制正式空间线 */
			_self._createSpatialPolyline();
			/* 删除标记点 */
			_self._removePointEntitys();
			/* 干掉事件句柄 释放资源*/
			_self._clearEvent(handler);
			/* 监听输出 */
			if (options.onComplete) options.onComplete(_self._sketchPoints, _self
				._sketchOutputPoints);
		})
		/* 注册鼠标右键单击事件 */
		this._registerRightClickEvent(handler, function(event) {
			if (_self._sketchTempPoints.length > 2) {
				/* 移除正式点最有一个元素 */
				_self._sketchPoints.pop();
				/* 移除临时点倒数第二个元素 */
				_self._sketchTempPoints.splice(_self._sketchTempPoints.length - 2, 1);
				if (options.onUndo) options.onUndo();
			}
		});
	},

	/**
	 * 绘制面工具
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onAdded(cPoints,gPoints)] 添加回调 可选
	 * @param {Function} [options.onMoving(cPoint)] 移动回调 可选
	 * @param {Function} [options.onUndo()] 撤销回调 可选 
	 * @param {Function} [options.onComplete(cPoints,gPoints)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回到 可选
	 */
	_sketchDrawPolygon(handler, options) {
		let _self = this;
		/* 注册鼠标左键点击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;
			/* 绘制点 */
			if (_self._isDrawPoint) {
				_self._createPoint(loc.sLocation, _self._lineLabel);
			}
			/* 当点数为0时绘制线和面 */
			if (_self._sketchTempPoints.length === 0) {
				_self._createTempPolygon();
				_self._createTempPolyline();
				_self._sketchTempPoints.push(loc.sLocation.clone());
			}
			_self._sketchTempPoints.push(loc.sLocation);
			/* 存储正式绘制点集合 */
			_self._sketchPoints.push(loc.sLocation.clone());
			/* 存储输出经纬度点集合 */
			_self._sketchOutputPoints.push(loc.gLocation);
			/* 监听输出 */
			if (options.onAdded) options.onAdded(_self._sketchPoints, _self._sketchOutputPoints);
		});
		/* 注册鼠标移动事件 */
		this._registerMouseMoveEvent(handler, function(event) {
			/* 如果运行环境是App 则禁止使用移动事件 */
			if (_self._isRuntimeApp()) return;

			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.endPosition);
			if (!Cesium.defined(loc.sLocation)) return;
			if (Cesium.defined(_self._sketchTempPolygon)) {
				_self._sketchTempPoints.pop();
				_self._sketchTempPoints.push(loc.sLocation);
				/* 监听输出 */
				if (options.onMoving) options.onMoving(loc.sLocation);
			}
		});
		/* 注册鼠标右键单击事件 */
		this._registerRightClickEvent(handler, function(event) {
			if (_self._sketchTempPoints.length > 2) {
				/* 移除正式点最有一个元素 */
				_self._sketchPoints.pop();
				/* 移除临时点倒数第二个元素 */
				_self._sketchTempPoints.splice(_self._sketchTempPoints.length - 2, 1);
				/* 如果绘制了点 则删除最后一个 */
				if (_self._isDrawPoint) {
					let lastPointEntity = _self._pointEntitys[_self._pointEntitys.length - 1];
					_self._entities.remove(lastPointEntity);
					/* 移除点实体数据中的最后一条数据 */
					_self._pointEntitys.pop();
				}
				if (options.onUndo) options.onUndo();
			}
		});
		/* 注册鼠标左键双击事件 */
		this._registerLeftDoubleClickEvent(handler, function(event) {
			/* 如果运行环境是App 则禁止使用双击结束事件 */
			if (_self._isRuntimeApp()) return;
			
			if (_self._sketchPoints.length < 3) {
				if (options.onError) options.onError('点数少于3个，禁止结束绘制！');
				return;
			}
			/* 删除临时线和面 */
			_self._removeEntityByObject(_self._sketchTempPolygon);
			_self._removeEntityByObject(_self._sketchTempPolyline);
			/* 绘制正式面 */
			_self._createPolygon();
			/* 删除标记点 */
			if (!_self._isRetainDrawPoint) _self._removePointEntitys();
			/* 干掉事件句柄 释放资源*/
			_self._clearEvent(handler);
			/* 监听输出 */
			if (options.onComplete) options.onComplete(_self._sketchPoints, _self
				._sketchOutputPoints);
		})
	},

	/**
	 * 绘制圆
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onAdded(center)] 添加回调 可选 
	 * @param {Function} [options.onComplete(center,radius)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回到 可选
	 */
	_sketchDrawCircle: function(handler, options) {
		let _self = this;
		/* 注册鼠标左键单击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;

			if (_self._sketchTempPoints.length === 0) {
				/* 绘制点 */
				if (_self._isDrawPoint) {
					_self._createPoint(loc.sLocation, '起点');
				}
				/* 添加数据 */
				_self._sketchTempPoints.push(loc.sLocation.clone());
				_self._sketchTempPoints.push(loc.sLocation); //凑数的
				/* 存储正式绘制点集合 */
				_self._sketchPoints.push(loc.sLocation.clone());
				/* 存储经纬度 */
				_self._sketchOutputPoints.push(loc.gLocation);
				/* 创建圆 */
				_self._createTempCircle(loc.sLocation);
				/* 监听输出 */
				if (options.onAdded) options.onAdded(loc.sLocation);
			} else {

				if (_self._isRuntimeApp()) {
					_self._sketchTempPoints.pop();
					_self._sketchTempPoints.push(loc.sLocation);

					let positionCenter = _self._sketchEllipseCenterPosition;
					let positionRotate = _self._sketchTempPoints[1];
					_self._ellipseOutlineCoordinates = [];
					for (let angle = 5; angle < 360;) {
						let newPosition = _self._rotatedPointByAngle(positionRotate, positionCenter, angle);
						_self._ellipseOutlineCoordinates.push(newPosition);
						angle = angle + 5;
					}
					_self._ellipseOutlineCoordinates.push(_self._ellipseOutlineCoordinates[0]);

					let point1cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[0]);
					let point2cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[1]);
					/* 计算距离 */
					let geodesic = new Cesium.EllipsoidGeodesic();
					geodesic.setEndPoints(point1cartographic, point2cartographic);
					_self._sketchEllipseRadius = geodesic.surfaceDistance;
					if (_self._sketchEllipseRadius <= 0) _self._sketchEllipseRadius = 1;

				}

				/* 删除标记点 */
				_self._removePointEntitys();
				/* 删除临时圆 */
				_self._removeEntityByObject(_self._sketchTempCircle);
				/* 创建正式圆 */
				_self._createCircle();
				/* 干掉事件句柄 释放资源*/
				_self._clearEvent(handler);
				/* 回调返回 */
				if (options.onComplete) options.onComplete(_self._sketchOutputPoints[0], _self._sketchEllipseRadius);
			}
		});
		/* 注册鼠标移动事件 */
		this._registerMouseMoveEvent(handler, function(event) {
			/* 如果运行环境是App 则禁止使用移动事件 */
			if (_self._isRuntimeApp()) return;

			/* 如果还未创建圆 则直接返回 */
			if (!Cesium.defined(_self._sketchTempCircle)) return;
			/* 获取空间位置 */
			var cartesian = _self._viewer.scene.pickPosition(event.endPosition);
			/* 如果获取点失败 则直接返回 */
			if (cartesian == undefined) return;
			_self._sketchTempPoints.pop();
			_self._sketchTempPoints.push(cartesian);
		})
	},

	/**
	 * 绘制高度线
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onAdded(cPoint)] 添加回调 可选
	 * @param {Function} [options.onMoving(cPoints,centerPoint)] 移动回调 可选
	 * @param {Function} [options.onComplete(cPoints,centerPoint)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回到 可选
	 */
	_sketchDrawHeightPolyline: function(handler, options) {
		let _self = this;
		/* 注册鼠标左键单击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;

			if (_self._sketchTempPoints.length === 0) {

				/* 绘制点 */
				if (_self._isDrawPoint) {
					_self._createPoint(loc.sLocation, '起点');
				}
				/* 赋值初始高度 */
				_self._sketchAltitudeInitHeight = loc.gLocation.height;
				/* 添加数据 */
				_self._sketchTempPoints.push(loc.sLocation.clone());
				_self._sketchTempPoints.push(loc.sLocation); //凑数的
				/* 存储正式绘制点集合 */
				_self._sketchPoints.push(loc.sLocation.clone());
				/* 监听输出 */
				if (options.onAdded) options.onAdded(loc.sLocation);
			} else {

				if (_self._isRuntimeApp()) {
					_self._sketchTempPoints.pop();
					_self._sketchTempPoints.push(loc.sLocation);

					let point1cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[0]);
					let point2cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[1]);
					_self._sketchEllipseCenterPosition = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(point1cartographic.longitude), Cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);

					_self._sketchAltitudePolylinePostions = [];
					_self._sketchAltitudePolylinePostions.push(_self._sketchTempPoints[0]);
					let point_temp = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(point1cartographic.longitude), Cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);
					_self._sketchAltitudePolylinePostions.push(point_temp);

					/* 计算距离 */
					let geodesic = new Cesium.EllipsoidGeodesic();
					geodesic.setEndPoints(point1cartographic, point2cartographic);
					_self._sketchEllipseRadius = geodesic.surfaceDistance;
					if (_self._sketchEllipseRadius <= 0) _self._sketchEllipseRadius = 1;

					let height_temp = point2cartographic.height - point1cartographic.height;
					_self._sketchEllipseHeight = height_temp + _self._sketchAltitudeInitHeight;
				}

				/* 删除标记点 */
				_self._removePointEntitys();
				/* 删除临时高度线 */
				_self._removeEntityByObject(_self._sketchTempAltituePolyline);
				/* 创建正式高度线 */
				_self._createAltitudePolyline();
				/* 干掉事件句柄 释放资源*/
				_self._clearEvent(handler);
				/* 回调返回 */
				if (options.onComplete) {
					options.onComplete(_self._sketchAltitudePolylinePostions, _self
						._sketchEllipseCenterPosition);
				}
			}
		})
		/* 注册鼠标移动事件 */
		this._registerMouseMoveEvent(handler, function(event) {

			/* 如果运行环境是App 则禁止使用移动事件 */
			if (_self._isRuntimeApp()) return;

			/* 如果还没设置起点 则直接返回 */
			if (_self._sketchTempPoints == undefined || _self._sketchTempPoints.length == 0)
				return;
			/* 获取空间位置 */
			var cartesian = _self._viewer.scene.pickPosition(event.endPosition);
			/* 如果获取点失败 则直接返回 */
			if (cartesian == undefined) return;
			if (_self._sketchTempPoints.length >= 2) {
				if (!Cesium.defined(_self._sketchTempAltituePolyline)) {
					/* 添加线 */
					_self._createTempAltitudePolyline();
				} else {
					_self._sketchTempPoints.pop();
					_self._sketchTempPoints.push(cartesian);
				}
				/* 回调返回 */
				if (options.onMoving) {
					options.onMoving(_self._sketchAltitudePolylinePostions, _self
						._sketchEllipseCenterPosition);
				}
			}
		})
	},

	/**
	 * 绘制矩形
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onAdded(cPoint)] 添加回调 可选
	 * @param {Function} [options.onComplete(points)] 完成回调 可选
	 */
	_sketchDrawRectangle: function(handler, options) {
		let _self = this;
		/* 注册鼠标左键单击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;

			if (_self._sketchTempPoints.length === 0) {
				/* 绘制点 */
				if (_self._isDrawPoint) {
					_self._createPoint(loc.sLocation, '起点');
				}
				/* 添加数据 */
				_self._sketchTempPoints.push(loc.gLocation);
				_self._sketchTempPoints.push(loc.gLocation); //凑数的
				/* 存储正式绘制点集合 */
				_self._sketchPoints.push(loc.gLocation);
				/* 创建矩形 */
				_self._createTempRectangle();
				/* 回调 */
				if (options.onAdded) options.onAdded(loc.sLocation);
			} else {

				if (_self._isRuntimeApp()) {
					_self._sketchTempPoints.pop();
					_self._sketchTempPoints.push(loc.gLocation);

					let lng0 = parseFloat(_self._sketchTempPoints[0].lng);
					let lat0 = parseFloat(_self._sketchTempPoints[0].lat);
					let lng1 = parseFloat(_self._sketchTempPoints[1].lng);
					let lat1 = parseFloat(_self._sketchTempPoints[1].lat);
					_self._rectangleCoordinates = [0, 0, 1, 1];
					if (lng0 < lng1) {
						_self._rectangleCoordinates[0] = lng0;
						_self._rectangleCoordinates[2] = lng1;
					} else {
						_self._rectangleCoordinates[0] = lng1;
						_self._rectangleCoordinates[2] = lng0;
					}
					if (lat0 < lat1) {
						_self._rectangleCoordinates[1] = lat0;
						_self._rectangleCoordinates[3] = lat1;
					} else {
						_self._rectangleCoordinates[1] = lat1;
						_self._rectangleCoordinates[3] = lat0;
					}
					let rectangle = Cesium.Rectangle.fromDegrees(_self._rectangleCoordinates[0], _self._rectangleCoordinates[1], _self._rectangleCoordinates[2], _self._rectangleCoordinates[3]);
					/* 计算并返回矩形的边界线坐标数组 */
					let res = _self._calculateRectangleOutlineCoordinates(rectangle);
					_self._rectangleOutlineCoordinates = res.cPoints;
					_self._sketchOutputPoints = res.gPoints;
				}

				/* 删除标记点 */
				_self._removePointEntitys();
				/* 删除临时矩形 */
				_self._removeEntityByObject(_self._sketchTempRectangle);
				/* 创建正式矩形 */
				_self._createRectangle();
				/* 干掉事件句柄 释放资源*/
				handler.destroy();
				handler = null;
				/* 回调返回 */
				if (options.onComplete) options.onComplete(_self._sketchOutputPoints);
			}
		});
		/* 挂接鼠标移动事件 */
		this._registerMouseMoveEvent(handler, function(event) {
			/* 如果运行环境是App 则禁止使用移动事件 */
			if (_self._isRuntimeApp()) return;

			/* 如果还未创矩形 则直接返回 */
			if (!Cesium.defined(_self._sketchTempRectangle)) return;
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.endPosition);
			if (!Cesium.defined(loc.sLocation)) return;
			_self._sketchTempPoints.pop();
			_self._sketchTempPoints.push(loc.gLocation);
		});
	},

	/**
	 * 绘制三角形
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onComplete(hCoordinates,sCoordinates,heightCoordinates,position)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回到 可选
	 */
	_sketchDrawTriangle: function(handler, options) {
		let _self = this;
		/* 挂接点击事件监听 */
		handler.setInputAction(function(event) {
			if (Cesium.defined(_self._sketchTempAltituePolyline)) return;
			/* 识别屏幕坐标位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;
			if (_self._sketchPoints.length == 0) {
				_self._createPoint(loc.sLocation, '起点');
				_self._sketchTempPoints.push(loc.sLocation.clone());
				_self._sketchTempPoints.push(loc.sLocation);
				_self._sketchPoints.push(loc.sLocation);
				/* 绘制临时线 */
				_self._createTempPolyline();
			} else if (_self._sketchPoints.length === 1) {
				_self._createPoint(loc.sLocation, '高度起点');
				/* 删除临时线 */
				_self._entities.remove(_self._sketchTempPolyline);
				_self._sketchPoints.push(loc.sLocation);
				/* 绘制正式线 */
				_self._createPolyline();
				/* 填充数据 */
				_self._sketchTempPoints.push(loc.sLocation.clone());
				_self._sketchPoints.push(loc.sLocation);
				/* 赋值三角形临时高度线椭圆的初始高度 */
				_self._sketchAltitudeInitHeight = loc.gLocation.height;
				/* 创建三角形临时高度线和空间线 */
				_self._createTempTriangleAltitudePolylineAndSpatialPolyline();
			}
		}, Cesium.ScreenSpaceEventType.LEFT_CLICK);
		/* 挂接移动事件 */
		handler.setInputAction(function(event) {
			/* 如果还未创建圆 则直接返回 */
			if (_self._sketchPoints === undefined || _self._sketchPoints.length === 0) return;
			/* 获取空间位置 */
			var cartesian = _self._viewer.scene.pickPosition(event.endPosition);
			/* 如果获取点失败 则直接返回 */
			if (cartesian == undefined) return;
			_self._sketchTempPoints.pop();
			_self._sketchTempPoints.push(cartesian);
		}, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
		/* 右键单击事件 */
		handler.setInputAction(function(event) {
			if (_self._sketchPoints.length < 2) {
				if (options.onError) options.onError('绘制图形不完整，禁止结束绘制！');
				return;
			}
			/* 删除标记点 */
			_self._removePointEntitys();
			/* 删除临时高度线及空间线 */
			_self._removeEntityByObject(_self._sketchTempTriangleAltitudePolyline);
			_self._removeEntityByObject(_self._sketchTempSpatialPolyline);
			/* 创建正式高度线及空间线 */
			_self._createAltitudePolyline();
			_self._createTriangleSpatialPolyline();
			/* 干掉事件句柄 释放资源*/
			handler.destroy();
			handler = null;
			/* 回调返回 */
			options.onComplete(_self._sketchPoints, _self
				._sketchTriangleSpatialPolylinePositions,
				_self._sketchAltitudePolylinePostions, _self
				._sketchEllipseCenterPosition);
		}, Cesium.ScreenSpaceEventType.RIGHT_CLICK);
	},

	/**
	 * 绘制面拉伸体工具
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onAdded(cPoints,gPoints)] 添加回调 可选
	 * @param {Function} [options.onMoving(cPoint)] 移动回调 可选
	 * @param {Function} [options.onUndo(cPoints)] 撤销回调 可选 
	 * @param {Function} [options.onComplete(cPoints,gPoints)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回到 可选
	 */
	_sketchDrawPolygonBody(handler, options) {
		let _self = this;
		/* 注册鼠标左键点击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;
			/* 绘制点 */
			if (_self._isDrawPoint) {
				_self._createPoint(loc.sLocation, _self._lineLabel);
			}
			/* 第一点击的时候绘制线 */
			if (_self._sketchTempPoints.length === 0) {
				_self._createTempPolygon();
				_self._createTempPolyline();
				_self._sketchTempPoints.push(loc.sLocation.clone());
			}
			_self._sketchTempPoints.push(loc.sLocation);
			/* 存储正式绘制点集合 */
			_self._sketchPoints.push(loc.sLocation.clone());
			/* 存储输出经纬度点集合 */
			_self._sketchOutputPoints.push(loc.gLocation);
			/* 监听输出 */
			if (options.onAdded) options.onAdded(_self._sketchPoints, _self._sketchOutputPoints);
		});
		/* 注册鼠标移动事件 */
		this._registerMouseMoveEvent(handler, function(event) {
			/* 如果运行环境是App 则禁止使用移动事件 */
			if (_self._isRuntimeApp()) return;

			/* 识别屏幕位置 */
			let loc = _self._transfromFromScreenPoint(event.endPosition);
			if (!Cesium.defined(loc.sLocation)) return;
			if (Cesium.defined(_self._sketchTempPolygon)) {
				_self._sketchTempPoints.pop();
				_self._sketchTempPoints.push(loc.sLocation);
				/* 监听输出 */
				if (options.onMoving) options.onMoving(loc.sLocation);
			}
		});
		/* 注册鼠标右键事件 */
		this._registerRightClickEvent(handler, function(event) {
			if (_self._sketchTempPoints.length > 2) {
				/* 移除正式点最有一个元素 */
				_self._sketchPoints.pop();
				_self._sketchOutputPoints.pop();
				/* 移除临时点倒数第二个元素 */
				_self._sketchTempPoints.splice(_self._sketchTempPoints.length - 2, 1);
				if (options.onUndo) options.onUndo(_self._sketchPoints);
			}
		});
		/* 注册鼠标左键双击事件 */
		this._registerLeftDoubleClickEvent(handler, function(event) {
			/* 如果运行环境是App 则禁止使用双击结束事件 */
			if (_self._isRuntimeApp()) return;
			
			if (_self._sketchPoints.length < 3) {
				if (options.onError) options.onError('点数少于3个，禁止结束绘制！');
				return;
			}
			/* 删除临时线和面 */
			_self._removeEntityByObject(_self._sketchTempPolygon);
			_self._removeEntityByObject(_self._sketchTempPolyline);
			/* 绘制正式体 */
			_self._createPolygonBody({
				height: 30,
				color: [255, 255, 0, 0.9],
			});
			/* 删除标记点 */
			_self._removePointEntitys();
			/* 干掉事件句柄 释放资源*/
			_self._clearEvent(handler);
			/* 监听输出 */
			if (options.onComplete) options.onComplete(_self._sketchPoints, _self
				._sketchOutputPoints);
		})
	},

	/**
	 * 另外一种方式绘制三角形
	 * @ignore
	 * @param {Object} handler 事件句柄
	 * @param {JSON} options 配置项
	 * @param {Function} [options.onMoving(cPoint)] 移动回调 可选
	 * @param {Function} [options.onComplete(positions)] 完成回调 可选
	 * @param {Function} [options.onError(message)] 错误回到 可选
	 */
	_sketchDrawTriangleA: function(handler, options) {
		let _self = this;
		/* 注册鼠标左键点击事件 */
		this._registerLeftClickEvent(handler, function(event) {
			if (Cesium.defined(_self._sketchTempAltituePolyline)) return;
			/* 识别屏幕坐标位置 */
			let loc = _self._transfromFromScreenPoint(event.position);
			if (!Cesium.defined(loc.sLocation)) return;
			if (_self._sketchPoints.length == 0) {

				/* 绘制点 */
				if (_self._isDrawPoint) {
					_self._createPoint(loc.sLocation, '起点');
				}

				_self._sketchTempPoints.push(loc.sLocation.clone());
				_self._sketchTempPoints.push(loc.sLocation);
				_self._sketchPoints.push(loc.sLocation);
				/* 绘制临时空间三角形 */
				_self._createTempSpatialTriangle();
				/* 监听输出 */
				if (options.onAdded) options.onAdded(loc.sLocation);
			} else if (_self._sketchPoints.length > 0) {

				if (_self._isRuntimeApp()) {
					_self._sketchTempPoints.pop();
					_self._sketchTempPoints.push(loc.sLocation);

					/* 为了成功绘制 需要对点数据进行处理 */
					_self._sketchSpatialTrianglePositions = [];
					_self._sketchSpatialTrianglePositions.push(_self._sketchTempPoints[0].clone());
					_self._sketchSpatialTrianglePositions.push(_self._sketchTempPoints[1].clone());
					let point1cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[0]);
					let point2cartographic = Cesium.Cartographic.fromCartesian(_self._sketchTempPoints[1]);
					let point_temp = Cesium.Cartesian3.fromDegrees(Cesium.Math.toDegrees(point1cartographic.longitude), Cesium.Math.toDegrees(point1cartographic.latitude), point2cartographic.height);
					_self._sketchSpatialTrianglePositions.push(point_temp);
					_self._sketchSpatialTrianglePositions.push(_self._sketchTempPoints[0].clone());
				}

				/* 删除绘制的点 */
				_self._removePointEntitys();
				/* 删除临时三角形 */
				_self._removeEntityByObject(_self._sketchTempSpatialTriangle);
				/* 创建正式三角形 */
				_self._createSpatialTriangle();
				/* 干掉事件句柄 释放资源*/
				_self._clearEvent(handler);
				/* 回调返回 */
				if (options.onComplete) options.onComplete(_self._sketchSpatialTrianglePositions);
			}
		});
		/* 注册鼠标移动事件 */
		this._registerMouseMoveEvent(handler, function(event) {

			/* 如果运行环境是App 则禁止使用移动事件 */
			if (_self._isRuntimeApp()) return;

			/* 如果还未创建圆 则直接返回 */
			if (_self._sketchPoints === undefined || _self._sketchPoints.length === 0) return;
			/* 获取空间位置 */
			var cartesian = _self._viewer.scene.pickPosition(event.endPosition);
			/* 如果获取点失败 则直接返回 */
			if (cartesian == undefined) return;
			_self._sketchTempPoints.pop();
			_self._sketchTempPoints.push(cartesian);
			/* 监听输出 */
			if (options.onMoving) options.onMoving(cartesian);
		});
	},

	/**
	 * 绘图工具
	 * @param {SketchViewModel.SketchType} toolsType 草图工具类型
	 * @param {JSON} options 回调集合
	 * @param {Function} [options.onAdded] 添加回调 可选 子方法自定义
	 * @param {Function} [options.onMoving] 移动回调 可选 子方法自定义
	 * @param {Function} [options.onUndo] 撤销回调 可选 子方法自定义 
	 * @param {Function} [options.onComplete] 完成回调 可选 子方法自定义
	 * @param {Function} [options.onError] 错误回调 可选 子方法自定义
	 */
	sketchTools: function(toolsType, options) {
		/* 定义自身 */
		let _self = this;
		/* 初始化 */
		this._clear();
		/* 注册事件 */
		_self._sketchEventHandler = new Cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
		/* 分类型注册事件 */
		switch (toolsType) {
			case SketchViewModel.SketchType.Point:
				_self._sketchDrawPoint(_self._sketchEventHandler, options);
				break;
			case SketchViewModel.SketchType.Line:
				_self._sketchDrawPolyline(_self._sketchEventHandler, options);
				break;
			case SketchViewModel.SketchType.Polygon:
				_self._sketchDrawPolygon(_self._sketchEventHandler, options);
				break;
			case SketchViewModel.SketchType.Height:
				_self._sketchDrawHeightPolyline(_self._sketchEventHandler, options);
				break;
			case SketchViewModel.SketchType.Spatial:
				_self._sketchDrawSpatialPolyline(_self._sketchEventHandler, options);
				break;
			case SketchViewModel.SketchType.Circle:
				_self._sketchDrawCircle(_self._sketchEventHandler, options);
				break;
			case SketchViewModel.SketchType.Rectangle:
				_self._sketchDrawRectangle(_self._sketchEventHandler, options);
				break;
			case SketchViewModel.SketchType.Triangle:
				_self._sketchDrawTriangleA(_self._sketchEventHandler, options);
				break;
			case SketchViewModel.SketchType.PolygonBody:
				_self._sketchDrawPolygonBody(_self._sketchEventHandler, options);
				break;
			case SketchViewModel.SketchType.MultiplePoint:
				_self._sketchDrawMultiplePoint(_self._sketchEventHandler, options);
				break;
		}
	},

	/**
	 * 根据坐标绘制要素
	 * @param {Array<Number>} points 点集合[lng,lat,......];
	 * @param {SketchViewModel.SketchType} type 绘制类型
	 * @param {JSON} options 回调配置
	 * @param {Function} options.onComplete() 完成回调，可选
	 * @param {Function} options.onError(message) 错误回调 
	 */
	sketchDrawFeacture: function(points, type, options) {
		let _self = this;
		if (points === undefined || points.length === undefined || points.length < 2) {
			if (options && options.onError) options.onError("输入的坐标集合异常！");
			return;
		}
		/* 转换坐标 */
		this._sketchPoints = [];
		for (let i = 0; i < points.length;) {
			this._sketchPoints.push(Cesium.Cartesian3.fromDegrees(points[i], points[i + 1], points[i + 2]));
			i = i + 3;
		}
		/* 分别判断 */
		switch (type) {
			case SketchViewModel.SketchType.DrawPoint:
				_self._createPoint(_self._sketchPoints[0], _self._lineLabel);
				if (options && options.onComplete) options.onComplete(_self._pointEntitys);
				break;
			case SketchViewModel.SketchType.DrawMultiplePoint:
				for (let i = 0; i < _self._sketchPoints.length; i++) {
					_self._createPoint(_self._sketchPoints[i], _self._lineLabel);
				}
				if (options && options.onComplete) options.onComplete(_self._pointEntitys);
				break;
			case SketchViewModel.SketchType.DrawPolyline:
				if (_self._sketchPoints.length < 2) {
					if (options && options.onError) options.onError("点数少于2个，无法绘制！");
				} else {
					_self._createPolyline();
					if (options && options.onComplete) options.onComplete(_self._sketchPolyline);
				}
				break;
			case SketchViewModel.SketchType.DrawPolygon:
				if (_self._sketchPoints.length < 3) {
					if (options && options.onError) options.onError("点数少于3个，无法绘制！");
				} else {
					_self._createPolygon();
					if (options && options.onComplete) options.onComplete(_self._sketchPolygon);
				}
				break;
			default:
				if (options && options.onError) options.onError("绘制类型异常！");
				break;
		}
	},

	/**
	 * 清理资源
	 */
	sketchClear: function() {
		this._clear(true);
		/* 干掉事件句柄 释放资源*/
		this._clearEvent(this._sketchEventHandler);
	},

	/**
	 * 初始化
	 */
	sketchInit: function() {
		this._clear(false);
	}
})

/* 编辑函数相关 */
Object.assign(SketchViewModel.prototype, {
	/**
	 * 检查颜色值
	 * @ignore
	 * @param {Number} color 颜色值[0~255]
	 * @return {Boolean} 是否满足颜色值要求
	 */
	_checkColor: function(color) {
		if (color === undefined || color === null) return false;
		if (typeof color != 'number') return false;
		let intColor = parseInt(color);
		if (intColor < 0 || intColor > 255) return false;
		return true;
	},

	/**
	 * 检查透明度是否符合要求
	 * @ignore
	 * @param {Object} alpha 透明度[0~1]
	 */
	_checkAlpha: function(alpha) {
		if (alpha === undefined || alpha === null) return false;
		if (typeof alpha != 'number') return false;
		let floatAlpha = parseFloat(alpha);
		if (floatAlpha < 0 || floatAlpha > 1) return false;
		return true;
	},

	/**
	 * 颜色和透明度检测
	 * @ignore
	 * @param {Array<Number>} colorAndAlpah 颜色和透明度
	 * @return {Array<Number>} [0~255,0~255,0~255,0~1] 如果异常 则返回undefined
	 */
	_checkColorAndAlpha: function(colorAndAlpah) {
		let setColor = undefined;
		if (!colorAndAlpah || colorAndAlpah.length === undefined || colorAndAlpah.length === 0)
			return undefined;
		if (colorAndAlpah.length === 1 && this._checkColor(colorAndAlpah[0])) {
			setColor = [colorAndAlpah[0], 0, 0, 1.0];
		} else if (colorAndAlpah.length === 2 && this._checkColor(colorAndAlpah[0]) && this._checkColor(
				colorAndAlpah[1])) {
			setColor = [colorAndAlpah[0], colorAndAlpah[1], 0, 1.0];
		} else if (colorAndAlpah.length === 3 && this._checkColor(colorAndAlpah[0]) && this._checkColor(
				colorAndAlpah[1]) && this._checkColor(colorAndAlpah[2])) {
			setColor = [colorAndAlpah[0], colorAndAlpah[1], colorAndAlpah[2], 1.0];
		} else if (colorAndAlpah.length === 4 && this._checkColor(colorAndAlpah[0]) && this._checkColor(
				colorAndAlpah[1]) && this._checkColor(colorAndAlpah[2]) && this._checkAlpha(
				colorAndAlpah[
					3])) {
			setColor = [colorAndAlpah[0], colorAndAlpah[1], colorAndAlpah[2], colorAndAlpah[3]];
		}
		return setColor;
	},

	/**
	 * 编辑选择的拉伸对象
	 * @ignore
	 * @param {JSON} options 配置项
	 * @param {Array<Number>} options.color [0~255,0~255,0~255,0~1]
	 * @param {Number} options.height 高度
	 * @param {Function} onComplete(message) 完成回调,如果message为undefined则代表成功，否则为失败消息
	 */
	sketchEditPickPolygonBody: function(options) {
		let _self = this;
		/* 获取当前选中的拉伸对象 */
		let primitive = _self._sketchPickPolygonBody;
		if (primitive === undefined) {
			if (options.onComplete) options.onComplete("未拾取对象或拾取的对象不符合要求！");
			return;
		};
		let color = primitive._useGeometry.color;
		let height = primitive._useGeometry.height;
		this._sketchPoints = primitive._useGeometry.cPoints;
		this._sketchOutputPoints = primitive._useGeometry.gPoints;
		if (options && options.height && typeof options.height === 'number') height = parseInt(options
			.height);
		if (options && options.color && this._checkColorAndAlpha(options.color)) color = this
			._checkColorAndAlpha(options.color);
		/* 删除已绘制的要素 */
		this._viewer.scene.primitives.remove(primitive);
		/* 创建新的要素 */
		this._createPolygonBody({
			color: color,
			height: height,
		});
		if (options.onComplete) options.onComplete(undefined);
	},

	/**
	 * 移除选择的拉伸实体
	 * @ignore
	 * @param {Function} onComplete(message) 完成回调，message为undifined为成功，否则为失败消息
	 */
	sketchRemovePickPolygonBody: function(onComplete) {
		let _self = this;
		/* 获取当前选中的拉伸对象 */
		let primitive = _self._sketchPickPolygonBody;
		if (primitive === undefined) {
			if (onComplete) onComplete("未拾取对象或拾取的对象不符合要求！");
			return;
		};
		/* 删除已绘制的要素 */
		this._viewer.scene.primitives.remove(primitive);
		if (onComplete) onComplete(undefined);
	},

	/**
	 * 拾取绘制的区域拉伸对象
	 * @ignore
	 * @param {Function} onComplete(options) 完成回调
	 * options.color 颜色数组
	 * options.height 高度
	 * 如果未查询到符合要求的对象或者实体 则options为undefined
	 */
	sketchPick: function(onComplete) {
		let _self = this;
		/* 创建事件句柄 */
		let handler = new Cesium.ScreenSpaceEventHandler(this._viewer.scene.canvas);
		/* 挂接点击事件监听 */
		handler.setInputAction(function(event) {
			let pickObj = _self._viewer.scene.pick(event.position);
			if (pickObj && pickObj.primitive && pickObj.primitive._useGeometry != undefined) {
				_self._sketchPickPolygonBody = pickObj.primitive;
				if (onComplete) onComplete({
					color: pickObj.primitive._useGeometry.color,
					height: pickObj.primitive._useGeometry.height,
				});
			} else {
				_self._sketchPickPolygonBody = undefined;
				if (onComplete) onComplete(undefined);
			}
			/* 干掉事件句柄 释放资源 */
			handler.destroy();
			handler = null;
		}, Cesium.ScreenSpaceEventType.LEFT_CLICK);
	}


});

/**
 * 草图工具类型
 */
SketchViewModel.SketchType = Object.freeze({
	Point: 'point',
	MultiplePoint: 'multiplePoint',
	Line: 'line',
	Polygon: 'polygon',
	Height: 'height',
	Spatial: 'spatial',
	Circle: 'circle',
	Rectangle: 'rectangle',
	Triangle: 'triangle',
	PolygonBody: 'polygonBody',
	DrawPoint: 'drawPoint',
	DrawMultiplePoint: 'drawMultiplePoint',
	DrawPolyline: 'drawPolyline',
	DrawPolygon: 'drawPolygon',
})

/**
 * 点图标类型
 */
SketchViewModel.SketchIconType = Object.freeze({
	Normal: 'normal',
	Blue: 'blue',
	Green: 'green',
	Violet: 'violter',
})

/**
 * 运行环境类型
 */
SketchViewModel.RuntimeEnvironment = Object.freeze(({
	App: 'app',
	Web: 'web'
}))

/* 输出 */
export {
	SketchViewModel
}