效果
通视分析是指以某一点为观察点，研究某一区域通视情况的地形分析。

通过cesium提供的碰撞检测api获取障碍点实现同时分析

通视分析代码

import PointDrawer from '../../BaseTool/Draw/DrawPoint';
import LineDrawer from '../../BaseTool/Draw/DrawLine';
import Coordinate from '../../BaseTool/Coordinate';
import Cesium from 'Cesium'
export default class InterAnalysis {
    // viewer: any;
    // interAnalysis_map: Map<Symbol, any>;
    // lineEntities: any = [];
    // pointEntities: any[] = [];

constructor(viewer) {
    this.viewer = viewer;
    this.interAnalysis_map = new Map();
    this.pointEntities = [];
    this.lineEntities = [];
}

create(sPoint, ePoint, objId) {
    debugger
    if (ePoint.x === sPoint.x && ePoint.y === sPoint.y && ePoint.z === sPoint.z) {
        this.pointEntities.push(PointDrawer.draw(this.viewer, sPoint, 10, Cesium.Color.AQUAMARINE));
        console.warn('通视起点与终点重叠');
        return;
    }

    this.pointEntities.push(PointDrawer.draw(this.viewer, sPoint, 10, Cesium.Color.AQUAMARINE));
    this.pointEntities.push(PointDrawer.draw(this.viewer, ePoint, 10, Cesium.Color.AQUAMARINE));

    let obj = this.drawVisibility(sPoint, ePoint).then((obstaclePoint) => {
        //获取视觉障碍点, 绘制线段
        if (!obstaclePoint) {
            obstaclePoint = ePoint;
            debugger
            return;
        }
        this.lineEntities.push(LineDrawer.draw(this.viewer, [sPoint, obstaclePoint], Cesium.Color.GREEN));
        this.lineEntities.push(LineDrawer.draw(this.viewer, [obstaclePoint, ePoint], Cesium.Color.RED));
    });

    this.interAnalysis_map.set(objId, obj);
}

//绘制通视线
drawVisibility(sPoint, ePoint) {
    var promise = Cesium.when.defer();
    var removePreRenderListener = this.viewer.scene.postUpdate.addEventListener(() => {
        //设置相机
        var curCamera = this.setCameraPositoion(sPoint, ePoint);

        var removePostRenderListener = this.viewer.scene.postRender.addEventListener(() => {
            //取点
            var obstaclePoint = this.getObstaclePoint(ePoint);
            //重置相机
            this.resetCamera(curCamera);

            removePreRenderListener();

            var removeOverlayListener = this.viewer.scene.postRender.addEventListener(function() {
                removeOverlayListener();
            });
            promise.resolve(obstaclePoint);
            removePostRenderListener();
        });
    });

    return promise;
}

//设置相机位置
setCameraPositoion(sPoint, ePoint) {
    let curCamera = {
        positon: this.viewer.camera.position.clone(),
        direction: this.viewer.camera.direction.clone(),
        up: this.viewer.camera.up.clone()
    };
    let direction = this.calculateDirection(sPoint, ePoint);
    let location = Coordinate.cartesian2lonlat(sPoint);
    let position1 = Cesium.Cartesian3.fromDegrees(location.longitude, location.latitude, location.height + 0.1);
    this.viewer.camera.setView({
        destination: position1,
        orientation: {
            direction: direction,
            up: this.viewer.camera.up.clone()
        }
    });
    return curCamera;
}

//获取障碍点
getObstaclePoint(ePoint) {
    let screenLocation = this.viewer.scene.cartesianToCanvasCoordinates(ePoint);

    if (!screenLocation) {
        console.warn('获取屏幕坐标失败');
        return ePoint;
    }
    let obstaclePoint = this.viewer.scene.pickPosition(screenLocation);
    return obstaclePoint;
}

//重置相机
resetCamera(camera) {
    this.viewer.camera.setView({
        destination: camera.positon,
        orientation: {
            direction: camera.direction,
            up: camera.up
        }
    });
}

//计算方向
calculateDirection(p1, p2) {
    return Cesium.Cartesian3.normalize(
        Cesium.Cartesian3.subtract(p2, p1, new Cesium.Cartesian3()),
        new Cesium.Cartesian3()
    );
}

//清除绘制
clearDraw() {
    if (this.pointEntities.length > 0) {
        for (let i = 0; i < this.pointEntities.length ; i++) {
            this.viewer.entities.removeById(this.pointEntities[i].id);
        }
    }
    if (this.lineEntities.length > 0) {
        for (let _i = 0; _i < this.lineEntities.length; _i++) {
            this.viewer.entities.removeById(this.lineEntities[_i].id);
        }
    }
}
}

坐标辅助

/*
 * @FileName: Coordinate
 * @Description: 坐标辅助
 */
import Cesium from 'Cesium'

export default class CoordinateHelper {
    //笛卡尔转经纬高
    static cartesian2lonlat(cartesian, ellipsoid) {
        let cartographic = Cesium.Cartographic.fromCartesian(cartesian, ellipsoid);
        return {
            longitude: Cesium.Math.toDegrees(cartographic.longitude), //经度
            latitude: Cesium.Math.toDegrees(cartographic.latitude), //纬度
            height: cartographic.height //高度
        };
    }
    //经纬高转世界坐标
    static lonlat2cartesian(lon, lat, height) {
        return Cesium.Cartesian3.fromDegrees(lon, lat, height);
    }
    //世界坐标下提升高度
    static addHieght_cartesian(cartesian, height) {
        let tempCoord = this.cartesian2lonlat(cartesian);
        tempCoord.height += height;
        let car = this.lonlat2cartesian(tempCoord.longitude, tempCoord.latitude, tempCoord.height);
        return car;
    }
    //世界坐标下设置高度
    static setHieght_cartesian(cartesian, height) {
        let tempCoord = this.cartesian2lonlat(cartesian);
        tempCoord.height = height;
        let car = this.lonlat2cartesian(tempCoord.longitude, tempCoord.latitude, tempCoord.height);
        return car;
    }
    /**
     * 计算及经纬度之间的距离
     */
    static catchDistancefromCartographic2D(longitude1, latitude1, longitude2, latitude2) {
        let p1 = Cesium.Cartesian3.fromDegrees(longitude1, latitude1, 0);
        let p2 = Cesium.Cartesian3.fromDegrees(longitude2, latitude2, 0);
        let res = Cesium.Cartesian3.distance(p1, p2);
        return res;
    }
    //将传入的点设置为同一高度
    static decreaseHeight(cartesianArray) {
		let minHeight;
		let lonAndLatArray = cartesianArray.map((value) => {
				var coor = this.cartesian2lonlat(value);
				minHeight = !minHeight ? coor.height : minHeight > coor.height ? coor.height : minHeight;
				return coor;
			}
		);
		return lonAndLatArray.map(function(value){
			return Cesium.Cartesian3.fromDegrees(value.longitude,value.latitude,minHeight);
		});
    }
    //将传入的点顺时针排序  返回排序后的下标数组
    static clockwiseSort(array){
		let rightArray = [];
		let leftArray = [];
		let resArray = [];
		let centerPoint = {x:0,y:0};
		array.forEach(function (value) {
			centerPoint.x += value.x;
			centerPoint.y += value.y;
		});
		centerPoint.x = centerPoint.x / array.length;
		centerPoint.y = centerPoint.y / array.length;
		array.forEach(function (value,index) {
			if(value.x < centerPoint.x){
				leftArray.push({value:value,idx:index})
			}else{
				rightArray.push({value:value,idx:index})
			}
		});
		for(var i = 0; i < rightArray.length; i++){
			for(var j = i; j < rightArray.length; j++){
				if(rightArray[j].value.y < rightArray[i].value.y){
					var temp = {
						value : rightArray[j].value,
						idx : rightArray[j].idx
					};
					rightArray[j] = {
						value : rightArray[i].value,
						idx : rightArray[i].idx
					};
					rightArray[i] = temp
				}
			}
		}
		for(var m = 0; m < leftArray.length; m++){
			for(var n = m; n < leftArray.length; n++){
				if(leftArray[n].value.y > leftArray[m].value.y){
					var s_temp = {
						value : leftArray[n].value,
						idx : leftArray[n].idx
					};
					leftArray[n] = {
						value : leftArray[m].value,
						idx : leftArray[m].idx
					};
					leftArray[m] = s_temp;
				}
			}
		}
		rightArray.forEach(function (value) {
			resArray.push(value.idx);
		});
		leftArray.forEach(function (value) {
			resArray.push(value.idx)
		});
		return resArray;
	};
}

绘制各种类型的点

/*
 * @FileName: DrawPointWidget
 * @Description: 绘制各种类型的点
 */

// import * as _ from 'lodash';
import Cesium from 'Cesium'

export default class DrawPoint {
    static draw(viewer, position, size, color, id) {
        if (position instanceof Array) {
            position = Cesium.Cartesian3.fromDegrees(position[0], position[1], position[2] ? position[2] : 0);
        }
        let options = {
            position: position,
            point: {
                pixelSize: size,
                color: color
            }
        };
        if (id) {
            options = _.merge(options, {
                id: id
            });
        }
        return viewer.entities.add(options);
    }
}

绘制各种类型的线

/*
 * @FileName: DrawPointWidget
 * @Description: 绘制各种类型的线
 */

import Cesium from 'Cesium'

export default class LineDrawer {
    static draw(viewer, positons, color, depthColor) {
        return viewer.entities.add({
            polyline: {
                positions: positons,
                width: 2,
                material: new Cesium.PolylineOutlineMaterialProperty({
                    color: color || Cesium.Color.GREEN,
                    outlineWidth: 1,
                    outlineColor: color || Cesium.Color.GREEN
                }),
                depthFailMaterial: depthColor
                    ? new Cesium.PolylineOutlineMaterialProperty({
                          color: depthColor,
                          outlineWidth: 0,
                          outlineColor: depthColor
                      })
                    : undefined
            }
        });
    }
}