import { CesiumZondy } from '../core/Base';

import CommonFuncManager from './CommonFuncManager';

const optionE = {
 directions: []
};

function calculatePositionSamplesGround(positions, startTime, multiplier) {
 if (positions !== undefined) {
 if (positions.constructor === Array) {
 const property = new Cesium.SampledPositionProperty();
 for (let since = 0; since < positions.length; since += 1) {
 property.addSample(Cesium.JulianDate.addSeconds(startTime, multiplier * since, new Cesium.JulianDate()), positions[since]);
 }
 return property;
 }
 }
 return undefined;
}

function calculatePositionSamples(positions, startTime, multiplier) {
 if (positions !== undefined) {
 if (positions.constructor === Array) {
 const property = new Cesium.SampledPositionProperty();
 for (let since = 0; since < positions.length; since += 1) {
 property.addSample(Cesium.JulianDate.addSeconds(startTime, multiplier * since, new Cesium.JulianDate()), Cesium.Cartesian3.fromDegrees(positions[since][0], positions[since][1]));
 }
 return property;
 }
 }
 return undefined;
}

function getTransForm(transform, lo, la, height) {
 let position = Cesium.Cartographic.toCartesian(Cesium.Cartographic.fromDegrees(lo, la, height));
 let matrix = new Cesium.Matrix4();
 matrix = Cesium.Matrix4.inverse(transform, matrix);
 position = Cesium.Matrix4.multiplyByPoint(matrix, position, position);
 const center = new Cesium.Cartesian3(0.0, 0.0, 0.0);
 Cesium.Cartesian3.subtract(position, center, position);
 Cesium.Matrix4.fromTranslation(position, matrix);
 return matrix;
}

function SortByBoxZValue(sortGeometryList, fZmaxCod) {
 let i;
 let j;
 let tempDotStru;
 let tempFZmaxCod;
 const len = sortGeometryList.length;
 const list = sortGeometryList;
 const cod = fZmaxCod;
 for (i = 1; i < len; i += 1) {
 for (j = len - 1; j >= i; j -= 1) {
 if (cod[j] > cod[j - 1]) {
 tempFZmaxCod = cod[j - 1];
 cod[j - 1] = cod[j];
 cod[j] = tempFZmaxCod;

 tempDotStru = list[j - 1];
 list[j - 1] = list[j];
 list[j] = tempDotStru;
 }
 }
 }
 const result = {
 list,
 cod
 };
 return result;
}

function getAxis() {
 let axis = 0;
 const { direction } = optionE;
 if (direction.x === 1.0 || direction.x === -1.0) {
 axis = 1;
 } else if (direction.y === 1.0 || direction.y === -1.0) {
 axis = 2;
 } else if (direction.z === 1.0 || direction.z === -1.0) {
 axis = 3;
 }
 return axis;
}

function getDistance(children, expDistance) {
 const lTotalNum = children.length;
 let fAxisCood = 0.0;
 let fZmaxCod = [];
 const mfExpDis = expDistance;

 const axis = getAxis();
 for (let i = 0; i < children.length; i += 1) {
 const child = children[i];
 if (child === undefined) {
 return undefined;
 }
 const { boundingSphere } = child;
 switch (axis) {
 case 1:
 case -1:
 fAxisCood = boundingSphere.center.x;
 fZmaxCod[i] = fAxisCood;
 break;
 case 2:
 case -2:
 fAxisCood = boundingSphere.center.y;
 fZmaxCod[i] = fAxisCood;
 break;
 case 3:
 case -3:
 fAxisCood = boundingSphere.center.z;
 fZmaxCod[i] = fAxisCood;
 break;
 default:
 fAxisCood = boundingSphere.center.x;
 fZmaxCod[i] = fAxisCood;
 break;
 }
 }
 const sortResult = SortByBoxZValue(children, fZmaxCod);
 const childrenList = sortResult.list;
 fZmaxCod = sortResult.cod;
 const distances = [];
 for (let j = 0; j < childrenList.length; j += 1) {
 const fZTrans = (lTotalNum - j - 1) * mfExpDis;
 distances.push(fZTrans);
 }
 const result = {
 childList: childrenList,
 distances
 };
 return result;
}

function clockT() {
 const children = Cesium.defaultValue(optionE.children, undefined);
 const { isAxis } = optionE;
 if (!Cesium.defined(children)) {
 return undefined;
 }
 let distance = Cesium.defaultValue(optionE.distance, 50);
 let matrixChild;
 const { viewer } = optionE;
 optionE.deltaDistance += optionE.speed;
 if (isAxis) {
 for (let i = 0; i < children.length; i += 1) {
 const child = children[i];
 distance = optionE.distances[i];
 if (optionE.deltaDistance > distance) {
 break;
 }
 matrixChild = child.transform;
 const directionTemp = optionE.directions[i].clone();
 Cesium.Cartesian3.multiplyByScalar(directionTemp, optionE.speed, directionTemp);
 matrixChild[12] += directionTemp.x;
 matrixChild[13] += directionTemp.y;
 matrixChild[14] += directionTemp.z;
 child.transform = matrixChild.clone();
 }
 if (optionE.deltaDistance > optionE.maxDistances) {
 viewer.clock.onTick.removeEventListener(clockT);
 }
 } else {
 for (let i = 0; i < children.length; i += 1) {
 const child = children[i];
 matrixChild = child.transform;
 const directionTemp = optionE.directions[i].clone();
 Cesium.Cartesian3.multiplyByScalar(directionTemp, optionE.speed, directionTemp);
 matrixChild[12] += directionTemp.x;
 matrixChild[13] += directionTemp.y;
 matrixChild[14] += directionTemp.z;
 child.transform = matrixChild.clone();
 }
 if (optionE.deltaDistance > distance) {
 viewer.clock.onTick.removeEventListener(clockT);
 }
 }
 return undefined;
}
/**
 * @author 三维基础平台研发中心·周凌风
 * @class module:客户端可视化分析.AnalysisManager
 * @classdesc 分析功能管理类
 * @description 分析功能的创建与移除
 * @param {Object} options 分析功能管理类构造参数
 * @param {Object} options.viewer 视图
 */
export default class AnalysisManager {
 constructor(options) {
 this._viewer = Cesium.defaultValue(options.viewer, undefined);
 this._scene = this._viewer.scene;
 }

 /**
 * 视图
 * @memberof AnalysisManager.prototype
 * @type {Viewer}
 * @readonly
 */
 get viewer() {
 return this._viewer;
 }

 /**
 * 场景
 * @memberof AnalysisManager.prototype
 * @readonly
 * @type {Scene}
 */
 get scene() {
 return this._scene;
 }

 /**
 * 创建热力图
 * @function module:客户端可视化分析.AnalysisManager.prototype.createHeatMap
 * @param {Object} bounds:WGS84 bounding box {north, east, south, west}
 * @param {Number} maxValue 最大值
 * @param {Number} minValue 最小值
 * @param {Array[]} data Array<[{'x':,'y':,'value':}]>
 * @param {Object} options 原生热力图参数
 * @returns {Object} 热力图实例
 */
 createHeatMap(bounds, minValue, maxValue, data, options) {
 const heatMap = Cesium.CesiumHeatmap.create(this.viewer, bounds, options);
 heatMap.setWGS84Data(minValue, maxValue, data);
 return heatMap;
 }

 /**
 * 移除热力图
 * @function module:客户端可视化分析.AnalysisManager.prototype.removeHeatMap
 * @param {Object} heatmap 热力图对象
 */
 removeHeatMap(heatmap) {
 heatmap.removeLayer();
 this.scene.requestRender();
 }

 /**
 * 模型漫游
 * @function module:客户端可视化分析.AnalysisManager.prototype.cruiseModel
 * @param {String} modelURL 模型url
 * @param {Array[]} positionArr 漫游线路节点坐标数组 Array<[x,y]>
 * @param {Boolean} isShowPath 是否显示线路和节点
 * @param {Number} clockFrequency 漫游时钟频率
 * @returns {Array} entities 模型对象Array<entity>
 */
 cruiseModel(modelURL, positionArr, isShowPath, clockFrequency) {
 const resultEntities = [];
 const start = Cesium.JulianDate.now();
 const seconds = (positionArr.length - 1) * Cesium.defaultValue(clockFrequency, 10);
 const stop = Cesium.JulianDate.addSeconds(start, seconds, new Cesium.JulianDate());
 this.viewer.clock.startTime = start.clone();
 this.viewer.clock.stopTime = stop.clone();
 this.viewer.clock.currentTime = start.clone();
 this.viewer.clock.clockRange = Cesium.ClockRange.LOOP_STOP; // Loop at the end
 this.viewer.clock.multiplier = 10;
 for (let i = 0; i < positionArr.length; i += 1) {
 const positionT = Cesium.Cartesian3.fromDegrees(positionArr[i][0], positionArr[i][1]);
 const pntEntity = this.viewer.entities.add({
 position: positionT,
 point: {
 pixelSize: 8,
 color: Cesium.Color.TRANSPARENT,
 outlineColor: Cesium.Color.YELLOW,
 outlineWidth: 3
 },
 show: Cesium.defaultValue(isShowPath, true)
 });
 resultEntities.push(pntEntity);
 }
 const position = calculatePositionSamples(positionArr, start, clockFrequency);
 const modelEntity = this.viewer.entities.add({
 availability: new Cesium.TimeIntervalCollection([
 new Cesium.TimeInterval({
 start,
 stop
 })
 ]),
 position,
 orientation: new Cesium.VelocityOrientationProperty(position),

 model: {
 uri: modelURL,
 minimumPixelSize: 64
 },
 path: {
 resolution: 1,
 material: new Cesium.PolylineGlowMaterialProperty({
 glowPower: 0.1,
 color: Cesium.Color.YELLOW
 }),
 width: 10,
 show: Cesium.defaultValue(isShowPath, true)
 }
 });
 resultEntities.push(modelEntity);
 return resultEntities;
 }

 /**
 * 模型漫游贴地
 * @function module:客户端可视化分析.AnalysisManager.prototype.cruiseModelGround
 * @param {String} modelURL 模型路径
 * @param {Array[]} positionArr 漫游线路节点坐标数组 Array<[x,y]>
 * @param {Boolean} isShowPath 是否显示线路和节点
 * @param {Number} clockFrequency 漫游时钟频率
 * @param {Function} callback 回调函数
 * @example
 * function successCreate(entities) {
 * viewer.trackedEntity = entities[entities.length - 1];
 * };
 * let positionArr = [];
 * for (let i = 0; i <= 360; i += 45) {
 * let radians = Cesium.Math.toRadians(i);
 * positionArr.push([121.0924 + (0.03 * 1.5 * Math.cos(radians)), 23.1476 + (0.03 * Math.sin(radians))]);
 * }
 * analysisManager.cruiseModelGround('../data/donghua.gltf', positionArr, true, 10, successCreate);
 * analysisManager.startCruiseModel();
 */
 cruiseModelGround(modelURL, positionArr, isShowPath, clockFrequency, callback) {
 const resultEntities = [];
 const cartesianArr = [];
 for (let i = 0; i < positionArr.length; i += 1) {
 cartesianArr.push(Cesium.Cartesian3.fromDegrees(positionArr[i][0], positionArr[i][1]));
 }

 const numOforiPnt = positionArr.length;

 let len = 0;
 for (let j = 0; j < cartesianArr.length - 1; j += 1) {
 len += Math.sqrt((cartesianArr[j].x - cartesianArr[j + 1].x) ** 2 + (cartesianArr[j].y - cartesianArr[j + 1].y) ** 2);
 }
 const pnts = CommonFuncManager.linearInterpolate3D(cartesianArr, len / 300);

 let cartographicsArr = this._viewer.scene.globe.ellipsoid.cartesianArrayToCartographicArray(cartesianArr);
 cartographicsArr = cartographicsArr.concat(this._viewer.scene.globe.ellipsoid.cartesianArrayToCartographicArray(pnts));

 const start = Cesium.JulianDate.fromDate(new Date(2015, 2, 25, 16));
 const seconds = (positionArr.length - 1) * Cesium.defaultValue(clockFrequency, 10);
 const stop = Cesium.JulianDate.addSeconds(start, seconds, new Cesium.JulianDate());
 this.viewer.clock.startTime = start.clone();
 this.viewer.clock.stopTime = stop.clone();
 this.viewer.clock.currentTime = start.clone();
 this.viewer.clock.clockRange = Cesium.ClockRange.LOOP_STOP; // Loop at the end
 this.viewer.clock.multiplier = 10;

 Cesium.sampleTerrain(this.viewer.terrainProvider, 7, cartographicsArr).then((updatedPositions) => {
 const cartesianPositions = this.viewer.scene.globe.ellipsoid.cartographicArrayToCartesianArray(updatedPositions);
 const oriVertices = cartesianPositions.slice(0, numOforiPnt);
 const samplePoints = cartesianPositions.slice(numOforiPnt);

 for (let j = 0; j < oriVertices.length; j += 1) {
 const pntEntity = this.viewer.entities.add({
 position: oriVertices[j],
 point: {
 pixelSize: 8,
 color: Cesium.Color.TRANSPARENT,
 outlineColor: Cesium.Color.YELLOW,
 outlineWidth: 3
 },
 show: Cesium.defaultValue(isShowPath, true)
 });
 resultEntities.push(pntEntity);
 }

 const clockFrequencyTem = (clockFrequency * (oriVertices.length - 1)) / (samplePoints.length - 1);
 const position = calculatePositionSamplesGround(samplePoints, start, clockFrequencyTem);
 const modelEntity = this.viewer.entities.add({
 availability: new Cesium.TimeIntervalCollection([
 new Cesium.TimeInterval({
 start,
 stop
 })
 ]),
 position,
 orientation: new Cesium.VelocityOrientationProperty(position),
 model: {
 uri: modelURL,
 minimumPixelSize: 128
 },
 path: {
 resolution: 1,
 material: new Cesium.PolylineGlowMaterialProperty({
 glowPower: 0.1,
 color: Cesium.Color.YELLOW
 }),
 width: 10,
 show: Cesium.defaultValue(isShowPath, true)
 }
 });
 resultEntities.push(modelEntity);
 if (typeof callback === 'function') {
 callback(resultEntities);
 }
 });
 }

 /**
 * 清除模型漫游
 * @function module:客户端可视化分析.AnalysisManager.prototype.clearCruiseModel
 * @param {Object} modelEntities 模型实例
 */
 clearCruiseModel(modelEntities) {
 if (modelEntities.constructor === Array) {
 for (let i = modelEntities.length - 1; i >= 0; i -= 1) {
 this.viewer.entities.remove(modelEntities[i]);
 }
 }
 }

 /**
 * 开始模型漫游
 * @function module:客户端可视化分析.AnalysisManager.prototype.startCruiseModel
 */
 startCruiseModel() {
 this.viewer.clock.shouldAnimate = true;
 }

 /**
 * 结束模型漫游
 * @function module:客户端可视化分析.AnalysisManager.prototype.stopCruiseModel
 */
 stopCruiseModel() {
 this.viewer.clock.shouldAnimate = false;
 }

 /**
 * 开挖
 * @function module:客户端可视化分析.AnalysisManager.prototype.createExcavateAnalysis
 * @param {Object} options 开挖参数
 * @param {Object} options.tileset 图层信息
 * @param {Object} options.planes 开挖面的形状
 * @param {Object} [options.material] 裁剪面材质
 * @param {Color} [options.edgeColor] 边界线颜色
 * @param {Number} [options.edgeWidth] 边界线宽度
 * @param {Boolean} [options.unionClippingRegions] 裁减法线方向,默认值为 false
 * @param {Number} options.longitude 开挖面定位点经度
 * @param {Number} options.latitude 开挖面定位点纬度
 * @param {Number} [options.height] 开挖面定位点高度
 */
 createExcavateAnalysis(options) {
 if (!Cesium.defined(options.tileset) || !Cesium.defined(options.planes)) {
 return undefined;
 }
 const { tileset } = options;
 const { planes } = options;
 const material = Cesium.defaultValue(options.material, Cesium.Color.WHITE.withAlpha(0.02));
 const edgeColor = Cesium.defaultValue(options.edgeColor, Cesium.Color.RED);
 const edgeWidth = Cesium.defaultValue(options.edgeWidth, 0);
 const unionClippingRegions = Cesium.defaultValue(options.unionClippingRegions, false);
 const { longitude } = options;
 const { latitude } = options;
 const height = Cesium.defaultValue(options.height, 0.0);
 const { transform } = tileset._root;
 const rotation = new Cesium.Matrix3();
 Cesium.Matrix4.getMatrix3(transform, rotation);
 const scale = new Cesium.Cartesian3();
 Cesium.Matrix4.getScale(transform, scale);
 const center = new Cesium.Cartesian3();
 Cesium.Matrix4.getTranslation(transform, center);
 let modelMatrix = transform.clone();
 if (Cesium.defined(longitude) && Cesium.defined(latitude)) {
 modelMatrix = getTransForm(transform, longitude, latitude, height);
 }
 tileset.clippingPlanes = new Cesium.ClippingPlaneCollection({
 modelMatrix,
 planes,
 edgeColor,
 edgeWidth,
 unionClippingRegions
 });
 const planeEntityArray = [];
 const { radius } = tileset.boundingSphere;
 for (let i = 0; i < planes.length; i += 1) {
 const planeEntity = this.viewer.entities.add({
 position: center,
 plane: {
 dimensions: new Cesium.Cartesian2(radius * 2.5, radius * 2.5),
 material
 }
 });
 planeEntityArray.push(planeEntity);
 }
 return {
 tileset,
 planes: planeEntityArray
 };
 }

 /**
 * 开始动态开挖
 * @function module:客户端可视化分析.AnalysisManager.prototype.startDynamicExcavate
 * @param {Object} options 执行开挖参数
 * @param {Object} options.planetEntity 开挖实例
 * @param {Number} options.distance 开挖距离
 * @param {Array} options.planes 平面集
 * @param {Matrix4} options.transform 转换矩阵
 */
 startDynamicExcavate(options) {
 const { planetEntity } = options;
 const { distance } = options;
 const { planes } = options;
 const { transform } = options;
 const scratchPlane = new Cesium.ClippingPlane(Cesium.Cartesian3.UNIT_X, 0.0);
 planetEntity.plane.plane = new Cesium.CallbackProperty(() => {
 for (let i = 0; i < planes.length; i += 1) {
 if (i === planes.length - 1) {
 const plane = planes[i];
 plane.distance = distance;
 Cesium.Plane.transform(plane, transform, scratchPlane);
 }
 }
 }, false);
 this.scene.requestRender();
 }

 /**
 * 裁剪
 * @function module:客户端可视化分析.AnalysisManager.prototype.getClippingPlanes
 * @param {Array} positions
 * @returns {Array} clippingPlanes 返回裁剪面集合
 */
 getClippingPlanes(positions) {
 if (!positions) {
 return undefined;
 }
 const pointsLength = positions.length;
 if (pointsLength < 2) {
 return undefined;
 }
 const clippingPlanes = [];
 for (let i = 0; i < pointsLength; i += 1) {
 const nextIndex = (i + 1) % pointsLength;
 let midpoint = Cesium.Cartesian3.add(positions[i], positions[nextIndex], new Cesium.Cartesian3());
 midpoint = Cesium.Cartesian3.multiplyByScalar(midpoint, 0.5, midpoint);
 const up = Cesium.Cartesian3.normalize(midpoint, new Cesium.Cartesian3());
 let right = Cesium.Cartesian3.subtract(positions[nextIndex], midpoint, new Cesium.Cartesian3());
 right = Cesium.Cartesian3.normalize(right, right);
 let normal = Cesium.Cartesian3.cross(right, up, new Cesium.Cartesian3());
 normal = Cesium.Cartesian3.normalize(normal, normal);
 const originCenteredPlane = new Cesium.Plane(normal, 0.0);
 const distance = Cesium.Plane.getPointDistance(originCenteredPlane, midpoint);
 clippingPlanes.push(new Cesium.ClippingPlane(normal, distance));
 }
 this.scene.requestRender();
 return clippingPlanes;
 }

 /**
 * 动态剖切
 * @function module:客户端可视化分析.AnalysisManager.prototype.createDynamicCutting
 * @param {Object} tileset 图层集
 * @param {Array} planes 平面集
 * @param {Object} options 动态剖切参数
 * @param {Color} [options.color=Color.WHITE.withAlpha(0.5)] 材质
 * @param {Number} [options.scaleHeight=2.5] 高度缩放比
 * @param {Number} [options.scaleWidth=2.5] 宽度缩放比
 * @param {Boolean} [options.interaction] 交互
 * 
 * @returns {Object} 返回对象
 */
 createDynamicCutting(tilesets, planes, options) {
 if (!Cesium.defined(tilesets) && tilesets.length > 0) {
 return undefined;
 }
 var scaleHeight = Cesium.defaultValue(options.scaleHeight, 2.5);
 var scaleWidth = Cesium.defaultValue(options.scaleWidth, 2.5);
 let material = Cesium.Color.WHITE.withAlpha(0.5);
 let interaction = false;
 const optionsParam = Cesium.defaultValue(options, {});

 material = Cesium.defaultValue(optionsParam.color, material);
 interaction = Cesium.defaultValue(optionsParam.interaction, false);

 const that = this;
 const cutPlanes = [];
 for (let j = 0; j < tilesets.length; j += 1) {
 const tileset = tilesets[j];
 tileset.clippingPlanes = new Cesium.ClippingPlaneCollection({
 planes,
 edgeColor: Cesium.Color.RED,
 edgeWidth: 0,
 unionClippingRegions: false
 });
 const { radius } = tileset.boundingSphere;
 const { transform } = tileset._root;
 const center = new Cesium.Cartesian3();
 Cesium.Matrix4.getTranslation(transform, center);
 for (let i = 0; i < planes.length; i += 1) {
 const normal = planes[i].normal._cartesian3;
 const planeEntity = this.viewer.entities.add({
 position: Cesium.AlgorithmLib.getPointOntoPlane(center, normal, tileset.boundingSphere.center, new Cesium.Cartesian3),
 plane: {
 dimensions: new Cesium.Cartesian2(radius * scaleWidth, radius * scaleHeight),
 material
 }
 });
 cutPlanes.push(planeEntity);
 }
 }
 let selectedPlane;
 let downHandler;
 if (interaction) {
 downHandler = new Cesium.ScreenSpaceEventHandler(this.viewer.scene.canvas);
 downHandler.setInputAction((movement) => {
 const pickedObject = that.scene.pick(movement.position);
 if (Cesium.defined(pickedObject) && Cesium.defined(pickedObject.id) && Cesium.defined(pickedObject.id.plane)) {
 selectedPlane = pickedObject.id.plane;
 selectedPlane.material = Cesium.Color.WHITE.withAlpha(0.0001);
 selectedPlane.outlineColor = Cesium.Color.WHITE;
 that.scene.screenSpaceCameraController.enableInputs = false;
 }
 }, Cesium.ScreenSpaceEventType.MIDDLE_DOWN);
 downHandler.setInputAction(() => {
 if (Cesium.defined(selectedPlane)) {
 selectedPlane.material = material;
 selectedPlane.outlineColor = material;
 selectedPlane = undefined;
 }

 that.scene.screenSpaceCameraController.enableInputs = true;
 }, Cesium.ScreenSpaceEventType.MIDDLE_UP);
 }
 return {
 tilesets,
 planes: cutPlanes,
 handler: downHandler
 };
 }

 /**
 * 开始动态剖切
 * @function module:客户端可视化分析.AnalysisManager.prototype.startDynamicCutting
 * @param {Object} options 执行剖切参数
 * @param {Object} options.planetEntity 剖切实例
 * @param {Number} options.distance 距离
 * @param {Object} options.plane 平面
 * @param {Matrix4} options.transform 转换矩阵
 */
 startDynamicCutting(options) {
 const { planetEntity } = options;
 const { distance } = options;
 const { plane } = options;
 const { transform } = options;

 const scratchPlane = new Cesium.ClippingPlane(Cesium.Cartesian3.UNIT_X, 0.0);
 planetEntity.plane.plane = new Cesium.CallbackProperty(() => {
 plane.distance = distance;
 return Cesium.Plane.transform(plane, transform, scratchPlane);
 }, false);
 this.scene.requestRender();
 }

 /**
 * 移除动态剖切
 * @function module:客户端可视化分析.AnalysisManager.prototype.deleteDynamicCutting
 * @param {Object} dynaObject 动态剖切实例
 */
 deleteDynamicCutting(dynaObject) {
 if (!Cesium.defined(dynaObject)) {
 return;
 }
 const { handler } = dynaObject;
 const { planes } = dynaObject;
 let { tilesets } = dynaObject;
 if (Cesium.defined(dynaObject.tileset)) {
 if (Cesium.defined(tilesets)) {
 tilesets.push(dynaObject.tileset);
 } else {
 tilesets = [dynaObject.tileset];
 }
 }
 for (let i = 0; i < planes.length; i += 1) {
 const plane = planes[i];
 plane.distance = 0;
 this.viewer.entities.remove(plane);
 }
 if (Cesium.defined(tilesets)) {
 for (let j = 0; j < tilesets.length; j += 1) {
 const tileset = tilesets[j];
 tileset.clippingPlanes.removeAll();
 }
 }
 if (Cesium.defined(handler)) {
 handler.removeInputAction(Cesium.ScreenSpaceEventType.MIDDLE_DOWN);
 handler.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE);
 handler.removeInputAction(Cesium.ScreenSpaceEventType.MIDDLE_UP);
 }
 }

 /**
 * 卷帘
 * @function module:客户端可视化分析.AnalysisManager.prototype.createRollershutters
 * @param {Object} tileset 图层集
 * @param {Array} planeArray 用于卷帘分析的两个面
 * @param {Number} distance 平面一的距离
 * @param {Number} distance1 平面二的距离
 * @param {Object} options 剖切面材质参数
 * @param {Color} [options.color] 剖切一的颜色
 * @param {Color} [options.color1] 剖切二的颜色
 * @example
 * 调用方法
 * analysisManager.createRollershutters([tileset],distance,distance2);
 */
 createRollershutters(tileset, planeArray, distance, distance1, options) {
 const optionsParam = Cesium.defaultValue(options, {});
 const plane = Cesium.defaultValue(planeArray[0], new Cesium.ClippingPlane(new Cesium.Cartesian3(1, 0, 0), -200.0));
 const plane1 = Cesium.defaultValue(planeArray[1], new Cesium.ClippingPlane(new Cesium.Cartesian3(-1, 0, 0), -200.0));
 const dynaCut = this.createDynamicCutting(tileset, [plane], {
 color: Cesium.defaultValue(optionsParam.color, new Cesium.Color(1.0, 1.0, 1.0, 0.3))
 });
 const planetEntity = dynaCut.planes[0];
 planetEntity.plane.plane = new Cesium.CallbackProperty(() => {
 plane.distance = distance;
 return Cesium.Plane.transform(plane, tileset[0].modelMatrix, new Cesium.ClippingPlane(Cesium.Cartesian3.UNIT_X, 0.0));
 }, false);
 const dynaCut1 = this.createDynamicCutting(tileset, [plane1], {
 color: Cesium.defaultValue(optionsParam.color1, new Cesium.Color(1.0, 1.0, 1.0, 0.3))
 });
 const planetEntity1 = dynaCut1.planes[0];
 planetEntity1.plane.plane = new Cesium.CallbackProperty(() => {
 plane1.distance = distance1;
 return Cesium.Plane.transform(plane1, tileset[0].modelMatrix, new Cesium.ClippingPlane(Cesium.Cartesian3.UNIT_X, 0.0));
 }, false);
 }

 /** 高亮
 * @function module:客户端可视化分析.AnalysisManager.prototype.startCustomDisplay
 * @param {Array<layer>} layerList 图层列表
 * @param {Array<id>} idList id列表
 * @param {Object} options 扩展属性
 * @param {Color} [options.color = new Cesium.Color(1.0,0,0,0.5)] 高亮颜色
 * @param {Cesium3DTileColorBlendMode} [options.colorBlendMode = Cesium.Cesium3DTileColorBlendMode.HIGHLIGHT] 高亮模式
 * @param {Number} [options.colorBlendAmount = 0.5] 混合系数
 * @param {Boolean} [options.applyForLayer = false] 是否应用至图层
 * @param {Color} [options.negate = true] 是否取反 ——意思是除了id列表中的要素应用color
 * @param {Color} [options.negateColor = new Cesium.Color.WHITE] 取反的颜色 只有在negate=true 的时候才起作用
 * @param {String} [options.style='EdgeHighlight'] 高亮模式//'EdgeHighlight'高亮+描边 'Edge'//描边
 * @param {Color} [options.edgeColor=new Cesium.Color(0, 0, 1,1.0)] //描边颜色 默认红色
 *
 */
 startCustomDisplay(layerList, idList, options) {
 if (!Cesium.defined(layerList) || !Cesium.defined(idList)) {
 return;
 }
 const optionsParam = Cesium.defaultValue(options, {});
 const that = this;
 let colorUse = Cesium.defaultValue(optionsParam.color, new Cesium.Color(1, 0, 0, 0.5));
 const edgeColorUse = Cesium.defaultValue(optionsParam.edgeColor, new Cesium.Color(1, 0, 0, 1.0));
 const negate = Cesium.defaultValue(optionsParam.negate, false);
 const negateColor = Cesium.defaultValue(optionsParam.negateColor, Cesium.Color.WHITE);
 const applyForLayer = Cesium.defaultValue(optionsParam.applyForLayer, false);
 const style = Cesium.defaultValue(optionsParam.style, '');
 const colorBlendMode = Cesium.defaultValue(optionsParam.colorBlendMode, Cesium.Cesium3DTileColorBlendMode.HIGHLIGHT);
 const colorBlendAmount = Cesium.defaultValue(optionsParam.colorBlendAmount, 0.5);
 if (style === 'Edge' && !Cesium.defined(this._edgeDetectionStageCD)) {
 this._edgeDetectionStageCD = Cesium.PostProcessStageLibrary.createEdgeDetectionStage();
 this._edgeDetectionStageCD.uniforms.color = edgeColorUse; // Color.BLUE;
 this._edgeDetectionStageCD.uniforms.length = 0.05;
 this._edgeDetectionStageCD.selected = [];
 this._silhouetteStageCD = Cesium.PostProcessStageLibrary.createSilhouetteStage([this._edgeDetectionStageCD]);
 this.viewer.scene.postProcessStages.add(this._silhouetteStageCD);
 }

 function evaluateColorCallBack(feature, result) {
 if (feature && feature.hasProperty('name')) {
 const title = feature.getProperty('name');
 const layerNow = feature.tileset;
 const values = title.split('_');
 const vlueNumber = parseInt(values[2], 10);
 let { color } = feature;
 colorUse = layerNow.color;
 if (style === 'EdgeHighlight' || style === 'Edge') {
 if (!Cesium.defined(layerNow._edgeDetectionfeatureList)) {
 layerNow._edgeDetectionfeatureList = [];
 }
 if (title !== undefined && title !== null && idList.indexOf(vlueNumber) > -1) {
 if (layerNow._edgeDetectionfeatureList.indexOf(feature) < 0) {
 layerNow._edgeDetectionfeatureList.push(feature);
 }
 that._edgeDetectionStageCD.selected = layerNow._edgeDetectionfeatureList;
 }
 if (style === 'Edge') {
 return color;
 }
 }
 if (applyForLayer) {
 color = colorUse;
 } else if (!layerNow.negate) {
 if (title !== undefined && title !== null && idList.indexOf(vlueNumber) > -1) {
 color = colorUse;
 } else {
 color = negateColor;
 }
 } else if (title !== undefined && title !== null && idList.indexOf(vlueNumber) > -1) {
 color = negateColor;
 } else {
 color = colorUse;
 }
 return Cesium.Color.clone(color, result);
 } else {
 return colorUse;
 }
 }
 for (let i = 0; i < layerList.length; i += 1) {
 const layer = layerList[i];
 layer.negate = negate;
 layer.color = colorUse;
 layer.colorBlendMode = colorBlendMode;
 layer.colorBlendAmount = colorBlendAmount;
 layer.style = new Cesium.Cesium3DTileStyle();
 layer.style.color = {
 evaluateColor: evaluateColorCallBack
 };
 }
 }

 /**
 * 停止全部高亮
 * @function module:客户端可视化分析.AnalysisManager.prototype.stopCustomDisplay
 * @param {Array<layer>} layerList 图层列表
 */
 stopCustomDisplay(layerList) {
 if (!Cesium.defined(layerList)) {
 return;
 }
 for (let i = 0; i < layerList.length; i += 1) {
 const tileset = layerList[i];
 tileset.style = undefined;
 }
 if (Cesium.defined(this._edgeDetectionStageCD) && Cesium.defined(this._silhouetteStageCD)) {
 this.viewer.scene.postProcessStages.remove(this._silhouetteStageCD);
 this._edgeDetectionStageCD = undefined;
 this._silhouetteStageCD.destroy();
 this._silhouetteStageCD = undefined;
 }
 this.viewer.scene.render();
 }

 /**
 * 根据id停止高亮
 * @function module:客户端可视化分析.AnalysisManager.prototype.stopCustomDisplayByIds
 * @param {Array<layer>} layerList 图层列表
 * @param {Array<id>} idList ID列表
 */
 stopCustomDisplayByIds(layerList, idList) {
 if (!Cesium.defined(layerList) || !Cesium.defined(idList)) {
 return;
 }
 const that = this;

 function evaluateColorCallBack(feature, result) {
 const title = feature.getProperty('name');
 const values = title.split('_');
 const layerNow = feature.tileset;
 const vlueNumber = parseInt(values[2], 10);
 let { color } = feature;
 if (title !== undefined && title !== null && idList.indexOf(vlueNumber) > -1 && layerNow._edgeDetectionfeatureList) {
 const feIndex = layerNow._edgeDetectionfeatureList.indexOf(feature);
 if (feIndex > -1) {
 layerNow._edgeDetectionfeatureList.splice(feIndex, 1);
 that._edgeDetectionStageCD.selected = layerNow._edgeDetectionfeatureList;
 }
 color = Cesium.Color.WHITE;
 }
 return Cesium.Color.clone(color, result);
 }

 for (let i = 0; i < layerList.length; i += 1) {
 const tileset = layerList[i];
 tileset.style = new Cesium.Cesium3DTileStyle();
 tileset.style.color = {
 evaluateColor: evaluateColorCallBack
 };
 }
 }

 /** 模型爆炸动画版
 * @function module:客户端可视化分析.AnalysisManager.prototype.createExplosion
 * @param {Object} options 爆炸参数
 * @param {Array<child>} options.children 当前图层子节点,如果为空则返回undefined
 * @param {Cartesian3} options.center 爆炸中心中心
 * @param {Cartesian3} [options.direction] 图层整体爆炸方向,默认值为 Cartesian3(1.0, 0.0, 0.0)
 * @param {Number} [options.distance] 沿当前方向移动距离,默认值为 50
 * */
 createExplosion(options) {
 optionE.children = Cesium.defaultValue(options.children, undefined);
 if (!Cesium.defined(optionE.children)) {
 return undefined;
 }
 optionE.center = Cesium.defaultValue(options.center, undefined);
 optionE.direction = Cesium.defaultValue(options.direction, new Cesium.Cartesian3(0.0, 0.0, 1.0));
 optionE.distance = Cesium.defaultValue(options.distance, 50);
 optionE.scene = this.scene;
 optionE.viewer = this.viewer;
 optionE.deltaDistance = Cesium.defaultValue(options.speed, 1);
 optionE.directions = [];
 optionE.distancesCenterPoint = [];
 optionE.speed = Cesium.defaultValue(options.speed, 1);
 const isAxis = Cesium.defaultValue(options.isAxis, false);
 optionE.isAxis = Cesium.defaultValue(options.isAxis, false);
 const expDistance = Cesium.defaultValue(options.expDistance, 100);
 optionE.expDistance = Cesium.defaultValue(options.expDistance, 100);
 const { transform } = options;
 optionE.transform = options.transform;

 const direction = optionE.direction.clone();
 const originPoint = new Cesium.Cartesian3(0, 0, 0);
 const directionPoint = direction;
 for (let i = 0; i < optionE.children.length; i += 1) {
 const child = optionE.children[i];
 if (Cesium.defined(optionE.center)) {
 const childCenter = child.boundingSphere.center;
 Cesium.Cartesian3.subtract(childCenter, optionE.center, direction);
 const length = Cesium.Cartesian3.magnitude(direction);
 if (length < 1.0e-10) {
 direction.x = 1.0;
 }
 Cesium.Cartesian3.normalize(direction, direction);
 optionE.directions.push(direction.clone());
 }
 }
 if (isAxis) {
 Cesium.Matrix4.multiplyByPoint(transform, originPoint, originPoint);
 Cesium.Matrix4.multiplyByPoint(transform, directionPoint, directionPoint);
 Cesium.Cartesian3.subtract(directionPoint, originPoint, direction);
 const length = Cesium.Cartesian3.magnitude(direction);
 if (length < 1.0e-10) {
 direction.x = 1.0;
 }
 Cesium.Cartesian3.normalize(direction, direction);
 for (let i = 0; i < optionE.children.length; i += 1) {
 optionE.directions.push(direction.clone());
 }
 const result = getDistance(optionE.children, expDistance);
 optionE.children = result.childList;
 optionE.distances = result.distances;
 const temp = result.distances[0];
 optionE.maxDistances = temp;
 this.viewer.clock.onTick.addEventListener(clockT);
 } else {
 this.viewer.clock.onTick.addEventListener(clockT);
 }
 this.scene.requestRender();
 return undefined;
 }

 /**
 * 模型爆炸无动画版
 * @function module:客户端可视化分析.AnalysisManager.prototype.createExplosion1
 * @param {Object} options 爆炸参数
 * @param {Array<child>} options.children 当前图层子节点,如果为空则返回undefined
 * @param {Cartesian3} options.center 包围盒中心点
 * @param {Cartesian3} [options.direction] 子节点爆炸方向
 * @param {Number} [options.distance] 子节点爆炸距离
 * @param {Boolean} [options.isAxis] 是否执行轴向爆炸,默认为false中心点爆炸,为true时轴向爆炸
 * @param {Number} [options.expDistance] 爆炸移动距离基数
 */
 createExplosion1(options) {
 let children = Cesium.defaultValue(options.children, undefined);
 if (!Cesium.defined(children)) {
 return undefined;
 }
 const center = Cesium.defaultValue(options.center, undefined);
 let direction = Cesium.defaultValue(options.direction, new Cesium.Cartesian3(0.0, 0.0, 1.0));
 const distance = Cesium.defaultValue(options.distance, 50);
 const isAxis = Cesium.defaultValue(options.isAxis, false);
 const expDistance = Cesium.defaultValue(options.expDistance, 100);
 const { scene } = this;

 const matrixChild = new Cesium.Matrix4();
 if (isAxis === false) {
 for (let i = 0; i < children.length; i += 1) {
 const child = children[i];
 if (Cesium.defined(center)) {
 const childCenter = child.boundingSphere.center;
 Cesium.Cartesian3.subtract(center, childCenter, direction);
 const length = Cesium.Cartesian3.magnitude(direction);
 if (length < 1.0e-10) {
 direction.x = 1.0;
 }
 }
 Cesium.Cartesian3.normalize(direction, direction);
 optionE.directions.push(direction.clone());
 Cesium.Cartesian3.multiplyByScalar(direction, distance, direction);
 Cesium.Matrix4.fromTranslation(direction, matrixChild);
 child.transform = matrixChild.clone();
 }
 }
 if (isAxis) {
 const transform = Cesium.defaultValue(options.transform);
 if (transform === undefined) {
 return undefined;
 }
 const originPoint = new Cesium.Cartesian3(0, 0, 0);
 const directionPoint = direction.clone();
 Cesium.Matrix4.multiplyByPoint(transform, originPoint, originPoint);
 Cesium.Matrix4.multiplyByPoint(transform, directionPoint, directionPoint);
 Cesium.Cartesian3.subtract(directionPoint, originPoint, direction);
 const length = Cesium.Cartesian3.magnitude(direction);
 if (length < 1.0e-10) {
 direction.x = 1.0;
 }
 Cesium.Cartesian3.normalize(direction, direction);
 optionE.direction = direction.clone();
 const result = getDistance(children, expDistance);
 children = result.childList;
 const { distances } = result;
 const tempDirection = direction.clone();
 for (let i = 0; i < children.length; i += 1) {
 const child = children[i];
 Cesium.Cartesian3.multiplyByScalar(direction, distances[i], direction);
 Cesium.Matrix4.fromTranslation(direction, matrixChild);
 direction = tempDirection.clone();
 child.transform = matrixChild.clone();
 }
 }
 scene.requestRender();
 return undefined;
 }

 /**
 * 移除爆炸
 * @function module:客户端可视化分析.AnalysisManager.prototype.recoverExplosion
 * @param {Object} options 移除爆炸参数
 * @param {Array<child>} options.children 当前图层子节点,如果为空则返回undefined
 */
 recoverExplosion(options) {
 const children = Cesium.defaultValue(options.children, undefined);
 if (!Cesium.defined(children)) {
 return undefined;
 }
 const matrixChild = new Cesium.Matrix4();
 if (optionE.direction) {
 const direction = optionE.direction.clone();
 if (direction.x !== 0 || direction.x !== 0.0) {
 direction.x *= -1.0;
 } else if (direction.y !== 0 || direction.y !== 0.0) {
 direction.y *= -1.0;
 } else if (direction.z !== 0 || direction.z !== 0.0) {
 direction.z *= -1.0;
 }
 for (let i = 0; i < children.length; i += 1) {
 const child = children[i];
 Cesium.Matrix4.fromTranslation(direction, matrixChild);
 child.transform = matrixChild.clone();
 }
 } else if (optionE.directions) {
 for (let i = 0; i < children.length; i += 1) {
 const direction = optionE.directions[i].clone();
 direction.x *= -1.0;
 direction.y *= -1.0;
 direction.z *= -1.0;

 const child = children[i];
 Cesium.Matrix4.fromTranslation(direction, matrixChild);
 child.transform = matrixChild.clone();
 }
 }
 this.scene.requestRender();
 return undefined;
 }

 /**
 * 添加场景特效
 * @function module:客户端可视化分析.AnalysisManager.prototype.addSceneEffect
 * @param {Object} effect 场景特效实例
 * @see https://cesium.com/docs/cesiumjs-ref-doc/PostProcessStage.html
 * @see https://cesium.com/docs/cesiumjs-ref-doc/PostProcessStageComposite.html
 */
 addSceneEffect(effect) {
 if (Cesium.defined(effect)) {
 return this.scene.postProcessStages.add(effect._effect);
 }
 return undefined;
 }

 /**
 * 移除场景特效
 * @function module:客户端可视化分析.AnalysisManager.prototype.removeSceneEffect
 * @param {Object} effect 场景特效实例
 */
 removeSceneEffect(effect) {
 if (Cesium.defined(effect)) {
 this.scene.postProcessStages.remove(effect._effect);
 }
 }

 /**
 * 移除全部场景特效
 * @function module:客户端可视化分析.AnalysisManager.prototype.removeAllSceneEffect
 */
 removeAllSceneEffect() {
 this.scene.postProcessStages.removeAll();
 }
}

CesiumZondy.Manager.AnalysisManager = AnalysisManager;