import EventBus from '@/utils/eventBus'
|
import * as Cesium from 'cesium'
|
import { Cartesian3, Terrain, Viewer } from 'cesium'
|
import store from '@/store/index'
|
|
import getBaseConfig from '@/buildConfig/config'
|
|
const {
|
imageryProvider_ammap,
|
imageryProvider_ammapBz,
|
imageryProvider_ammapSL,
|
imageryProvider_stand,
|
imageryProvider_standZh,
|
imageryProvider_tdt_cia_w,
|
imageryProvider_tdt_img_w,
|
|
blueImageryProviderVec,
|
blueImageryProviderCva,
|
} = getBaseConfig()
|
|
import { addBlueFilter } from '@/utils/cesium/common'
|
import { useBoundary } from '@/utils/cesium/useBoundary'
|
|
let smallMpaCenterDistance = null
|
let curCameraHpr = null
|
|
let proHandler = null
|
let proController = null
|
let proMoveFlag = null
|
|
let handler = null
|
/**
|
* 公共的Cesium (蓝色，2d)
|
*/
|
|
// 封装的不用管
|
let cn = {
|
ri: function () {
|
return a
|
},
|
|
LS: function () {
|
return o
|
},
|
|
jL: function () {
|
return n
|
},
|
}
|
function a (e) {
|
return null != e
|
}
|
function o (e, t) {
|
return a(e) ? e : t
|
}
|
|
function n (e, t = !1) {
|
let { longitude: i, latitude: a, height: o } = e
|
return Cesium.Cartesian3.fromDegrees(i, a, t ? 0 : o)
|
}
|
|
/**
|
* 创建ztzf-cesium
|
* @param {Object} options - 配置选项对象
|
* @param {string} options.dom - Cesium 容器的 DOM 元素
|
* @param {boolean} [options.flatMode=true] - 是否启用 2D 模式，默认为 true
|
* @param {boolean} [options.terrain=false] - 是否启用地形，默认为 false
|
* @param {number} [options.layerMode=17] - 图层模式，默认值为 17（蓝色底图）
|
* @param {boolean} [options.contour=true] - 是否显示轮廓线，默认为 true
|
* @param {boolean} [options.flyToContour=false] - 是否飞行到轮廓，默认为 false
|
* @param {number} [options.multiple=1.4] - 范围倍数
|
* @param {number} [options.dockOptions={}] - 机巢显示
|
* @param {array} [options.boundaryChange] - 边界改变事件
|
* @param {array} [options.boundaryColor] - 边界颜色
|
* @param {array} [options.dockRangeType] - 机巢范围类型 1显示覆盖圆；2显示覆盖圈
|
* @param {array} [options.useDockHeight] - 是否使用机巢高度，默认为false
|
*/
|
export class PublicCesium {
|
|
constructor(options) {
|
this.handlerLeftEvents = { handler: null }
|
this.handlerRightEvents = { handler: null }
|
this.handlerMouseMoveEvents = { handler: null }
|
this.viewer = null
|
this.globalBaseMapLayers = []
|
this.boundary = null
|
this.init(options)
|
}
|
|
init (options) {
|
const {
|
dom,
|
flatMode = true,
|
terrain = false,
|
layerMode = 0,
|
contour = true,
|
// flyToContour = false,
|
multiple = 1.4,
|
|
dockOptions = {},
|
|
|
|
dockRangeType = 1,
|
useDockHeight = false
|
} = options
|
Cesium.Camera.DEFAULT_VIEW_FACTOR = -0.45
|
// 西南东北，默认显示中国
|
Cesium.Camera.DEFAULT_VIEW_RECTANGLE = Cesium.Rectangle.fromDegrees(66, 4, 135, 53.55)
|
const viewerOptions = {
|
infoBox: false, // 禁用沙箱，解决控制台报错
|
animation: false, // 左下角的动画仪表盘
|
baseLayerPicker: false, // 右上角的图层选择按钮
|
geocoder: false, // 搜索框
|
homeButton: false, // home按钮
|
sceneModePicker: false, // 模式切换按钮
|
timeline: false, // 底部的时间轴
|
navigationHelpButton: false, // 右上角的帮助按钮，
|
selectionIndicator: false, // 是否显示选择指示器
|
baseLayer: false,
|
fullscreenButton: false,
|
}
|
|
this.viewer = new Viewer(dom, viewerOptions)
|
this.viewerDom = dom
|
|
this.viewer.scene.globe.enableLighting = true
|
this.viewer.shadows = false
|
this.viewer.shadowMap.darkness = 0.5
|
|
let time = new Date()
|
time.setHours(12, 0, 0, 0)
|
let utc = Cesium.JulianDate.fromDate(new Date(time))
|
|
this.viewer.clockViewModel.currentTime = Cesium.JulianDate.addHours(utc, 0, new Cesium.JulianDate())
|
|
// 边界，机巢
|
|
this.viewer?.imageryLayers.removeAll()
|
this.viewer._cesiumWidget._creditContainer.style.display = 'none'
|
handler = new Cesium.ScreenSpaceEventHandler(this.viewer?.scene.canvas)
|
|
this.viewer?.cesiumWidget.screenSpaceEventHandler.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK) // 禁用双击
|
|
if (terrain) {
|
try {
|
Cesium.CesiumTerrainProvider.fromUrl(`${import.meta.env.VITE_APP_TERRAIN_URL}`, {
|
requestVertexNormals: true, // 启用地形法线增强立体感
|
requestWaterMask: true, // 启用水体遮罩效果
|
}).then(terrainProvider => {
|
this.viewer.terrainProvider = terrainProvider
|
})
|
} catch (error) {
|
console.error('地形加载失败:', error)
|
}
|
}
|
|
this.viewer.scene.screenSpaceCameraController.maximumZoomDistance = 4500000
|
this.switchLayers(layerMode)
|
this.switchFlatMode(flatMode)
|
// this.switchContour(contour)
|
// flyToContour && this.flyToContour(contour)
|
}
|
|
getViewer () {
|
return this.viewer
|
}
|
|
// 销毁viewer
|
viewerDestroy (removeDom = true) {
|
smallMpaCenterDistance = null
|
|
if (this.viewer) {
|
this.viewer?.entities.removeAll()
|
this.viewer?.imageryLayers.removeAll()
|
this.viewer?.dataSources.removeAll()
|
|
|
// try {
|
// this.viewer?.scene?.primitives?.removeAll()
|
// this.viewer?.entities?.removeAll()
|
// } catch (e) {
|
// console.warn('清理资源时出错:', e)
|
|
// console.log(this.viewer, 1111111111111)
|
// }
|
|
// 获取webgl上下文
|
let gl = this.viewer?.scene.context._originalGLContext
|
gl.canvas.width = 1
|
gl.canvas.height = 1
|
gl.getExtension("WEBGL_lose_context").loseContext()
|
gl = null
|
this.viewer?.destroy() // 销毁Viewer实例
|
this.viewer = null
|
var cesiumContainer = document.getElementById(this.viewerDom)
|
if (cesiumContainer && removeDom) {
|
cesiumContainer.remove() // 移除与地图相关的DOM元素
|
this.viewerDom = null
|
}
|
}
|
}
|
|
setShowDock (sns) {
|
// this.boundary?.setShowDock(sns)
|
}
|
|
// 切换轮廓显示
|
// async switchContour (open) {
|
// if (open) {
|
// await this.boundary?.openContour()
|
// } else {
|
// this.boundary?.closeContour()
|
// }
|
// }
|
// // 飞向轮廓居中
|
// flyToContour () {
|
// this.boundary?.flyToBoundary()
|
// }
|
|
// 飞行 flyto
|
flyTo (pointOption, time = 4, height = 3000, orientation = {}, complete = () => { }) {
|
if (!pointOption.longitude && !pointOption.latitude) return
|
const destination = Cesium.Cartesian3.fromDegrees(pointOption.longitude, pointOption.latitude, height)
|
const duration = time
|
this.viewer?.camera.flyTo({
|
destination,
|
duration,
|
orientation,
|
complete,
|
})
|
}
|
|
switchLayers (mode, roadLine = false) {
|
let mapLayers = []
|
this.globalBaseMapLayers?.forEach(item => {
|
if (item.mapLayer) item.mapLayer.show = false
|
})
|
// store.state.common.mapSetting.mode = mode
|
// 标准地图(天地图矢量)加载
|
if (mode === 0) {
|
mapLayers.push(
|
...[
|
{ key: 'imageryProvider_standZh', layer: imageryProvider_standZh },
|
{ key: 'imageryProvider_stand', layer: imageryProvider_stand },
|
]
|
)
|
}
|
// 高德地图矢量图层加载
|
if (mode === 2) {
|
mapLayers.push({
|
key: 'imageryProvider_ammapSL',
|
layer: imageryProvider_ammapSL,
|
})
|
}
|
// 高德影像地图数据图层
|
if (mode === 3) {
|
mapLayers.push(
|
...[
|
{ key: 'imageryProvider_ammap', layer: imageryProvider_ammap },
|
{ key: 'imageryProvider_ammapBz', layer: imageryProvider_ammapBz },
|
]
|
)
|
}
|
|
// 天地图影像➕注记
|
if (mode === 4) {
|
mapLayers.push(
|
...[
|
{ key: 'imageryProvider_standZh', layer: imageryProvider_standZh },
|
// { key: 'imageryProvider_tdt_cia_w', layer: imageryProvider_tdt_cia_w },
|
{ key: 'imageryProvider_tdt_img_w', layer: imageryProvider_tdt_img_w },
|
]
|
)
|
}
|
|
// 蓝色底图
|
if (mode === 17) {
|
mapLayers.push(
|
...[
|
{ key: 'blueImageryProviderCva', layer: blueImageryProviderCva },
|
{ key: 'blueImageryProviderVec', layer: blueImageryProviderVec },
|
]
|
)
|
}
|
|
// 路线图加载
|
if (roadLine === true && mode === 1) {
|
mapLayers.push({ key: 'annotation', layer: imageryProvider_tdt_cia_w })
|
}
|
|
mapLayers.forEach(item => {
|
let find = this.globalBaseMapLayers.find(item1 => item1.key === item.key)
|
if (!find) {
|
find = {
|
key: item.key,
|
mapLayer: this.viewer?.imageryLayers.addImageryProvider(item.layer),
|
}
|
this.globalBaseMapLayers.push(find)
|
}
|
find.mapLayer.show = true
|
this.setCurrentLayerFilter(find, mode)
|
this.viewer?.imageryLayers.lowerToBottom(find.mapLayer)
|
})
|
}
|
|
// 设置或重置滤镜
|
|
setCurrentLayerFilter (data, mode) {
|
if (mode === 17) {
|
data.mapLayer.brightness = 0.6 // 亮度（默认值）
|
data.mapLayer.contrast = 1.8 // 对比度（负值降低对比度）
|
data.mapLayer.hue = 1 // 色相（弧度值，3.0可能导致紫色）
|
data.mapLayer.saturation = 0 // 增加饱和度强化蓝色
|
data.mapLayer.gamma = 0.3 // 伽马校正（小于1.0使颜色更鲜艳）
|
|
if (data.key === 'blueImageryProviderVec')
|
addBlueFilter(
|
{
|
bInvertColor: true,
|
bFilterColor: true,
|
filterColor: '#4e70a6',
|
},
|
this.viewer,
|
true
|
)
|
} else {
|
data.mapLayer.brightness = 1 // 亮度（默认值）
|
data.mapLayer.contrast = 1 // 对比度（负值降低对比度）
|
data.mapLayer.hue = 0 // 色相（弧度值，3.0可能导致紫色）
|
data.mapLayer.saturation = 1 // 增加饱和度强化蓝色
|
data.mapLayer.gamma = 1 // 伽马校正（小于1.0使颜色更鲜艳）
|
|
addBlueFilter(
|
{
|
bInvertColor: true,
|
bFilterColor: true,
|
filterColor: '#4e70a6',
|
},
|
this.viewer,
|
false
|
)
|
}
|
}
|
|
// 切换为二三维模式 type: true 2D false 3D
|
switchFlatMode (type) {
|
if (type) {
|
this.viewer?.scene.morphTo2D(0)
|
} else {
|
this.viewer?.scene.morphTo3D(0)
|
}
|
}
|
|
// 右键点击事件
|
addRightClickEvent (sid, cb, eventKey = 'rightHandler') {
|
if (this.handlerRightEvents.rightHandler) this.removeRightClickEvent()
|
if (this.handlerRightEvents[eventKey]) this.removeRightClickEvent(eventKey)
|
|
this.handlerRightEvents[eventKey] = new Cesium.ScreenSpaceEventHandler(this.viewer?.scene.canvas)
|
|
this.handlerRightEvents[eventKey].setInputAction(click => {
|
const pick = this.viewer?.scene.pick(click.position)
|
cb(click, pick, this.viewer)
|
}, Cesium.ScreenSpaceEventType.RIGHT_CLICK)
|
}
|
|
// 移除鼠标右键事件
|
removeRightClickEvent (eventKey = 'rightHandler') {
|
if (!this.handlerRightEvents[eventKey]) return
|
this.handlerRightEvents[eventKey].removeInputAction(Cesium.ScreenSpaceEventType.RIGHT_CLICK)
|
|
this.handlerRightEvents[eventKey] = null
|
}
|
|
addLeftDrillPickEvent (cb, eventKey = 'handler') {
|
if (this.handlerLeftEvents.handler) this.removeLeftDrillPickEvent()
|
if (this.handlerLeftEvents[eventKey]) this.removeLeftDrillPickEvent(eventKey)
|
|
this.handlerLeftEvents[eventKey] = new Cesium.ScreenSpaceEventHandler(this.viewer?.scene.canvas)
|
this.handlerLeftEvents[eventKey].setInputAction(click => {
|
const picks = this.viewer?.scene.drillPick(click.position)
|
|
cb(picks)
|
}, Cesium.ScreenSpaceEventType.LEFT_CLICK)
|
}
|
|
removeLeftDrillPickEvent (eventKey = 'handler') {
|
if (this.handlerLeftEvents[eventKey] == null) return
|
this.handlerLeftEvents[eventKey].removeInputAction(Cesium.ScreenSpaceEventType.LEFT_CLICK)
|
|
this.handlerLeftEvents[eventKey] = null
|
}
|
|
// 鼠标点击事件
|
addLeftClickEvent (sid, cb, eventKey = 'handler') {
|
if (this.handlerLeftEvents.handler) this.removeLeftClickEvent()
|
if (this.handlerLeftEvents[eventKey]) this.removeLeftClickEvent(eventKey)
|
|
this.handlerLeftEvents[eventKey] = new Cesium.ScreenSpaceEventHandler(this.viewer?.scene.canvas)
|
this.handlerLeftEvents[eventKey].setInputAction(click => {
|
const pick = this.viewer?.scene.pick(click.position)
|
|
if (pick && pick.primitive && pick.primitive?.customParams?.type === '3DTileset') {
|
return cb(click, pick, this.viewer, this.handlerLeftEvents[eventKey])
|
}
|
|
if (pick && pick.id && (pick.id._id === sid || pick.id._id.includes(sid))) {
|
cb(click, pick, this.viewer, this.handlerLeftEvents[eventKey])
|
}
|
|
if (sid === null) {
|
cb(click, pick, this.viewer, this.handlerLeftEvents[eventKey])
|
}
|
}, Cesium.ScreenSpaceEventType.LEFT_CLICK)
|
}
|
|
// 移除鼠标点击事件
|
removeLeftClickEvent (eventKey = 'handler') {
|
if (this.handlerLeftEvents[eventKey] == null) return
|
this.handlerLeftEvents[eventKey].removeInputAction(Cesium.ScreenSpaceEventType.LEFT_CLICK)
|
|
this.handlerLeftEvents[eventKey] = null
|
}
|
|
// 鼠标移动事件
|
addMouseHandler (sid, cb, eventKey = 'mouseHandler') {
|
const that = this
|
if (this.handlerMouseMoveEvents.mouseHandler) this.removeMouseHandler()
|
if (this.handlerMouseMoveEvents[eventKey]) this.removeMouseHandler(eventKey)
|
|
|
this.handlerMouseMoveEvents[eventKey] = new Cesium.ScreenSpaceEventHandler(this.viewer?.scene.canvas)
|
|
this.handlerMouseMoveEvents[eventKey].setInputAction(function (movement) {
|
cb(movement, that.viewer)
|
}, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
|
}
|
|
// 移除鼠标移动事件
|
removeMouseHandler (eventKey = 'mouseHandler') {
|
if (this.handlerMouseMoveEvents[eventKey] == null) return
|
this.handlerMouseMoveEvents[eventKey].removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE)
|
|
this.handlerMouseMoveEvents[eventKey] = null
|
}
|
|
pointInitEvent (left_down, mouse_move, left_up) {
|
if (this.pointEditHandler) this.pointUnInitEvent()
|
this.pointEditHandler = new Cesium.ScreenSpaceEventHandler(this.viewer?.scene.canvas)
|
const events = {
|
left_down,
|
mouse_move,
|
left_up,
|
}
|
|
this.pointEditBindEvent(events)
|
this.pointEditBindEvent(events, Cesium.KeyboardEventModifier.CTRL)
|
this.pointEditBindEvent(events, Cesium.KeyboardEventModifier.ALT)
|
this.pointEditBindEvent(events, Cesium.KeyboardEventModifier.SHIFT)
|
this.pointEditBindEvent(events, Cesium.KeyboardEventModifier.META)
|
}
|
|
pointEditBindEvent (events, e) {
|
if (this.pointEditHandler) {
|
this.pointEditHandler.setInputAction(events.left_down(e), Cesium.ScreenSpaceEventType.LEFT_DOWN, e)
|
this.pointEditHandler.setInputAction(events.mouse_move(e), Cesium.ScreenSpaceEventType.MOUSE_MOVE, e)
|
this.pointEditHandler.setInputAction(events.left_up(e), Cesium.ScreenSpaceEventType.LEFT_UP, e)
|
}
|
}
|
|
pointUnInitEvent () {
|
this.pointEditUnBindEvent()
|
this.pointEditUnBindEvent(Cesium.KeyboardEventModifier.CTRL)
|
this.pointEditUnBindEvent(Cesium.KeyboardEventModifier.ALT)
|
this.pointEditUnBindEvent(Cesium.KeyboardEventModifier.SHIFT)
|
this.pointEditUnBindEvent(Cesium.KeyboardEventModifier.META)
|
|
this.pointEditHandler = null
|
}
|
|
pointEditUnBindEvent (e) {
|
this.pointEditHandler?.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_DOWN, e)
|
this.pointEditHandler?.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE, e)
|
this.pointEditHandler?.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_UP, e)
|
}
|
|
setCameraMove (e) {
|
this.setCameraAttribute(e)
|
}
|
|
setCameraAttribute (e) {
|
let t = {}
|
, i = !1
|
|
if (e.attitude) {
|
let { fov: n } = e.attitude
|
|
if ((0, cn.ri)(n) && this.viewer?.camera) {
|
this.viewer.camera.frustum = new Cesium.PerspectiveFrustum({
|
fov: Cesium.Math.toRadians(n),
|
aspectRatio: this.viewer?.canvas.clientWidth / this.viewer?.canvas.clientHeight,
|
near: .1
|
})
|
}
|
}
|
i && this.viewer?.camera.setView(t)
|
}
|
|
setView (options) {
|
const position = Cesium.Cartesian3.fromDegrees(
|
Number(options.longitude),
|
Number(options.latitude),
|
Number(options.height || 0),
|
)
|
const heading = Number(options.heading || 0)
|
this.viewer?.camera?.setView({
|
destination: position,
|
orientation: {
|
heading: Cesium.Math.toRadians(heading >= 0 ? heading : heading + 360), // 水平旋转（偏航角）
|
pitch: Cesium.Math.toRadians(Number(options.pitch || 0)), // 俯仰角（-90°表示俯视地心）
|
roll: 0.0 // 翻转角
|
}
|
})
|
|
this.getCameraCurPositionDistance()
|
}
|
|
getCameraCurPositionDistance () {
|
if (!this.viewer) return
|
|
// 获取相机位置
|
const position = this.viewer?.camera.positionCartographic
|
const cameraLongitude = Cesium.Math.toDegrees(position.longitude)
|
const cameraLatitude = Cesium.Math.toDegrees(position.latitude)
|
const cameraHeight = position.height
|
|
// 获取地图区域中心点位置
|
let mapCenterPx = {
|
x: this.viewer?.canvas.clientWidth / 2,
|
y: this.viewer?.canvas.clientHeight / 2
|
}
|
|
let centerInfo = this.getMouseInfo(mapCenterPx)
|
|
if (centerInfo.wgs84SurfacePosition) {
|
const {
|
lng,
|
lat,
|
alt
|
} = centerInfo.wgs84SurfacePosition
|
|
// 计算相机到中心点的距离
|
const cameraPosition = Cesium.Cartesian3.fromDegrees(cameraLongitude, cameraLatitude, cameraHeight)
|
const centerPoint = Cesium.Cartesian3.fromDegrees(lng, lat, alt)
|
const distance = Cesium.Cartesian3.distance(cameraPosition, centerPoint)
|
|
smallMpaCenterDistance = distance
|
EventBus.emit('setCameraCurPositionDistance', distance)
|
} else {
|
const cameraPosition = this.viewer?.camera.position
|
const farDistance = this.viewer?.camera.frustum.far // 获取相机的远裁剪面距离
|
const distance = farDistance - Cesium.Cartesian3.magnitude(cameraPosition)
|
smallMpaCenterDistance = distance
|
EventBus.emit('setCameraCurPositionDistance', '')
|
}
|
}
|
|
getMouseInfo (position) {
|
let scene = this.viewer?.scene
|
let surfaceCartesian = undefined
|
let wgs84SurfacePosition = undefined
|
|
if (
|
scene.mode === Cesium.SceneMode.SCENE3D &&
|
!(this.viewer?.terrainProvider instanceof Cesium.EllipsoidTerrainProvider)
|
) {
|
let ray = scene.camera.getPickRay(position)
|
surfaceCartesian = scene.globe.pick(ray, scene)
|
} else {
|
surfaceCartesian = scene.camera.pickEllipsoid(
|
position,
|
Cesium.Ellipsoid.WGS84,
|
)
|
}
|
|
if (surfaceCartesian) {
|
let c = Cesium.Ellipsoid.WGS84.cartesianToCartographic(surfaceCartesian)
|
if (c) {
|
wgs84SurfacePosition = {
|
lng: Cesium.Math.toDegrees(c.longitude),
|
lat: Cesium.Math.toDegrees(c.latitude),
|
alt: c.height,
|
}
|
}
|
}
|
|
return {
|
wgs84SurfacePosition: wgs84SurfacePosition,
|
}
|
}
|
|
getMouseInfoAll (position) {
|
let scene = this.viewer?.scene
|
let target = scene.pick(position)
|
let cartesian = undefined
|
let surfaceCartesian = undefined
|
let wgs84Position = undefined
|
let wgs84SurfacePosition = undefined
|
if (scene.pickPositionSupported) {
|
cartesian = scene.pickPosition(position)
|
}
|
if (cartesian) {
|
let c = Cesium.Ellipsoid.WGS84.cartesianToCartographic(cartesian)
|
if (c) {
|
wgs84Position = {
|
lng: Cesium.Math.toDegrees(c.longitude),
|
lat: Cesium.Math.toDegrees(c.latitude),
|
alt: c.height,
|
}
|
}
|
}
|
if (
|
scene.mode === Cesium.SceneMode.SCENE3D &&
|
!(this.viewer?.terrainProvider instanceof Cesium.EllipsoidTerrainProvider)
|
) {
|
let ray = scene.camera.getPickRay(position)
|
surfaceCartesian = scene.globe.pick(ray, scene)
|
} else {
|
surfaceCartesian = scene.camera.pickEllipsoid(position, Cesium.Ellipsoid.WGS84)
|
}
|
if (surfaceCartesian) {
|
let c = Cesium.Ellipsoid.WGS84.cartesianToCartographic(surfaceCartesian)
|
if (c) {
|
wgs84SurfacePosition = {
|
lng: Cesium.Math.toDegrees(c.longitude),
|
lat: Cesium.Math.toDegrees(c.latitude),
|
alt: c.height,
|
}
|
}
|
}
|
|
return {
|
target: target,
|
windowPosition: position,
|
position: cartesian,
|
wgs84Position: wgs84Position,
|
surfacePosition: surfaceCartesian,
|
wgs84SurfacePosition: wgs84SurfacePosition,
|
}
|
}
|
|
// 左键按下事件
|
pro_left_down (e) {
|
proMoveFlag = !0
|
}
|
|
// 左键抬起事件
|
pro_left_up (e) {
|
proMoveFlag = !1
|
}
|
|
// 鹰眼鼠标移动事件
|
pro_mouse_move (e) {
|
if (proMoveFlag) {
|
this.look3D(e.startPosition, e.endPosition)
|
|
const position = this.viewer?.camera.positionCartographic
|
const lng = Cesium.Math.toDegrees(position.longitude).toFixed(4)
|
const lat = Cesium.Math.toDegrees(position.latitude).toFixed(4)
|
const alt = (position.height / 1000).toFixed(2) // 转换为千米
|
|
// 获取方向
|
const heading = Cesium.Math.toDegrees(this.viewer?.camera.heading).toFixed(2)
|
const pitch = Cesium.Math.toDegrees(this.viewer?.camera.pitch).toFixed(2)
|
const roll = Cesium.Math.toDegrees(this.viewer?.camera.roll).toFixed(2)
|
|
curCameraHpr = {
|
heading,
|
pitch,
|
roll
|
}
|
|
let newHeading = ((heading + 180) % 360) - 180
|
EventBus.emit('PointAirLine-setRoamPoint', {
|
pitch: pitch,
|
heading: newHeading >= 0 ? newHeading - 180 : newHeading + 180
|
})
|
|
this.getCameraCurPositionDistance()
|
}
|
}
|
|
// 鹰眼地图相关事件
|
bindEvent () {
|
this.bindProLeftDown = this.pro_left_down.bind(this)
|
this.bindProLeftUp = this.pro_left_up.bind(this)
|
this.bindProLeftMove = this.pro_mouse_move.bind(this)
|
|
proHandler = new Cesium.ScreenSpaceEventHandler(this.viewer?.scene.canvas)
|
|
proController = this.viewer?.scene.screenSpaceCameraController
|
|
proController.enableRotate = !1
|
proController.enableTilt = !1
|
proController.enableZoom = !1
|
proController.enableLook = !1
|
proController.enableTranslate = !1
|
proMoveFlag = false
|
|
handler.setInputAction(this.bindProLeftDown, Cesium.ScreenSpaceEventType.LEFT_DOWN)
|
handler.setInputAction(this.bindProLeftUp, Cesium.ScreenSpaceEventType.LEFT_UP)
|
handler.setInputAction(this.bindProLeftMove, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
|
}
|
|
unBindEvent = () => {
|
if (proHandler) {
|
handler.removeInputAction(this.bindProLeftDown, Cesium.ScreenSpaceEventType.LEFT_DOWN)
|
handler.removeInputAction(this.bindProLeftUp, Cesium.ScreenSpaceEventType.LEFT_UP)
|
handler.removeInputAction(this.bindProLeftMove, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
|
|
proController = null
|
proHandler = null
|
}
|
}
|
|
look3D (e, t, i = !1) {
|
let r = this.viewer?.camera
|
, a = this.viewer?.scene.globe.ellipsoid
|
, s = i ? -1 : 2
|
, o = a.geodeticSurfaceNormal(r.position)
|
r.look(o, this.getLookAngle(e, t, "x") * s),
|
this.lookVertical(-this.getLookAngle(e, t, "y") * s, o)
|
}
|
|
getLookAngle (e, t, i) {
|
let r, a
|
let s = e[i]
|
, o = t[i]
|
, n = new Cesium.Cartesian2("x" === i ? s : 0, "y" === i ? s : 0)
|
, l = new Cesium.Cartesian2("x" === i ? o : 0, "y" === i ? o : 0)
|
, c = this.viewer?.camera.getPickRay(n)
|
, h = this.viewer?.camera.getPickRay(l)
|
if (!c || !h)
|
return 0
|
this.viewer?.camera.frustum instanceof Cesium.OrthographicFrustum ? (r = c.origin,
|
a = h.origin,
|
Cesium.Cartesian3.add(this.viewer?.camera.direction, r, r),
|
Cesium.Cartesian3.add(this.viewer?.camera.direction, a, a),
|
Cesium.Cartesian3.subtract(r, this.viewer?.camera.position, r),
|
Cesium.Cartesian3.subtract(a, this.viewer?.camera.position, a),
|
Cesium.Cartesian3.normalize(r, r),
|
Cesium.Cartesian3.normalize(a, a)) : (r = c.direction,
|
a = h.direction)
|
let d = Cesium.Cartesian3.dot(r, a)
|
, p = 0
|
return d < 1 && (p = Math.acos(d)),
|
s > o ? -p : p
|
}
|
|
lookVertical (e, t) {
|
let i = this.viewer?.camera
|
, r = this.judgeParallelAndRecalculateAngle(-e, i.direction, t)
|
r && i.look(i.right, r)
|
}
|
|
sg (e, t) {
|
return Cesium.Cartesian3.equalsEpsilon(e, t, Cesium.Math.EPSILON2) ? 1 : Cesium.Cartesian3.equalsEpsilon(e, Cesium.Cartesian3.negate(t, new Cesium.Cartesian3), Cesium.Math.EPSILON2) ? -1 : 0
|
}
|
|
judgeParallelAndRecalculateAngle (e, t, i) {
|
let r = this.sg(t, i)
|
, a = e
|
if (1 === r && a < 0)
|
a = 0
|
else if (-1 === r && a > 0)
|
a = 0
|
else if (0 === r) {
|
let e = Cesium.Cartesian3.dot(t, i)
|
, r = Cesium.Math.acosClamped(-e)
|
a > 0 && a > r && (a = r - Cesium.Math.EPSILON4),
|
r = Cesium.Math.acosClamped(e),
|
a < 0 && -a > r && (a = -r + Cesium.Math.EPSILON4)
|
}
|
return a
|
}
|
|
getEntityById (id) {
|
const pointEntity = this.viewer?.entities.getById(id)
|
return pointEntity
|
}
|
|
removeById (id) {
|
this.viewer?.entities.removeById(id)
|
const pointEntity = this.viewer?.entities.getById(id)
|
if (pointEntity && pointEntity !== undefined) {
|
this.viewer?.entities.remove(pointEntity)
|
}
|
}
|
|
removeAllPoint () {
|
if (this.viewer) {
|
this.viewer?.entities?.removeAll()
|
// viewer?.scene?.primitives?.removeAll();
|
}
|
}
|
|
// 添加entity
|
addCustomImageryProviderDataSource (imageryLayers) {
|
return this.viewer?.imageryLayers.addImageryProvider(imageryLayers)
|
}
|
|
showCustomImageryProviderDataSource (imageryLayers, show) {
|
if (imageryLayers) {
|
imageryLayers.show = show
|
}
|
}
|
|
|
removeAllCustomImageryProviderDataSource (imageryLayers) {
|
if (imageryLayers) {
|
this.viewer?.imageryLayers.remove(imageryLayers)
|
}
|
}
|
}
|
