内容修改

shuishen

2022-04-29 4f55f7d94198eca8eba9ae6b85af19a07cac2f79

 src/components/map/components/dimension.vue

@@ -1,42 +1,12 @@
<template>
    <div class="dimension-cut">
        <!-- <el-button type="primary">{{zoomValue}}</el-button> -->

        <el-button
            v-show="btnGroupShow"
            size="mini"
            class="three-stm"
            type="primary"
            @click="locationSTM"
        >s3m</el-button>

        <el-button
            v-show="btnGroupShow"
            size="mini"
            class="sat-stm"
            type="primary"
            @click="locationSAT"
        >科技</el-button>

        <el-button
            v-show="btnGroupShow"
            size="mini"
            class="sat-tc"
            type="primary"
            @click="locationTC"
        >热力图</el-button>

        <el-checkbox
            v-show="btnGroupShow"
            size="mini"
            class="sat-qx"
            v-model="qxChange"
            label="倾斜数据"
            @change="qxChangeEvent"
            border
        ></el-checkbox>

        <el-radio-group v-model="dimensionValue" size="medium" @change="dimensionChange">
        <el-radio-group
            v-model="dimensionValue"
            size="medium"
            @change="dimensionChange"
            ref="StateChange"
        >
            <el-radio-button label="三 维"></el-radio-button>
            <el-radio-button label="真三维"></el-radio-button>
        </el-radio-group>
@@ -50,6 +20,8 @@
import baseLayerImgUrl from '@/assets/baseUrl'

let baseLayer = []

var baseLayers = []

let tilesetLayer = null

@@ -68,24 +40,11 @@

let select = null

let streenMlayer = null

let layerSat = null
let layerSATtwo = null
let tcLayer = null

// let viewerHeight = 950
// let smallViewerHeight = 1950

// const mixVH = 500
// const maxVH = 950
// const oneVH = 500
// const twoVH = 650
// const fourVH = 800
// const fiveVH = 950
let yxLayer = null
let dxLayer = null

let viewerHeight = 700
let smallViewerHeight = 1700
let heightChange = 700

const mixVH = 150
const maxVH = 700
@@ -95,15 +54,15 @@
const fourVH = 500
const fiveVH = 700

const heightDifferenceValue = 100

// const wallLayer = null

export default {
    name: 'dimension',
    data () {
        return {
            qxChange: false,
            zoomValue: 0,
            btnGroupShow: false,
            dimensionValue: '三 维',
            // 建筑2.5D地图
            // 建筑2.5D面数据
@@ -138,8 +97,8 @@
                [114.03954722, 27.62819644, 100],
                [114.04006133, 27.628038, 100]
            ],
            mapCenter: [114.03928009,
                27.63018386, 700]
            mapCenter: [114.03928435,
                27.62997062, 700]
            // mapCenter: [116.35559028,
            //     27.96548051, 5000]
            // mapCenter: [115.871863, 28.743861, 950.0]
@@ -162,12 +121,56 @@
            color: null
        }
    },
    mounted () {
        const that = this
        this.$EventBus.$on('stateChange', () => {
            if (that.dimensionValue != '真三维') {
                that.dimensionValue = '真三维'
                that.dimensionChange()
            }
        })

        this.$EventBus.$on('chinaDx', (paras) => {
            if (paras == 'add') {
                if (dxLayer == null) {
                    dxLayer = global.DC.TerrainFactory.createUrlTerrain({
                        url: 'http://data.marsgis.cn/terrain'
                    })
                    global.viewer.addTerrain(dxLayer)
                }
            } else {
                global.viewer.removeTerrain(dxLayer)
                dxLayer = null
            }
        })

        this.$EventBus.$on('mxOrQx', (paras) => {
            that.qxChangeEvent(paras)
        })
    },
    watch: {
        viewerExist: {
            immediate: true,
            handler (newCode, oldCode) {
                if (this.titlesetLayerFlag == false && newCode == true) {
                    var that = this

                    baseLayerImgUrl.forEach(item => {
                        var obj = {}
                        obj[Object.keys(item)[0]] = []
                        Object.values(item)[0].forEach(citem => {
                            var layer = new global.DC.Namespace.Cesium.SingleTileImageryProvider({
                                url: citem.url,
                                rectangle: global.DC.Namespace.Cesium.Rectangle.fromDegrees(citem.rectangle[0], citem.rectangle[1], citem.rectangle[2], citem.rectangle[3])
                            })
                            obj[Object.keys(item)[0]].push({ layer, id: citem.id + Object.keys(item)[0], rectangle: citem.rectangle })
                        })
                        baseLayers.push(obj)
                    })

                    global.viewer.imageryLayers.addImageryProvider(new global.DC.Namespace.Cesium.SingleTileImageryProvider({
                        url: '/img/bg/map.jpg'
                    }))

                    silhouetteBlue =
                        global.DC.Namespace.Cesium.PostProcessStageLibrary.createEdgeDetectionStage()
@@ -182,29 +185,9 @@
                        )
                    )

                    global.viewer.imageryLayers.addImageryProvider(
                        new global.DC.Namespace.Cesium.UrlTemplateImageryProvider({
                            url: 'http://t{s}.tianditu.gov.cn/DataServer?T=vec_w&x={x}&y={y}&l={z}&tk=9ae78c51a0a28f06444d541148496e36',
                            subdomains: ['0', '1', '2', '3', '4', '5', '6', '7'],
                            format: 'image/jpeg',
                            show: true,
                            maximumLevel: 18
                        })
                    )

                    global.viewer.imageryLayers.addImageryProvider(
                        new global.DC.Namespace.Cesium.UrlTemplateImageryProvider({
                            url: 'http://t{s}.tianditu.gov.cn/DataServer?T=cva_w&x={x}&y={y}&l={z}&tk=9ae78c51a0a28f06444d541148496e36',
                            subdomains: ['0', '1', '2', '3', '4', '5', '6', '7'],
                            format: 'image/jpeg',
                            show: true,
                            maximumLevel: 18
                        })
                    )

                    // global.viewer.imageryLayers.addImageryProvider(
                    //     new global.DC.Namespace.Cesium.WebMapTileServiceImageryProvider({
                    //         url: ' http://t1.tianditu.gov.cn/vec_w/wmts?tk=9ae78c51a0a28f06444d541148496e36',
                    //         url: ' http://t1.tianditu.gov.cn/vec_w/wmts?tk=e9533f5acb2ac470b07f406a4d24b4f0',
                    //         type: 'wmts',
                    //         layer: 'vec',
                    //         style: 'default',
@@ -217,7 +200,7 @@

                    // global.viewer.imageryLayers.addImageryProvider(
                    //     new global.DC.Namespace.Cesium.WebMapTileServiceImageryProvider({
                    //         url: ' http://t1.tianditu.gov.cn/cva_w/wmts?tk=9ae78c51a0a28f06444d541148496e36',
                    //         url: ' http://t1.tianditu.gov.cn/cva_w/wmts?tk=e9533f5acb2ac470b07f406a4d24b4f0',
                    //         type: 'wmts',
                    //         layer: 'cva',
                    //         style: 'default',
@@ -227,24 +210,6 @@
                    //         maximumLevel: 18
                    //     })
                    // )

                    const videoLayer = new global.DC.CameraVideoLayer('video-layer').addTo(
                        global.viewer
                    )

                    const cameraVideo = new global.DC.CameraVideo(
                        new global.DC.Position(114.03935976, 27.62939045, 100.25, 4.2, -90),
                        document.getElementById('video')
                    )
                    cameraVideo.setStyle({
                        fov: 30,
                        far: 120,
                        near: 1,
                        aspectRatio: 1.3,
                        alpha: 0.7
                    })

                    videoLayer.addOverlay(cameraVideo)

                    // baseMapLayer =
                    //     global.viewer.imageryLayers.addImageryProvider(new global.DC.Namespace.Cesium.UrlTemplateImageryProvider({
@@ -353,7 +318,6 @@
                    //         }
                    //     })
                    // }, 400)
                    that.titlesetLayerFlag = true

                    global.viewer.camera.setView({
                        // Cesium的坐标是以地心为原点，一向指向南美洲，一向指向亚洲，一向指向北极州
@@ -371,7 +335,6 @@
                            roll: 0.0
                        }
                    })

                    // 最小
                    global.viewer.scene.screenSpaceCameraController.minimumZoomDistance = mixVH
                    global.eagleViewer.scene.screenSpaceCameraController.minimumZoomDistance = mixVH + 1000
@@ -380,10 +343,10 @@
                    global.eagleViewer.scene.screenSpaceCameraController.maximumZoomDistance = maxVH + 1000

                    // 设置相机缩小时的速率
                    global.viewer.scene.screenSpaceCameraController._minimumZoomRate = 2000
                    // global.viewer.scene.screenSpaceCameraController._minimumZoomRate = 2000
                    // global.eagleViewer.scene.screenSpaceCameraController._minimumZoomRate = 2000
                    // 设置相机放大时的速率
                    global.viewer.scene.screenSpaceCameraController._maximumZoomRate = 5906376272000
                    // global.viewer.scene.screenSpaceCameraController._maximumZoomRate = 5906376272000
                    // global.eagleViewer.scene.screenSpaceCameraController._maximumZoomRate = 5906376272000
                    // 视角平移
                    global.viewer.scene.screenSpaceCameraController.enableRotate = true
@@ -523,156 +486,17 @@
                                    })
                                }
                            }

                        document.querySelector('.dc-zoom-controller').children[2].onclick =
                            function () {
                                if (
                                    that.dimensionValue != undefined &&
                                    that.dimensionValue != '真三维'
                                ) {
                                    if (viewerHeight == oneVH) {
                                        global.viewer.camera.setView({
                                            destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                                                global.viewer.camera.positionCartographic.longitude,
                                                global.viewer.camera.positionCartographic.latitude,
                                                twoVH
                                            ),
                                            orientation: {
                                                // 指向
                                                heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                                                // 视角
                                                pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                                                roll: 0.0
                                            }
                                        })
                                        viewerHeight = twoVH
                                        that.$emit('change-wheel', false, 'startWheel')
                                        that.addBaseLayer()
                                        return
                                    }

                                    if (viewerHeight == twoVH) {
                                        global.viewer.camera.setView({
                                            destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                                                global.viewer.camera.positionCartographic.longitude,
                                                global.viewer.camera.positionCartographic.latitude,
                                                fourVH
                                            ),
                                            orientation: {
                                                // 指向
                                                heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                                                // 视角
                                                pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                                                roll: 0.0
                                            }
                                        })
                                        viewerHeight = fourVH
                                        that.$emit('change-wheel', false, 'startWheel')
                                        that.addBaseLayer()
                                        return
                                    }

                                    if (viewerHeight == fourVH) {
                                        global.viewer.camera.setView({
                                            destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                                                global.viewer.camera.positionCartographic.longitude,
                                                global.viewer.camera.positionCartographic.latitude,
                                                fiveVH
                                            ),
                                            orientation: {
                                                // 指向
                                                heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                                                // 视角
                                                pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                                                roll: 0.0
                                            }
                                        })
                                        viewerHeight = fiveVH
                                        that.$emit('change-wheel', false, 'startWheel')
                                        that.addBaseLayer()
                                    }
                                }
                            }

                        document.querySelector('.dc-zoom-controller').children[0].onclick =
                            function () {
                                if (
                                    that.dimensionValue != undefined &&
                                    that.dimensionValue != '真三维'
                                ) {
                                    if (viewerHeight == fiveVH) {
                                        global.viewer.camera.setView({
                                            destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                                                global.viewer.camera.positionCartographic.longitude,
                                                global.viewer.camera.positionCartographic.latitude,
                                                fourVH
                                            ),
                                            orientation: {
                                                // 指向
                                                heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                                                // 视角
                                                pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                                                roll: 0.0
                                            }
                                        })
                                        viewerHeight = fourVH
                                        that.$emit('change-wheel', false, 'startWheel')
                                        that.addBaseLayer()
                                        return
                                    }

                                    if (viewerHeight == fourVH) {
                                        global.viewer.camera.setView({
                                            destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                                                global.viewer.camera.positionCartographic.longitude,
                                                global.viewer.camera.positionCartographic.latitude,
                                                twoVH
                                            ),
                                            orientation: {
                                                // 指向
                                                heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                                                // 视角
                                                pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                                                roll: 0.0
                                            }
                                        })
                                        viewerHeight = twoVH
                                        that.$emit('change-wheel', false, 'startWheel')
                                        that.addBaseLayer()
                                        return
                                    }

                                    if (viewerHeight == twoVH) {
                                        global.viewer.camera.setView({
                                            destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                                                global.viewer.camera.positionCartographic.longitude,
                                                global.viewer.camera.positionCartographic.latitude,
                                                oneVH
                                            ),
                                            orientation: {
                                                // 指向
                                                heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                                                // 视角
                                                pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                                                roll: 0.0
                                            }
                                        })
                                        viewerHeight = oneVH
                                        that.$emit('change-wheel', false, 'startWheel')
                                        that.addBaseLayer()
                                    }
                                }
                            }
                    })

                    global.viewer.on(global.DC.SceneEventType.CAMERA_CHANGED, that.mapCameraEvent)
                    global.eagleViewer.on(global.DC.SceneEventType.CAMERA_CHANGED, that.smallMapCameraEvent)

                    that.titlesetLayerFlag = true
                }
            }
        }
    },
    methods: {

        getViewExtend () {
            const params = {}
            const extend = global.viewer.camera.computeViewRectangle()
@@ -729,10 +553,6 @@

        zoomToOpen () {

        },

        locationSTM () {
            global.viewer.flyToPosition('116.45793269658417,39.92711385557482,617.5967826044838,181.95219395269424,-21.286437065473546')
        },

        mouseMoveEvent (e) {
@@ -803,12 +623,6 @@
        },

        addBaseLayer () {
            this.removeBaseLayer()
            baseLayer = []
            this.updateBaseLayer(false)
        },

        removeBaseLayer () {
            if (baseLayer.length > 0) {
                baseLayer.forEach(item => {
                    global.viewer.imageryLayers.remove(
@@ -816,97 +630,123 @@
                    )
                })
            }

            baseLayer = []

            this.updateBaseLayer(false)
        },

        updateBaseLayer (flag) {
            const extent = this.getViewExtend()
            baseLayerImgUrl.forEach(item => {
                if (item[viewerHeight]) {
                    item[viewerHeight].forEach(sm => {
                        let startFlag = true

                        if (flag == true) {
                            baseLayer.forEach(dt => {
                                if (dt.id == sm.id) startFlag = false
                            })
                        }
            const array = baseLayers.filter(item => {
                return item[viewerHeight]
            })

                        if (startFlag == false) return

                        if (
                            (
                                sm.rectangle[0] > extent.minx &&
                                sm.rectangle[1] > extent.miny &&
                                sm.rectangle[2] < extent.maxx &&
                                sm.rectangle[3] < extent.maxy
                            ) ||
                            (
                                sm.rectangle[0] < extent.minx &&
                                sm.rectangle[1] < extent.maxy &&
                                sm.rectangle[2] > extent.minx &&
                                sm.rectangle[3] > extent.maxy
                            ) ||
                            (
                                sm.rectangle[0] < extent.maxx &&
                                sm.rectangle[1] < extent.maxy &&
                                sm.rectangle[2] > extent.maxx &&
                                sm.rectangle[3] > extent.maxy
                            ) ||
                            (
                                sm.rectangle[0] < extent.maxx &&
                                sm.rectangle[1] < extent.miny &&
                                sm.rectangle[2] > extent.maxx &&
                                sm.rectangle[3] > extent.miny
                            ) ||
                            (
                                sm.rectangle[0] < extent.minx &&
                                sm.rectangle[1] < extent.miny &&
                                sm.rectangle[2] > extent.minx &&
                                sm.rectangle[3] > extent.miny
                            ) ||
                            (
                                sm.rectangle[0] > extent.minx &&
                                sm.rectangle[1] < extent.maxy &&
                                sm.rectangle[2] < extent.maxx &&
                                sm.rectangle[3] > extent.maxy
                            ) ||
                            (
                                sm.rectangle[0] > extent.minx &&
                                sm.rectangle[1] > extent.miny &&
                                sm.rectangle[2] > extent.maxx &&
                                sm.rectangle[3] < extent.maxy
                            ) ||
                            (
                                sm.rectangle[0] > extent.minx &&
                                sm.rectangle[1] < extent.miny &&
                                sm.rectangle[2] < extent.maxx &&
                                sm.rectangle[3] > extent.miny
                            ) ||
                            (
                                sm.rectangle[0] < extent.minx &&
                                sm.rectangle[1] > extent.miny &&
                                sm.rectangle[2] > extent.minx &&
                                sm.rectangle[3] < extent.maxy
                            )
                        ) {
                            var layer = global.viewer.imageryLayers.addImageryProvider(new global.DC.Namespace.Cesium.SingleTileImageryProvider({
                                url: sm.url,
                                rectangle: global.DC.Namespace.Cesium.Rectangle.fromDegrees(sm.rectangle[0], sm.rectangle[1], sm.rectangle[2], sm.rectangle[3])
                            }))

                            baseLayer.push({ layer, id: sm.id })
                        }
            array[0][viewerHeight].forEach(sm => {
                let startFlag = false
                if (flag == true) {
                    startFlag = baseLayer.some(dt => {
                        return dt.id == sm.id
                    })
                }

                if (startFlag == true) return

                if (
                    (
                        sm.rectangle[0] > extent.minx &&
                        sm.rectangle[1] > extent.miny &&
                        sm.rectangle[2] < extent.maxx &&
                        sm.rectangle[3] < extent.maxy
                    ) ||
                    (
                        sm.rectangle[0] < extent.minx &&
                        sm.rectangle[1] < extent.maxy &&
                        sm.rectangle[2] > extent.minx &&
                        sm.rectangle[3] > extent.maxy
                    ) ||
                    (
                        sm.rectangle[0] < extent.maxx &&
                        sm.rectangle[1] < extent.maxy &&
                        sm.rectangle[2] > extent.maxx &&
                        sm.rectangle[3] > extent.maxy
                    ) ||
                    (
                        sm.rectangle[0] < extent.maxx &&
                        sm.rectangle[1] < extent.miny &&
                        sm.rectangle[2] > extent.maxx &&
                        sm.rectangle[3] > extent.miny
                    ) ||
                    (
                        sm.rectangle[0] < extent.minx &&
                        sm.rectangle[1] < extent.miny &&
                        sm.rectangle[2] > extent.minx &&
                        sm.rectangle[3] > extent.miny
                    ) ||
                    (
                        sm.rectangle[0] > extent.minx &&
                        sm.rectangle[1] < extent.maxy &&
                        sm.rectangle[2] < extent.maxx &&
                        sm.rectangle[3] > extent.maxy
                    ) ||
                    (
                        sm.rectangle[0] > extent.minx &&
                        sm.rectangle[1] > extent.miny &&
                        sm.rectangle[2] > extent.maxx &&
                        sm.rectangle[3] < extent.maxy
                    ) ||
                    (
                        sm.rectangle[0] > extent.minx &&
                        sm.rectangle[1] < extent.miny &&
                        sm.rectangle[2] < extent.maxx &&
                        sm.rectangle[3] > extent.miny
                    ) ||
                    (
                        sm.rectangle[0] < extent.minx &&
                        sm.rectangle[1] > extent.miny &&
                        sm.rectangle[2] > extent.minx &&
                        sm.rectangle[3] < extent.maxy
                    )
                ) {
                    var layer = global.viewer.imageryLayers.addImageryProvider(sm.layer)

                    baseLayer.push({ layer, id: sm.id })
                }
            })
        },

        mapCameraEvent () {
            const that = this

            that.updateBaseLayer(true)
        // 视图重置
        resetView (lng, lat, height, Range, type) {
            let Cartesian3 = null
            if (type == 'minx') {
                Cartesian3 = global.DC.Namespace.Cesium.Cartesian3.fromDegrees(
                    Range.west,
                    lat,
                    height
                )
            } else if (type == 'miny') {
                Cartesian3 = global.DC.Namespace.Cesium.Cartesian3.fromDegrees(
                    lng,
                    Range.north,
                    height
                )
            } else if (type == 'maxx') {
                Cartesian3 = global.DC.Namespace.Cesium.Cartesian3.fromDegrees(
                    Range.east,
                    lat,
                    height
                )
            } else if (type == 'maxy') {
                Cartesian3 = global.DC.Namespace.Cesium.Cartesian3.fromDegrees(
                    lng,
                    Range.south,
                    height
                )
            }

            global.viewer.camera.setView({
                destination: Cartesian3,
                orientation: {
                    // 指向
                    heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
@@ -915,138 +755,92 @@
                    roll: 0.0
                }
            })
        },

            if (this.startWheel == false) return
        mapCameraEvent () {
            const that = this

            if (this.wheelFlag) { // 下
                if (viewerHeight == fiveVH) {
                    global.viewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.viewer.camera.positionCartographic.longitude,
                            global.viewer.camera.positionCartographic.latitude,
                            fourVH
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    viewerHeight = fourVH
                    that.$emit('change-wheel', false, 'startWheel')
                    that.addBaseLayer()
                    return
                }
            const height = global.viewer.camera.positionCartographic.height

                if (viewerHeight == fourVH) {
                    global.viewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.viewer.camera.positionCartographic.longitude,
                            global.viewer.camera.positionCartographic.latitude,
                            twoVH
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    viewerHeight = twoVH
                    that.$emit('change-wheel', false, 'startWheel')
                    that.addBaseLayer()
                    return
                }
            heightChange = viewerHeight

                if (viewerHeight == twoVH) {
                    global.viewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.viewer.camera.positionCartographic.longitude,
                            global.viewer.camera.positionCartographic.latitude,
                            oneVH
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    viewerHeight = oneVH
                    that.$emit('change-wheel', false, 'startWheel')
                    that.addBaseLayer()
                }
            } else { // 上
                if (viewerHeight == oneVH) {
                    global.viewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.viewer.camera.positionCartographic.longitude,
                            global.viewer.camera.positionCartographic.latitude,
                            twoVH
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    viewerHeight = twoVH
                    that.$emit('change-wheel', false, 'startWheel')
                    that.addBaseLayer()
                    return
                }
            // const Range = { west: 114.03553025, north: 27.62646537, east: 114.04252774, south: 27.63355509 }
            // const rectangle = global.viewer.camera.computeViewRectangle()

                if (viewerHeight == twoVH) {
                    global.viewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.viewer.camera.positionCartographic.longitude,
                            global.viewer.camera.positionCartographic.latitude,
                            fourVH
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    viewerHeight = fourVH
                    that.$emit('change-wheel', false, 'startWheel')
                    that.addBaseLayer()
                    return
                }
            // const west = rectangle.west / Math.PI * 180
            // const north = rectangle.north / Math.PI * 180
            // const east = rectangle.east / Math.PI * 180
            // const south = rectangle.south / Math.PI * 180

                if (viewerHeight == fourVH) {
                    global.viewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.viewer.camera.positionCartographic.longitude,
                            global.viewer.camera.positionCartographic.latitude,
                            fiveVH
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    viewerHeight = fiveVH
                    that.$emit('change-wheel', false, 'startWheel')
                    that.addBaseLayer()
                }
            // const lng = global.viewer.camera.positionCartographic.longitude / Math.PI * 180
            // const lat = global.viewer.camera.positionCartographic.latitude / Math.PI * 180

            // if (west < Range.west) {
            //     that.resetView(lng, lat, height, Range, 'minx')
            // } else if (north < Range.north) {
            //     that.resetView(lng, lat, height, Range, 'miny')
            // } else if (east > Range.east) {
            //     that.resetView(lng, lat, height, Range, 'maxx')
            // } else if (south > Range.south) {
            //     that.resetView(lng, lat, height, Range, 'maxy')
            // }

            if (height > 720) {
                global.viewer.camera.setView({
                    destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                        global.viewer.camera.positionCartographic.longitude,
                        global.viewer.camera.positionCartographic.latitude,
                        702
                    ),
                    orientation: {
                        // 指向
                        heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                        // 视角
                        pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                        roll: 0.0
                    }
                })

                return
            }

            if (height < 140) {
                global.viewer.camera.setView({
                    destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                        global.viewer.camera.positionCartographic.longitude,
                        global.viewer.camera.positionCartographic.latitude,
                        148
                    ),
                    orientation: {
                        // 指向
                        heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                        // 视角
                        pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                        roll: 0.0
                    }
                })

                return
            }

            if (height > fiveVH - heightDifferenceValue) {
                viewerHeight = fiveVH
            } else if (height <= fourVH + heightDifferenceValue && height > fourVH - heightDifferenceValue) {
                viewerHeight = fourVH
            } else if (height <= twoVH + heightDifferenceValue && height > twoVH - heightDifferenceValue) {
                viewerHeight = twoVH
            } else if (height <= oneVH + 50) {
                viewerHeight = oneVH
            }

            if (heightChange != viewerHeight) {
                that.addBaseLayer()
            }

            that.updateBaseLayer(true)
        },

        smallMapCameraEvent () {
            const that = this
            global.eagleViewer.camera.setView({
                orientation: {
                    // 指向
@@ -1056,134 +850,6 @@
                    roll: 0.0
                }
            })

            if (this.startSmallWheel == false) return

            if (this.wheelFlag) { // 下
                if (smallViewerHeight == fiveVH + 1000) {
                    global.eagleViewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.eagleViewer.camera.positionCartographic.longitude,
                            global.eagleViewer.camera.positionCartographic.latitude,
                            fourVH + 1000
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    smallViewerHeight = fourVH + 1000
                    that.$emit('change-wheel', false, 'startSmallWheel')
                    that.addBaseLayer()
                    return
                }

                if (smallViewerHeight == fourVH + 1000) {
                    global.eagleViewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.eagleViewer.camera.positionCartographic.longitude,
                            global.eagleViewer.camera.positionCartographic.latitude,
                            twoVH + 1000
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    smallViewerHeight = twoVH + 1000
                    that.$emit('change-wheel', false, 'startSmallWheel')
                    that.addBaseLayer()
                    return
                }

                if (smallViewerHeight == twoVH + 1000) {
                    global.eagleViewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.eagleViewer.camera.positionCartographic.longitude,
                            global.eagleViewer.camera.positionCartographic.latitude,
                            oneVH + 1000
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    smallViewerHeight = oneVH + 1000
                    that.$emit('change-wheel', false, 'startSmallWheel')
                    that.addBaseLayer()
                }
            } else { // 上
                if (smallViewerHeight == oneVH + 1000) {
                    global.eagleViewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.eagleViewer.camera.positionCartographic.longitude,
                            global.eagleViewer.camera.positionCartographic.latitude,
                            twoVH + 1000
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    smallViewerHeight = twoVH + 1000
                    that.$emit('change-wheel', false, 'startSmallWheel')
                    that.addBaseLayer()
                    return
                }

                if (smallViewerHeight == twoVH + 1000) {
                    global.eagleViewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.eagleViewer.camera.positionCartographic.longitude,
                            global.eagleViewer.camera.positionCartographic.latitude,
                            fourVH + 1000
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    smallViewerHeight = fourVH + 1000
                    that.$emit('change-wheel', false, 'startSmallWheel')
                    that.addBaseLayer()
                    return
                }

                if (smallViewerHeight == fourVH + 1000) {
                    global.eagleViewer.camera.setView({
                        destination: global.DC.Namespace.Cesium.Cartesian3.fromRadians(
                            global.eagleViewer.camera.positionCartographic.longitude,
                            global.eagleViewer.camera.positionCartographic.latitude,
                            fiveVH + 1000
                        ),
                        orientation: {
                            // 指向
                            heading: global.DC.Namespace.Cesium.Math.toRadians(0, 0),
                            // 视角
                            pitch: global.DC.Namespace.Cesium.Math.toRadians(-90),
                            roll: 0.0
                        }
                    })
                    smallViewerHeight = fiveVH + 1000
                    that.$emit('change-wheel', false, 'startSmallWheel')
                    that.addBaseLayer()
                }
            }
        },

        createdLayers () {
@@ -1311,14 +977,6 @@
            }
        },

        locationSAT () {
            global.viewer.flyToPosition('121.4941629,31.2091462,1859.56,0,-28.71')
        },

        locationTC () {
            global.viewer.flyToPosition('120.670183527,31.348282115,109658.22,0,-89.90659095062371')
        },

        addQxTileset () {
            qxTilesetLayer = new global.DC.TilesetLayer('qxTilesetLayer')
            global.viewer.addLayer(qxTilesetLayer)
@@ -1330,7 +988,7 @@
                // skipLevelOfDetail: false,
                shadows: global.DC.Namespace.Cesium.ShadowMode.DISABLED
            })
            qxTileset.setHeight(-100)
            qxTileset.setHeight(18)
            qxTilesetLayer.addOverlay(qxTileset)
        },

@@ -1352,6 +1010,7 @@
                // skipLevelOfDetail: false,
                shadows: global.DC.Namespace.Cesium.ShadowMode.DISABLED
            })
            tileset.setHeight(150)
            tilesetLayer.addOverlay(tileset)
            tileset.on(global.DC.MouseEventType.CLICK, that.tilesetClick)
        },
@@ -1367,104 +1026,52 @@

        qxChangeEvent (change) {
            const that = this
            if (change) {
                that.removeMxTileset()
                that.addQxTileset()
            } else {
                that.removeQxTileset()
                that.addMxTileset()
            }
        },

        generatePosition (num) {
            const list = []
            for (let i = 0; i < num; i++) {
                const lng = 120.38105869 + Math.random() * 0.5
                const lat = 31.10115627 + Math.random() * 0.5
                list.push(new global.DC.Position(lng, lat))
            }
            return list
        },

        removeTC () {
            global.viewer.removeLayer(tcLayer)
            tcLayer = null
        },

        createTC () {
            tcLayer = new global.DC.HeatLayer('tcLayer', {
                useGround: true,
                radius: 40
            })
            global.viewer.addLayer(tcLayer)
            const positions = this.generatePosition(3000)
            tcLayer.setPositions(positions)
        },

        // 科技感删除
        removeSAT () {
            global.viewer.removeLayer(layerSat)
            global.viewer.removeLayer(layerSATtwo)
            layerSat = null
            layerSATtwo = null
        },

        // 科技感添加
        createSAT () {
            function generatePosition (num, isAdd) {
                const list = []
                for (let i = 0; i < num; i++) {
                    const lng = 121.49536592256028 + Math.random() * 0.04 * (isAdd ? 1 : -1)
                    const lat = 31.241616722278213 + Math.random() * 0.04 * (isAdd ? 1 : -1)
                    list.push({ lng, lat })
            global.viewer.camera.setView({
                // Cesium的坐标是以地心为原点，一向指向南美洲，一向指向亚洲，一向指向北极州
                // fromDegrees()方法，将经纬度和高程转换为世界坐标
                destination: global.DC.Namespace.Cesium.Cartesian3.fromDegrees(
                    114.03989859,
                    27.62581763,
                    420.0
                ),
                orientation: {
                    // 指向
                    heading: global.DC.Namespace.Cesium.Math.toRadians(-9),
                    // 视角
                    pitch: global.DC.Namespace.Cesium.Math.toRadians(-34.54),
                    roll: 0.0
                }
                return list
            }

            layerSat = new global.DC.TilesetLayer('layerSat').addTo(global.viewer)

            const build = new global.DC.Tileset(
                'http://resource.dvgis.cn/data/3dtiles/ljz/tileset.json',
                { skipLevels: true }
            )

            const fs = `
                        varying vec3 v_positionEC;
                        void main(void){
                            vec4 position = czm_inverseModelView * vec4(v_positionEC,1); // 位置
                            float glowRange = 100.0; // 光环的移动范围(高度)
                            gl_FragColor = vec4(0.2,  0.5, 1.0, 1.0); // 颜色
                            gl_FragColor *= vec4(vec3(position.z / 100.0), 1.0); // 渐变
                            // 动态光环
                            float time = fract(czm_frameNumber / 360.0);
                            time = abs(time - 0.5) * 2.0;
                            float diff = step(0.005, abs( clamp(position.z / glowRange, 0.0, 1.0) - time));
                            gl_FragColor.rgb += gl_FragColor.rgb * (1.0 - diff);
                        }
                        `
            build.setCustomShader(fs)

            layerSat.addOverlay(build)

            layerSATtwo = new global.DC.PrimitiveLayer('layer').addTo(global.viewer)

            let positions = generatePosition(50, true)

            positions = positions.concat(generatePosition(50))

            positions.forEach(item => {
                const position = global.DC.Position.fromObject(item)
                const end = position.copy()
                end.alt = 5000 * Math.random()
                const line = new global.DC.FlowLinePrimitive([position, end], 0.5)
                line.setStyle({
                    speed: 6 * Math.random(),
                    color: global.DC.Color.fromCssColorString('rgb(141,172,172)'),
                    percent: 0.1,
                    gradient: 0.01
                })
                layerSATtwo.addOverlay(line)
            })

            global.eagleViewer.camera.setView({
                // Cesium的坐标是以地心为原点，一向指向南美洲，一向指向亚洲，一向指向北极州
                // fromDegrees()方法，将经纬度和高程转换为世界坐标
                destination: global.DC.Namespace.Cesium.Cartesian3.fromDegrees(
                    that.mapCenter[0],
                    that.mapCenter[1],
                    1420.0
                ),
                orientation: {
                    // 指向
                    heading: global.DC.Namespace.Cesium.Math.toRadians(-9),
                    // 视角
                    pitch: global.DC.Namespace.Cesium.Math.toRadians(-34.54),
                    roll: 0.0
                }
            })
            if (change) {
                if (qxTileset == null &&
                    qxTilesetLayer == null) {
                    that.removeMxTileset()
                    that.addQxTileset()
                }
            } else {
                if (tileset == null &&
                    tilesetLayer == null) {
                    that.removeQxTileset()
                    that.addMxTileset()
                }
            }
        },

        dimensionChange () {
@@ -1473,21 +1080,40 @@
            that.$store.commit('SET_TWOORTHREE', that.dimensionValue)

            if (that.dimensionValue == '真三维') {
                that.btnGroupShow = true
                that.createSAT()
                that.createTC()
                global.viewer.off(global.DC.MouseEventType.MOUSE_MOVE, that.mouseMoveEvent)
                global.viewer.off(global.DC.SceneEventType.CAMERA_CHANGED, that.mapCameraEvent)
                global.eagleViewer.off(global.DC.SceneEventType.CAMERA_CHANGED, that.smallMapCameraEvent)

                yxLayer = global.viewer.imageryLayers.addImageryProvider(
                    new global.DC.Namespace.Cesium.UrlTemplateImageryProvider({
                        url: 'http://t{s}.tianditu.gov.cn/DataServer?T=img_w&x={x}&y={y}&l={z}&tk=e9533f5acb2ac470b07f406a4d24b4f0',
                        subdomains: ['0', '1', '2', '3', '4', '5', '6', '7'],
                        format: 'image/jpeg',
                        show: true,
                        maximumLevel: 18
                    })
                )

                dxLayer = global.DC.TerrainFactory.createUrlTerrain({
                    url: 'http://data.marsgis.cn/terrain'
                })
                global.viewer.addTerrain(dxLayer)

                that.btnGroupShow = true

                that.removeLayers()
                that.removeBaseLayer()
                baseLayer.forEach(item => {
                    global.viewer.imageryLayers.remove(
                        item.layer
                    )
                })

                baseLayer = []

                silhouetteBlue.selected = []

                that.addMxTileset()

                streenMlayer = new global.DC.S3MLayer('streenMlayer', 'http://resource.dvgis.cn/data/3dtiles/CBD/cbd.scp')
                global.viewer.addLayer(streenMlayer)
                // 最小
                global.viewer.scene.screenSpaceCameraController.minimumZoomDistance = 1.0
                global.eagleViewer.scene.screenSpaceCameraController.minimumZoomDistance = 1.0
@@ -1496,6 +1122,11 @@
                    Number.POSITIVE_INFINITY
                global.eagleViewer.scene.screenSpaceCameraController.maximumZoomDistance =
                    Number.POSITIVE_INFINITY

                // 设置相机缩小时的速率
                // global.viewer.scene.screenSpaceCameraController._minimumZoomRate = 20.0
                // 设置相机放大时的速率
                // global.viewer.scene.screenSpaceCameraController._maximumZoomRate = 5906376272000.0
                // 视角旋转
                global.viewer.scene.screenSpaceCameraController.enableTilt = true
                global.eagleViewer.scene.screenSpaceCameraController.enableTilt = true
@@ -1505,8 +1136,8 @@
                    // fromDegrees()方法，将经纬度和高程转换为世界坐标
                    destination: global.DC.Namespace.Cesium.Cartesian3.fromDegrees(
                        114.03989859,
                        27.62681763,
                        220.0
                        27.62581763,
                        420.0
                    ),
                    orientation: {
                        // 指向
@@ -1523,7 +1154,7 @@
                    destination: global.DC.Namespace.Cesium.Cartesian3.fromDegrees(
                        that.mapCenter[0],
                        that.mapCenter[1],
                        1220.0
                        1420.0
                    ),
                    orientation: {
                        // 指向
@@ -1534,17 +1165,17 @@
                    }
                })
            } else {
                global.viewer.imageryLayers.remove(yxLayer)
                global.viewer.removeTerrain(dxLayer)
                dxLayer = null

                that.btnGroupShow = false
                that.removeSAT()
                that.removeTC()
                global.viewer.on(global.DC.MouseEventType.MOUSE_MOVE, that.mouseMoveEvent)
                global.viewer.on(global.DC.SceneEventType.CAMERA_CHANGED, that.mapCameraEvent)
                global.eagleViewer.on(global.DC.SceneEventType.CAMERA_CHANGED, that.smallMapCameraEvent)
                that.removeMxTileset()
                that.removeQxTileset()
                if (tilesetLayer != null) that.removeMxTileset()
                if (qxTilesetLayer != null) that.removeQxTileset()

                global.viewer.removeLayer(streenMlayer)
                streenMlayer = null
                that.createdLayers()

                that.addBaseLayer()
@@ -1586,8 +1217,11 @@
                global.viewer.scene.screenSpaceCameraController.minimumZoomDistance = mixVH
                global.eagleViewer.scene.screenSpaceCameraController.minimumZoomDistance = mixVH + 1000
                // 最大
                global.viewer.scene.screenSpaceCameraController.maximumZoomDistance = maxVH
                global.eagleViewer.scene.screenSpaceCameraController.maximumZoomDistance = maxVH + 1000
                // global.viewer.scene.screenSpaceCameraController.maximumZoomDistance = maxVH
                // global.eagleViewer.scene.screenSpaceCameraController.maximumZoomDistance = maxVH + 1000
                global.viewer.scene.screenSpaceCameraController._minimumZoomRate = 2000
                // 设置相机放大时的速率
                global.viewer.scene.screenSpaceCameraController._maximumZoomRate = 5906376272000
                // 视角旋转
                global.viewer.scene.screenSpaceCameraController.enableTilt = false
                global.eagleViewer.scene.screenSpaceCameraController.enableTilt = false
@@ -1619,20 +1253,5 @@
    top: 66px;
    right: 75px;
    z-index: 99;
}

.sat-tc {
    position: fixed;
    top: 66px;
    right: 141px;
    z-index: 99;
}

.sat-qx {
    position: fixed;
    top: 66px;
    right: 220px;
    z-index: 99;
    background: #fff;
}
</style>