1455 lines
48 KiB
JavaScript
1455 lines
48 KiB
JavaScript
/**
|
|
* 分屏对比
|
|
* */
|
|
import Tools from '../../Tools';
|
|
import { CesiumContainer, closeRotateAround } from '../global'
|
|
import { FlwStatusSwitch, JwwStatusSwitch, getFlwStatus, getJwwStatus } from "../global"
|
|
import { off as offMultiViewportMode } from '../MultiViewportMode';
|
|
import { MouseRightMenu, getMouseRightMenuStatus } from '../mouseRightMenu';
|
|
import { getLeftClickState, getRightClickState, getMoveState } from '../ClickCallback'
|
|
import { openLeftClick, openRightClick, openMove } from './ClickCallback'
|
|
import { SheetIndexStatusSwitch, getStatus } from '../SheetIndex'
|
|
|
|
|
|
let state = false
|
|
let sdkD // 分屏对象
|
|
let sdkP // 主屏对象
|
|
let activeViewer
|
|
let controlViewer
|
|
let syncObject = {}
|
|
let handlers = []
|
|
let activeIds
|
|
let statusMap = new Map()
|
|
// window.statusMap = statusMap
|
|
// async function init(sdk) {
|
|
// sdkP = sdk
|
|
// activeViewer = 0
|
|
// let tools = new Tools()
|
|
// let sdk2 = await new YJ.YJEarth(sdk.div_id)
|
|
// sdk2.viewer._element.className = 'cesium-viewer 2d'
|
|
// // setTimeout(() => {
|
|
// // let switchCluster = new YJ.Global.switchCluster(sdk2, true)
|
|
// // }, 500);
|
|
// CesiumContainer(sdk2, {
|
|
// compass: false, // 罗盘
|
|
// // legend: false, // 比例尺
|
|
// info: false, // 信息栏
|
|
// frame: false // 刷新率
|
|
// })
|
|
// sdk2.viewer.scene.mode = Cesium.SceneMode.SCENE2D
|
|
// sdkD = await sdk2
|
|
// solveBug()
|
|
// await eventBind(sdk, 0)
|
|
// await eventBind(sdk2, 1)
|
|
// syncObject = { sdks: [sdk, sdk2], tools }
|
|
// await syncData(sdk)
|
|
// sdk.viewer.scene.preRender.addEventListener(syncViewer, syncObject)
|
|
|
|
// sdk.viewer.imageryLayers.layerAdded.addEventListener(syncImageryLayerAdded);
|
|
// sdk.viewer.imageryLayers.layerMoved.addEventListener(syncImageryLayerMoved);
|
|
// sdk.viewer.imageryLayers.layerRemoved.addEventListener(syncImageryLayerRemoved);
|
|
// sdk.viewer.imageryLayers.layerShownOrHidden.addEventListener(syncImageryLayerShownOrHidden);
|
|
// // sdk.viewer.entities.collectionChanged.addEventListener(syncEntities)
|
|
// // sdk.viewer.dataSources.dataSourceAdded.addEventListener(syncDataSources)
|
|
// }
|
|
async function on(sdk) {
|
|
state = true
|
|
if (sdkD) {
|
|
}
|
|
else {
|
|
init(sdk)
|
|
offMultiViewportMode(sdk)
|
|
}
|
|
}
|
|
|
|
function off() {
|
|
state = false
|
|
if (!sdkP) {
|
|
return
|
|
}
|
|
setSplitDirection(-1, undefined, true)
|
|
let sliderElm = sdkP.viewer._element.getElementsByClassName('YJ-custom-slider')[0]
|
|
let leftElm = sdkP.viewer._element.getElementsByClassName('YJ-custom-checkbox-left')[0]
|
|
let rightElm = sdkP.viewer._element.getElementsByClassName('YJ-custom-checkbox-right')[0]
|
|
if (sliderElm) {
|
|
sdkP.viewer._element.removeChild(sliderElm)
|
|
sdkP.viewer._element.removeChild(leftElm)
|
|
sdkP.viewer._element.removeChild(rightElm)
|
|
}
|
|
sdkP.viewer.scene.preRender.removeEventListener(syncViewer, syncObject)
|
|
sdkP.viewer.imageryLayers.layerAdded.removeEventListener(syncImageryLayerAdded);
|
|
sdkP.viewer.imageryLayers.layerMoved.removeEventListener(syncImageryLayerMoved);
|
|
sdkP.viewer.imageryLayers.layerRemoved.removeEventListener(syncImageryLayerRemoved);
|
|
sdkP.viewer.imageryLayers.layerShownOrHidden.removeEventListener(syncImageryLayerShownOrHidden);
|
|
// sdk.viewer.entities.collectionChanged.removeEventListener(syncEntities)
|
|
// sdk.viewer.dataSources.dataSourceAdded.removeEventListener(syncDataSources)
|
|
|
|
//primitiveAdded=undefined基元同步设置在add位置
|
|
// sdk.viewer.scene.primitives.primitiveAdded.removeEventListener(syncPrimitivesAdded)
|
|
for (let i = 0; i < handlers.length; i++) {
|
|
handlers[i].destroy()
|
|
}
|
|
if (sdkD) {
|
|
let rightBox = sdkP.viewer._element.getElementsByClassName('cesium-viewer-cesiumWidgetContainer')[0].getElementsByClassName('cesium-widget')[1]
|
|
sdkP.viewer._element.getElementsByClassName('cesium-viewer-cesiumWidgetContainer')[0].removeChild(rightBox)
|
|
// sdkD.destroy()
|
|
handlers = []
|
|
sdkD = null
|
|
activeViewer = null
|
|
syncObject = {}
|
|
}
|
|
let leftBox = sdkP.viewer._element.getElementsByClassName('cesium-widget')[0]
|
|
let leftCanvas = leftBox.getElementsByTagName('canvas')[0]
|
|
leftBox.style.width = '100%'
|
|
leftCanvas.style.width = '100%'
|
|
sdkP = null
|
|
}
|
|
|
|
|
|
async function init(sdk) {
|
|
sdk.entityMap.forEach((item, key) => {
|
|
if (item.type && item.type == 'TrajectoryMotion' && item.viewFollow) {
|
|
item.viewFollow = false
|
|
}
|
|
})
|
|
let sliderElm = sdk.viewer._element.getElementsByClassName('YJ-custom-slider')[0]
|
|
let leftElm = sdk.viewer._element.getElementsByClassName('YJ-custom-checkbox-left')[0]
|
|
let rightElm = sdk.viewer._element.getElementsByClassName('YJ-custom-checkbox-right')[0]
|
|
if (sliderElm) {
|
|
sdk.viewer._element.removeChild(sliderElm)
|
|
sdk.viewer._element.removeChild(leftElm)
|
|
sdk.viewer._element.removeChild(rightElm)
|
|
}
|
|
sliderElm = document.createElement('div');
|
|
sliderElm.className = 'YJ-custom-slider'
|
|
sliderElm.style.position = 'absolute'
|
|
sliderElm.style.left = '50%'
|
|
sliderElm.style.top = '0px'
|
|
|
|
leftElm = document.createElement('input');
|
|
leftElm.className = 'YJ-custom-checkbox-left'
|
|
leftElm.type = 'checkbox'
|
|
leftElm.style.position = 'absolute'
|
|
leftElm.style.left = 'calc(50% - 50px)'
|
|
rightElm = document.createElement('input');
|
|
rightElm.className = 'YJ-custom-checkbox-right'
|
|
rightElm.type = 'checkbox'
|
|
rightElm.style.position = 'absolute'
|
|
rightElm.style.right = 'calc(50% - 50px)'
|
|
|
|
if (!activeIds || activeIds.length == 0) {
|
|
leftElm.style.display = 'none'
|
|
rightElm.style.display = 'none'
|
|
}
|
|
|
|
sdk.viewer._element.appendChild(leftElm)
|
|
sdk.viewer._element.appendChild(rightElm)
|
|
|
|
let left = 0
|
|
let right = 0
|
|
if (activeIds) {
|
|
for (let i = 0; i < activeIds.length; i++) {
|
|
let status = statusMap.get(activeIds[i])
|
|
if (status) {
|
|
if (status.P) {
|
|
left++
|
|
}
|
|
if (status.D) {
|
|
right++
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
sdkP = sdk
|
|
|
|
if (!left && !right) {
|
|
left++
|
|
}
|
|
leftElm.checked = left ? true : false
|
|
rightElm.checked = right ? true : false
|
|
leftElm.addEventListener('change', (e) => {
|
|
if (!e.target.checked) {
|
|
if (!rightElm.checked) {
|
|
rightElm.checked = true
|
|
}
|
|
}
|
|
for (let i = 0; i < activeIds.length; i++) {
|
|
let status = statusMap.get(activeIds[i])
|
|
status = status || {}
|
|
status.P = e.target.checked
|
|
status.D = rightElm.checked
|
|
statusMap.set(activeIds[i], status)
|
|
}
|
|
changeEntitySplitStatus()
|
|
})
|
|
rightElm.addEventListener('change', (e) => {
|
|
if (!e.target.checked) {
|
|
if (!leftElm.checked) {
|
|
leftElm.checked = true
|
|
}
|
|
}
|
|
for (let i = 0; i < activeIds.length; i++) {
|
|
let status = statusMap.get(activeIds[i])
|
|
status = status || {}
|
|
status.P = leftElm.checked
|
|
status.D = e.target.checked
|
|
statusMap.set(activeIds[i], status)
|
|
}
|
|
changeEntitySplitStatus()
|
|
})
|
|
|
|
sliderElm.addEventListener('mousedown', () => {
|
|
sdk.viewer._element.getElementsByClassName('cesium-viewer-cesiumWidgetContainer')[0].style.cursor = 'e-resize'
|
|
document.body.addEventListener('mousemove', mousemove)
|
|
sliderElm.addEventListener('mouseup', () => {
|
|
sdk.viewer._element.getElementsByClassName('cesium-viewer-cesiumWidgetContainer')[0].style.cursor = 'unset'
|
|
document.body.removeEventListener('mousemove', mousemove)
|
|
})
|
|
})
|
|
|
|
sdk.viewer._element.appendChild(sliderElm)
|
|
|
|
|
|
let leftBox = sdk.viewer._element.getElementsByClassName('cesium-widget')[0]
|
|
let leftCanvas = leftBox.getElementsByTagName('canvas')[0]
|
|
leftBox.style.width = '50%'
|
|
leftBox.style.left = '0px'
|
|
leftBox.style.overflow = 'hidden'
|
|
leftCanvas.style.width = '200%'
|
|
|
|
activeViewer = 0
|
|
let tools = new Tools()
|
|
sdkD = await new YJ.YJEarth(sdk.div_id)
|
|
if (getLeftClickState()) {
|
|
await new openLeftClick(sdkD)
|
|
}
|
|
if (getRightClickState()) {
|
|
await new openRightClick(sdkD)
|
|
}
|
|
if (getMoveState()) {
|
|
await new openMove(sdkD)
|
|
}
|
|
if (getMouseRightMenuStatus(sdk)) {
|
|
MouseRightMenu(sdkD, true)
|
|
}
|
|
sdkD.viewer._element.style.display = 'none'
|
|
let rightBox = document.createElement('div');
|
|
rightBox.className = 'cesium-widget cesium-widget-split'
|
|
rightBox.style.width = '50%'
|
|
rightBox.style.position = 'absolute'
|
|
rightBox.style.right = '0px'
|
|
rightBox.style.overflow = 'hidden'
|
|
let rightCanvas = sdkD.viewer._element.getElementsByClassName('cesium-viewer-cesiumWidgetContainer')[0].getElementsByTagName('canvas')[0]
|
|
rightCanvas.style.width = '200%'
|
|
rightCanvas.style.position = 'absolute'
|
|
rightCanvas.style.right = '0px'
|
|
rightBox.appendChild(rightCanvas)
|
|
sdk.viewer._element.getElementsByClassName('cesium-viewer-cesiumWidgetContainer')[0].appendChild(rightBox)
|
|
document.getElementById(sdk.div_id).removeChild(sdkD.viewer._element)
|
|
|
|
function mousemove(a) {
|
|
if (sdk.viewer._element.getElementsByClassName('cesium-viewer-cesiumWidgetContainer')[0] === a.target ||
|
|
sdk.viewer._element.getElementsByClassName('cesium-widget')[0].getElementsByTagName('canvas')[0] === a.target ||
|
|
sdk.viewer._element.getElementsByClassName('cesium-widget')[1].getElementsByTagName('canvas')[0] === a.target) {
|
|
let offsetX = a.offsetX
|
|
if (a.offsetX < 60) {
|
|
offsetX = 60
|
|
}
|
|
if ((a.target.width - a.offsetX) < 60) {
|
|
offsetX = a.target.width - 60
|
|
}
|
|
sliderElm.style.left = (offsetX / sdk.viewer._element.scrollWidth * 100) + '%'
|
|
leftBox.style.width = (offsetX / sdk.viewer._element.scrollWidth) * 100 + '%'
|
|
leftCanvas.style.width = 100 / (offsetX / sdk.viewer._element.scrollWidth) + '%'
|
|
rightBox.style.width = (1 - (offsetX / sdk.viewer._element.scrollWidth)) * 100 + '%'
|
|
rightCanvas.style.width = 100 / (1 - (offsetX / sdk.viewer._element.scrollWidth)) + '%'
|
|
leftElm.style.left = `calc(${(offsetX / sdk.viewer._element.scrollWidth) * 100}% - 50px)`
|
|
rightElm.style.right = `calc(${(1 - (offsetX / sdk.viewer._element.scrollWidth)) * 100}% - 50px)`
|
|
}
|
|
}
|
|
|
|
await eventBind()
|
|
syncObject = { sdks: [sdk, sdkD], tools }
|
|
|
|
changeEntitySplitStatus()
|
|
// await setSplitDirection(-1)
|
|
sdk.viewer.scene.preRender.addEventListener(syncViewer, syncObject)
|
|
|
|
// sdk.viewer.imageryLayers.layerAdded.addEventListener(syncImageryLayerAdded);
|
|
sdk.viewer.imageryLayers.layerMoved.addEventListener(syncImageryLayerMoved);
|
|
// sdk.viewer.imageryLayers.layerRemoved.addEventListener(syncImageryLayerRemoved);
|
|
// sdk.viewer.imageryLayers.layerShownOrHidden.addEventListener(syncImageryLayerShownOrHidden);
|
|
|
|
if (getFlwStatus(sdk)) {
|
|
FlwStatusSwitch(sdkD, true)
|
|
}
|
|
if (getJwwStatus(sdk)) {
|
|
JwwStatusSwitch(sdkD, true)
|
|
}
|
|
if (getStatus()) {
|
|
SheetIndexStatusSwitch(sdkD, true)
|
|
}
|
|
|
|
function changeEntitySplitStatus(v) {
|
|
let value
|
|
// if (v === undefined || v === null) {
|
|
// if (leftElm.checked && rightElm.checked) {
|
|
// value = 0
|
|
// }
|
|
// else {
|
|
// if (leftElm.checked) {
|
|
// value = -1
|
|
// }
|
|
// if (rightElm.checked) {
|
|
// value = 1
|
|
// }
|
|
// }
|
|
// }
|
|
// else {
|
|
// value = v
|
|
// }
|
|
for (let [key, status] of statusMap) {
|
|
if (!status) {
|
|
value = -1
|
|
}
|
|
else if (status.P && status.D) {
|
|
value = 0
|
|
}
|
|
else {
|
|
if (status.P) {
|
|
value = -1
|
|
}
|
|
if (status.D) {
|
|
value = 1
|
|
}
|
|
}
|
|
// else {
|
|
// value = v
|
|
// }
|
|
let entity = sdk.entityMap.get(key)
|
|
// entity && (entity.splitDirection = value)
|
|
entity && (setSplitDirection(value, key))
|
|
}
|
|
// if (activeIds && activeIds.length > 0) {
|
|
// for (let i = 0; i < activeIds.length; i++) {
|
|
// let entity = sdk.entityMap.get(activeIds[i])
|
|
// // entity && (entity.splitDirection = value)
|
|
// console.log(entity, activeIds, value)
|
|
// entity && (setSplitDirection(value, entity.options.id))
|
|
// }
|
|
// }
|
|
// else {
|
|
// sdk.entityMap.forEach((item, key) => {
|
|
// // item.splitDirection = value
|
|
// setSplitDirection(value, item.options.id)
|
|
// })
|
|
// }
|
|
}
|
|
}
|
|
|
|
// async function syncData(entityId) {
|
|
// if (!sdkP) {
|
|
// return
|
|
// }
|
|
// let entityMapP = sdkP.entityMap
|
|
// let entityMapD = (sdkD && sdkD.entityMap)
|
|
// if (entityId) {
|
|
// let thatD = entityMapD.get(entityId)
|
|
// if (thatD) {
|
|
// let direction = 0
|
|
// if(thatD.show) {
|
|
// direction =
|
|
// }
|
|
// thatD.remove()
|
|
// }
|
|
// setSplitDirection(entityId)
|
|
// }
|
|
// // else {
|
|
// // for (let [key, thatP] of sdkP.entityMap) {
|
|
// // if (!thatP || !thatP.show) {
|
|
// // continue
|
|
// // }
|
|
// // else {
|
|
// // setEvent(key)
|
|
// // }
|
|
// // }
|
|
// // }
|
|
// }
|
|
|
|
async function setSplitDirection(v, id, isoff = false, entityId) {
|
|
if (!sdkP) {
|
|
return
|
|
}
|
|
|
|
let entityMapP = sdkP.entityMap
|
|
let entityMapD = (sdkD && sdkD.entityMap)
|
|
if (id) {
|
|
let thatP = entityMapP.get(id)
|
|
if (!thatP || !thatP.show) {
|
|
return
|
|
}
|
|
setEvent(id, entityId)
|
|
}
|
|
else {
|
|
for (let [key, thatP] of sdkP.entityMap) {
|
|
if (!thatP || !thatP.show) {
|
|
continue
|
|
}
|
|
else {
|
|
setEvent(key, entityId)
|
|
}
|
|
}
|
|
}
|
|
|
|
async function setEvent(id, entityId) {
|
|
let status = {}
|
|
let thatP = entityMapP.get(id)
|
|
if (!thatP && !thatP.show) {
|
|
return
|
|
}
|
|
let thatD = (entityMapD && entityMapD.get(id))
|
|
if (thatD) {
|
|
switch (v) {
|
|
case null:
|
|
case void 0:
|
|
case 0:
|
|
case '0':
|
|
status.P = true
|
|
status.D = true
|
|
if (thatP.type === 'TrajectoryMotion') {
|
|
if (thatP.entity && thatP.modelShow && !thatP.firstPersonView) {
|
|
thatP.entity.show = true
|
|
}
|
|
if (thatP.line && thatP.lineShow) {
|
|
thatP.line.show = true
|
|
}
|
|
if (thatP.realTimeLine && thatP.realTimeRoute) {
|
|
thatP.realTimeLine.show = true
|
|
}
|
|
if (thatP.TweenAnimate) {
|
|
let state = thatP.state
|
|
if (state) {
|
|
thatPstate(false)
|
|
}
|
|
thatD.setMovePositionByDistance(thatP.TweenAnimate._object.distance)
|
|
thatPstate(state)
|
|
}
|
|
|
|
function thatPstate(v) {
|
|
thatP.options.state = v
|
|
cancelAnimationFrame(thatP._requestAnimationFrameEventId)
|
|
if (thatP.editObj) {
|
|
thatP.editObj.destroy()
|
|
thatP.editObj = null
|
|
}
|
|
if (thatP.TweenAnimate) {
|
|
clearTimeout(thatP.TweenAnimate.timeout)
|
|
if (v) {
|
|
thatP.lineEdit = false
|
|
if (thatP.TweenAnimate.isPlaying()) {
|
|
thatP.TweenAnimate.timeout = setTimeout(() => {
|
|
thatP.TweenAnimate.resume()
|
|
}, thatP.options.delay);
|
|
}
|
|
else {
|
|
thatP.TweenAnimate.delay(thatP.delay).start()
|
|
}
|
|
}
|
|
else {
|
|
let positionCamera = { ...thatP.sdk.viewer.camera._position }
|
|
thatP._requestAnimationFrameEventId = requestAnimationFrame(function fn() {
|
|
if (thatP.firstPersonView) {
|
|
thatP.sdk.viewer.camera.setView({
|
|
destination: { ...positionCamera },
|
|
orientation: {
|
|
heading: thatP.sdk.viewer.camera.heading,
|
|
pitch: thatP.sdk.viewer.camera.pitch,
|
|
roll: thatP.sdk.viewer.camera.roll
|
|
}
|
|
})
|
|
}
|
|
thatP._requestAnimationFrameEventId = requestAnimationFrame(fn)
|
|
})
|
|
thatP.TweenAnimate.pause()
|
|
}
|
|
}
|
|
else {
|
|
if (v) {
|
|
let positions = thatP.renewLinePositions(thatP.options.line.positions)
|
|
thatP.modelMove(positions)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (thatP.type === 'vector') {
|
|
if (thatP.entity) {
|
|
if (entityId) {
|
|
for (let i = 0; i < thatP.entity.entities.values.length; i++) {
|
|
if (thatP.entity.entities.values[i].id === entityId) {
|
|
thatP.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (let i = 0; i < thatP.entity.entities.values.length; i++) {
|
|
thatP.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
thatP.entity && (thatP.entity.show = true)
|
|
}
|
|
if (thatP.type === 'PincerArrowObject') {
|
|
if (thatP.TweenAnimate && !thatP.TweenAnimate._isPaused) {
|
|
thatP.setSpreadProgressByTime(thatP.TweenAnimate._object.distance1 / thatP.TweenAnimate._valuesEnd.distance1 * thatP.spreadTime)
|
|
}
|
|
}
|
|
if (thatP.type === 'AttackArrowObject' || thatP.type === 'StraightArrowObject') {
|
|
if (thatP.TweenAnimate && !thatP.TweenAnimate._isPaused) {
|
|
thatP.setSpreadProgressByTime(thatP.TweenAnimate._object.distance / thatP.TweenAnimate._valuesEnd.distance * thatP.spreadTime)
|
|
}
|
|
}
|
|
if (thatP.type === 'GroundSvg' && thatP.text) {
|
|
thatP.text.show = thatP.textShow
|
|
thatD.textShow = thatP.textShow
|
|
}
|
|
if (thatP.label && thatP.labelShow) {
|
|
thatP.labelShow = true
|
|
}
|
|
if (thatD.label) {
|
|
thatD.label.options.ground = false
|
|
}
|
|
if (thatD.type === 'vector') {
|
|
if (thatD.entity) {
|
|
if (entityId) {
|
|
for (let i = 0; i < thatD.entity.entities.values.length; i++) {
|
|
if (thatD.entity.entities.values[i].id === entityId) {
|
|
thatD.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (let i = 0; i < thatD.entity.entities.values.length; i++) {
|
|
thatD.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
thatD.show = true
|
|
}
|
|
if (thatD.type === 'TrajectoryMotion') {
|
|
thatD.firstPersonView = thatP.firstPersonView
|
|
}
|
|
if (thatD.type === 'Explosion') {
|
|
thatD.entity.imgIndex = thatP.entity.imgIndex
|
|
}
|
|
break
|
|
case 1:
|
|
case '1':
|
|
status.P = false
|
|
status.D = true
|
|
if (thatP.type === 'TrajectoryMotion') {
|
|
thatP.entity && (thatP.entity.show = false)
|
|
thatP.line && (thatP.line.show = false)
|
|
thatP.realTimeLine && (thatP.realTimeLine.show = false)
|
|
}
|
|
else if (thatP.type === 'vector') {
|
|
if (thatP.entity) {
|
|
if (!entityId) {
|
|
for (let i = 0; i < thatP.entity.entities.values.length; i++) {
|
|
thatP.entity.entities.values[i].show = false
|
|
}
|
|
}
|
|
else {
|
|
for (let i = 0; i < thatP.entity.entities.values.length; i++) {
|
|
if (thatP.entity.entities.values[i].id === entityId) {
|
|
thatP.entity.entities.values[i].show = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
thatP.entity && (thatP.entity.show = false)
|
|
}
|
|
if (thatP.type === 'PincerArrowObject') {
|
|
if (thatP.TweenAnimate && !thatP.TweenAnimate._isPaused) {
|
|
thatP.setSpreadProgressByTime(thatP.TweenAnimate._object.distance1 / thatP.TweenAnimate._valuesEnd.distance1 * thatP.spreadTime)
|
|
}
|
|
}
|
|
if (thatP.type === 'AttackArrowObject' || thatP.type === 'StraightArrowObject') {
|
|
if (thatP.TweenAnimate && !thatP.TweenAnimate._isPaused) {
|
|
thatP.setSpreadProgressByTime(thatP.TweenAnimate._object.distance / thatP.TweenAnimate._valuesEnd.distance * thatP.spreadTime)
|
|
}
|
|
}
|
|
|
|
if (thatP.type === 'GroundSvg' && thatP.text) {
|
|
thatP.text.show = false
|
|
thatD.textShow = thatP.textShow
|
|
}
|
|
if (thatP.label) {
|
|
thatP.label.entity.show = false
|
|
}
|
|
if (thatD.label) {
|
|
thatD.label.options.ground = false
|
|
}
|
|
if (thatD.type === 'vector') {
|
|
if (thatD.entity) {
|
|
if (entityId) {
|
|
for (let i = 0; i < thatD.entity.entities.values.length; i++) {
|
|
if (thatD.entity.entities.values[i].id === entityId) {
|
|
thatD.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (let i = 0; i < thatD.entity.entities.values.length; i++) {
|
|
thatD.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else {
|
|
thatD.show = true
|
|
}
|
|
if (thatD.type === 'TrajectoryMotion') {
|
|
thatD.firstPersonView = thatP.firstPersonView
|
|
}
|
|
break
|
|
case -1:
|
|
case '-1':
|
|
status.P = true
|
|
status.D = false
|
|
if (thatP.type === 'TrajectoryMotion') {
|
|
if (thatP.entity && thatP.modelShow && !thatP.firstPersonView) {
|
|
thatP.entity.show = true
|
|
}
|
|
if (thatP.line && thatP.lineShow) {
|
|
thatP.line.show = true
|
|
}
|
|
if (thatP.realTimeLine && thatP.realTimeRoute) {
|
|
thatP.realTimeLine.show = true
|
|
}
|
|
// if (thatP.TweenAnimate) {
|
|
// let state = thatP.state
|
|
// if (state) {
|
|
// thatP.state = false
|
|
// }
|
|
// thatD.setMovePositionByDistance(thatP.TweenAnimate._object.distance)
|
|
// thatP.state = state
|
|
// }
|
|
}
|
|
else if (thatP.type === 'vector') {
|
|
if (thatP.entity) {
|
|
if (entityId) {
|
|
for (let i = 0; i < thatP.entity.entities.values.length; i++) {
|
|
if (thatP.entity.entities.values[i].id === entityId) {
|
|
thatP.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (let i = 0; i < thatP.entity.entities.values.length; i++) {
|
|
thatP.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
thatP.entity && (thatP.entity.show = true)
|
|
}
|
|
if (thatP.type === 'GroundSvg' && thatP.text) {
|
|
thatP.text.show = thatP.textShow
|
|
thatD.textShow = false
|
|
}
|
|
if (thatP.label && thatP.labelShow) {
|
|
thatP.label.entity.show = true
|
|
}
|
|
if (thatD.label) {
|
|
thatD.label.options.ground = false
|
|
}
|
|
if (thatP.type === 'terrain') {
|
|
thatD.show = true
|
|
}
|
|
else if (thatD.type === 'vector') {
|
|
if (thatD.entity) {
|
|
if (entityId) {
|
|
for (let i = 0; i < thatD.entity.entities.values.length; i++) {
|
|
if (thatD.entity.entities.values[i].id === entityId) {
|
|
if (thatD.entity.entities.values[i].id === entityId) {
|
|
thatD.entity.entities.values[i].show = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (let i = 0; i < thatD.entity.entities.values.length; i++) {
|
|
thatD.entity.entities.values[i].show = false
|
|
}
|
|
}
|
|
|
|
}
|
|
} else {
|
|
thatD.show = false
|
|
}
|
|
break
|
|
}
|
|
}
|
|
else {
|
|
let options = syncObject.tools.deepCopyObj(thatP.options)
|
|
let target
|
|
switch (v) {
|
|
case null:
|
|
case void 0:
|
|
case 0:
|
|
case '0':
|
|
status.P = true
|
|
status.D = true
|
|
options.show = true
|
|
if(thatP.type==='layer') {
|
|
options.layer_index = thatP.layer_index
|
|
}
|
|
target = await new thatP.constructor(sdkD, options)
|
|
if (thatP.onClick) {
|
|
target.onClick = thatP.onClick
|
|
}
|
|
if (thatP.onRightClick) {
|
|
target.onRightClick = thatP.onRightClick
|
|
}
|
|
if (thatP.onMouseMove) {
|
|
target.onMouseMove = thatP.onMouseMove
|
|
}
|
|
if (thatP.type === 'TrajectoryMotion') {
|
|
if (thatP.entity && thatP.modelShow && !thatP.firstPersonView) {
|
|
thatP.entity.show = true
|
|
}
|
|
if (thatP.line && thatP.lineShow) {
|
|
thatP.line.show = true
|
|
}
|
|
if (thatP.realTimeLine && thatP.realTimeRoute) {
|
|
thatP.realTimeLine.show = true
|
|
}
|
|
if (thatP.TweenAnimate) {
|
|
let state = thatP.state
|
|
if (state) {
|
|
thatP.state = false
|
|
}
|
|
target.setMovePositionByDistance(thatP.TweenAnimate._object.distance)
|
|
thatP.state = state
|
|
}
|
|
}
|
|
else {
|
|
if (target.type !== 'glb' && target.on) {
|
|
if (target.type === 'vector') {
|
|
target.data = thatP.data
|
|
}
|
|
await target.on()
|
|
}
|
|
if (target.type === 'Explosion') {
|
|
target.entity.imgIndex = thatP.entity.imgIndex
|
|
}
|
|
if (target.type === 'PincerArrowObject') {
|
|
if (thatP.TweenAnimate && !thatP.TweenAnimate._isPaused) {
|
|
target.setSpreadProgressByTime(thatP.TweenAnimate._object.distance1 / thatP.TweenAnimate._valuesEnd.distance1 * thatP.spreadTime)
|
|
}
|
|
}
|
|
if (target.type === 'AttackArrowObject' || target.type === 'StraightArrowObject') {
|
|
if (thatP.TweenAnimate && !thatP.TweenAnimate._isPaused) {
|
|
target.setSpreadProgressByTime(thatP.TweenAnimate._object.distance / thatP.TweenAnimate._valuesEnd.distance * thatP.spreadTime)
|
|
}
|
|
}
|
|
|
|
if (thatP.type === 'vector') {
|
|
target.load(() => {
|
|
if (target.entity) {
|
|
if (entityId) {
|
|
for (let i = 0; i < target.entity.entities.values.length; i++) {
|
|
if (target.entity.entities.values[i].id === entityId) {
|
|
target.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (let i = 0; i < target.entity.entities.values.length; i++) {
|
|
target.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
thatP.entity && (thatP.entity.show = true)
|
|
}
|
|
if (thatP.type === 'GroundSvg' && thatP.text) {
|
|
thatP.text.show = thatP.textShow
|
|
target.textShow = thatP.textShow
|
|
}
|
|
if (thatP.label && thatP.labelShow) {
|
|
thatP.label.entity.show = true
|
|
}
|
|
break
|
|
case 1:
|
|
case '1':
|
|
status.P = false
|
|
status.D = true
|
|
options.show = true
|
|
if(thatP.type==='layer') {
|
|
options.layer_index = thatP.layer_index
|
|
}
|
|
target = await new thatP.constructor(sdkD, options)
|
|
if (thatP.onClick) {
|
|
target.onClick = thatP.onClick
|
|
}
|
|
if (thatP.onRightClick) {
|
|
target.onRightClick = thatP.onRightClick
|
|
}
|
|
if (thatP.onMouseMove) {
|
|
target.onMouseMove = thatP.onMouseMove
|
|
}
|
|
if (thatP.type === 'TrajectoryMotion') {
|
|
if (thatP.entity && thatP.modelShow) {
|
|
thatP.entity.show = false
|
|
}
|
|
if (thatP.line && thatP.lineShow) {
|
|
thatP.line.show = false
|
|
}
|
|
if (thatP.realTimeLine && thatP.realTimeRoute) {
|
|
thatP.realTimeLine.show = false
|
|
}
|
|
if (thatP.TweenAnimate) {
|
|
let state = thatP.state
|
|
if (state) {
|
|
thatP.state = false
|
|
}
|
|
target.setMovePositionByDistance(thatP.TweenAnimate._object.distance)
|
|
thatP.state = state
|
|
}
|
|
}
|
|
else {
|
|
if (target.type !== 'glb' && target.on) {
|
|
if (thatP.type === 'vector') {
|
|
target.data = thatP.data
|
|
if (thatP.entity) {
|
|
for (let i = 0; i < thatP.entity.entities.values.length; i++) {
|
|
thatP.entity.entities.values[i].show = false
|
|
}
|
|
}
|
|
}
|
|
await target.on()
|
|
}
|
|
if (thatP.type === 'vector') {
|
|
if (target.entity) {
|
|
if (entityId) {
|
|
for (let i = 0; i < target.entity.entities.values.length; i++) {
|
|
if (target.entity.entities.values[i].id === entityId) {
|
|
target.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (let i = 0; i < target.entity.entities.values.length; i++) {
|
|
target.entity.entities.values[i].show = thatP.entity.entities.values[i]._customShow === false ? false : true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
thatP.entity && (thatP.entity.show = false)
|
|
}
|
|
}
|
|
|
|
if (thatP.type === 'GroundSvg' && thatP.text) {
|
|
thatP.text.show = false
|
|
target.textShow = thatP.textShow
|
|
}
|
|
if (thatP.label) {
|
|
thatP.label.entity.show = false
|
|
}
|
|
break
|
|
case -1:
|
|
case '-1':
|
|
status.P = true
|
|
status.D = false
|
|
if (thatP.type === 'TrajectoryMotion') {
|
|
if (thatP.entity && thatP.modelShow && !thatP.firstPersonView) {
|
|
thatP.entity.show = true
|
|
}
|
|
if (thatP.line && thatP.lineShow) {
|
|
thatP.line.show = true
|
|
}
|
|
if (thatP.realTimeLine && thatP.realTimeRoute) {
|
|
thatP.realTimeLine.show = true
|
|
}
|
|
// if (thatP.TweenAnimate) {
|
|
// let state = thatP.state
|
|
// if (state) {
|
|
// thatP.state = false
|
|
// }
|
|
// target.setMovePositionByDistance(thatP.TweenAnimate._object.distance)
|
|
// thatP.state = state
|
|
// }
|
|
}
|
|
else {
|
|
thatP.entity && (thatP.entity.show = true)
|
|
if (thatP.type === 'terrain') {
|
|
options.show = true
|
|
target = await new thatP.constructor(sdkD, options)
|
|
if (thatP.onClick) {
|
|
target.onClick = thatP.onClick
|
|
}
|
|
if (thatP.onRightClick) {
|
|
target.onRightClick = thatP.onRightClick
|
|
}
|
|
if (thatP.onMouseMove) {
|
|
target.onMouseMove = thatP.onMouseMove
|
|
}
|
|
}
|
|
}
|
|
if (thatP.type === 'GroundSvg' && thatP.text) {
|
|
thatP.text.show = thatP.textShow
|
|
target.textShow = false
|
|
}
|
|
if (thatP.label && thatP.labelShow) {
|
|
thatP.label.entity.show = true
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
if (!isoff) {
|
|
statusMap.set(id, status)
|
|
}
|
|
}
|
|
|
|
if (isoff) {
|
|
return
|
|
}
|
|
// let leftElm = sdkP.viewer._element.getElementsByClassName('YJ-custom-checkbox-left')[0]
|
|
// let rightElm = sdkP.viewer._element.getElementsByClassName('YJ-custom-checkbox-right')[0]
|
|
// if (leftElm && rightElm) {
|
|
// switch (v) {
|
|
// case null:
|
|
// case void 0:
|
|
// case 0:
|
|
// case '0':
|
|
// leftElm.checked = true
|
|
// rightElm.checked = true
|
|
// break
|
|
// case 1:
|
|
// case '1':
|
|
// leftElm.checked = false
|
|
// rightElm.checked = true
|
|
// break
|
|
// case -1:
|
|
// case '-1':
|
|
// leftElm.checked = true
|
|
// rightElm.checked = false
|
|
// break
|
|
// }
|
|
// }
|
|
|
|
}
|
|
|
|
function syncEntities(entities1, entities2) {
|
|
if (!sdkP) {
|
|
return
|
|
}
|
|
if (sdkD) {
|
|
if (Array.isArray(entities1) || Array.isArray(entities2)) {
|
|
entities1 = null
|
|
entities2 = null
|
|
}
|
|
if (!entities1) {
|
|
entities1 = sdkD.viewer.entities
|
|
}
|
|
if (!entities2) {
|
|
entities2 = sdkP.viewer.entities
|
|
}
|
|
let entities2D = entities1
|
|
let entities3D = entities2
|
|
for (let i = entities2D.values.length - 1; i >= 0; i--) {
|
|
let flag = false
|
|
for (let m = entities3D.values.length - 1; m >= 0; m--) {
|
|
if (entities2D.values[i].id === entities3D.values[m].id) {
|
|
flag = true
|
|
entities2D.values[i] === entities3D.values[m]
|
|
}
|
|
}
|
|
if (!flag) {
|
|
entities2D.remove(entities2D.values[i])
|
|
}
|
|
}
|
|
for (let m = entities3D.values.length - 1; m >= 0; m--) {
|
|
let flag = false
|
|
for (let i = entities2D.values.length - 1; i >= 0; i--) {
|
|
if (entities2D.values[i].id === entities3D.values[m].id) {
|
|
flag = true
|
|
break
|
|
}
|
|
}
|
|
if (!flag) {
|
|
let entity = entities2D.add(entities3D.values[m])
|
|
// if (entity.rectangle) {
|
|
// // 设置高度，否则在某些位置无法显示，但色彩会变暗
|
|
// entity.rectangle.height = 0
|
|
// console.log('242342354235',entities3D.values[m])
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function syncDataSources(dataSources, type) {
|
|
if (!sdkP) {
|
|
return
|
|
}
|
|
if (sdkD) {
|
|
let dataSources2D = sdkD.viewer.dataSources
|
|
if (dataSources) {
|
|
for (let i = dataSources2D._dataSources.length - 1; i >= 0; i--) {
|
|
if (dataSources2D._dataSources[i].name === dataSources.name) {
|
|
if (type === 'entities') {
|
|
syncEntities(dataSources2D._dataSources[i].entities, dataSources.entities)
|
|
}
|
|
if (type === 'clustering') {
|
|
dataSources2D._dataSources[i].clustering.enabled = dataSources.clustering.enabled
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// for (let m = dataSources3D._dataSources.length - 1; m >= 0; m--) {
|
|
// let flag = false
|
|
// for (let i = dataSources2D._dataSources.length - 1; i >= 0; i--) {
|
|
// console.log(dataSources2D._dataSources[i].name, dataSources3D._dataSources[m].name)
|
|
// if (dataSources2D._dataSources[i].name === dataSources3D._dataSources[m].name) {
|
|
// flag = true
|
|
// break
|
|
// }
|
|
// }
|
|
// if (!flag) {
|
|
// dataSources2D.add(dataSources3D._dataSources[m])
|
|
// }
|
|
// }
|
|
}
|
|
}
|
|
function syncImageryLayerAdded(layer, index) {
|
|
sdkD.viewer.imageryLayers.addImageryProvider(layer.imageryProvider, index)
|
|
}
|
|
function syncImageryLayerMoved(layer, newindxe, oldindex) {
|
|
let layerD
|
|
for (let i = 0; i < sdkD.viewer.imageryLayers._layers.length; i++) {
|
|
if (sdkD.viewer.imageryLayers._layers[i]._id === layer._id) {
|
|
layerD = sdkD.viewer.imageryLayers._layers[i]
|
|
break
|
|
}
|
|
}
|
|
if (!layerD) {
|
|
return
|
|
}
|
|
// 移到最底层
|
|
if (newindxe === 0) {
|
|
sdkD.viewer.imageryLayers.lowerToBottom(layerD)
|
|
}
|
|
// 移到最高层
|
|
else if (newindxe === sdkD.viewer.imageryLayers._layers.length - 1) {
|
|
sdkD.viewer.imageryLayers.raiseToTop(layerD)
|
|
}
|
|
else {
|
|
if (newindxe < oldindex) {
|
|
if(newindxe<sdkD.viewer.imageryLayers._layers.length-1) {
|
|
sdkD.viewer.imageryLayers.lower(layerD)
|
|
}
|
|
}
|
|
else {
|
|
sdkD.viewer.imageryLayers.raise(layerD)
|
|
}
|
|
}
|
|
}
|
|
function syncImageryLayerRemoved(layer, index) {
|
|
let layerD = sdkD.viewer.imageryLayers._layers[index]
|
|
if (!layerD) {
|
|
return
|
|
}
|
|
sdkD.viewer.imageryLayers.remove(layerD)
|
|
}
|
|
function syncImageryLayerShownOrHidden(layer, index, state) {
|
|
let layerD = sdkD.viewer.imageryLayers._layers[index]
|
|
if (!layerD) {
|
|
return
|
|
}
|
|
layerD.show = state
|
|
}
|
|
|
|
async function syncPrimitives(primitive) {
|
|
if (!sdkP) {
|
|
return
|
|
}
|
|
if (sdkD) {
|
|
// await sdkD.viewer.scene.primitives.remove(primitive)
|
|
// await sdkD.viewer.scene.primitives.add(primitive)
|
|
let primitives2D = sdkD.viewer.scene.primitives._primitives
|
|
let primitives3D = sdkP.viewer.scene.primitives._primitives
|
|
// console.log(primitives2D, primitives3D)
|
|
// setTimeout(() => {
|
|
// sdkD.viewer.scene.primitives._primitives[1] = sdkP.viewer.scene.primitives._primitives[1]
|
|
// }, 2000);
|
|
for (let i = primitives2D.length - 1; i >= 1; i--) {
|
|
let flag = false
|
|
for (let m = primitives3D.length - 1; m >= 1; m--) {
|
|
if (primitives3D[m].id && primitives2D[m].id && (primitives3D[m].id === primitives2D[i].id)) {
|
|
flag = true
|
|
}
|
|
}
|
|
if (!flag) {
|
|
sdkD.viewer.scene.primitives.remove(primitives2D[i])
|
|
}
|
|
}
|
|
for (let m = primitives3D.length - 1; m >= 1; m--) {
|
|
let flag = false
|
|
for (let i = primitives2D.length - 1; i >= 1; i--) {
|
|
if (primitives3D[m].id && primitives2D[m].id && (primitives3D[m].id === primitives2D[i].id)) {
|
|
flag = true
|
|
primitives2D[i].show = primitives3D[m].show
|
|
primitives2D[i].startColor = primitives3D[m].startColor
|
|
primitives2D[i].endColor = primitives3D[m].endColor
|
|
primitives2D[i].minimumSpeed = primitives3D[m].minimumSpeed
|
|
primitives2D[i].maximumSpeed = primitives3D[m].maximumSpeed
|
|
primitives2D[i].minimumParticleLife = primitives3D[m].minimumParticleLife
|
|
primitives2D[i].maximumParticleLife = primitives3D[m].maximumParticleLife
|
|
primitives2D[i].startScale = primitives3D[m].startScale
|
|
primitives2D[i].endScale = primitives3D[m].endScale
|
|
primitives2D[i].emissionRate = primitives3D[m].emissionRate
|
|
primitives2D[i].particleSize = primitives3D[m].particleSize
|
|
primitives2D[i].modelMatrix = primitives3D[m].modelMatrix
|
|
}
|
|
}
|
|
if (!flag) {
|
|
sdkD.viewer.scene.primitives.add(primitives3D[m])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function eventBind() {
|
|
let handler0 = new Cesium.ScreenSpaceEventHandler(
|
|
sdkP.viewer._element.getElementsByClassName('cesium-widget')[0]
|
|
)
|
|
handler0.setInputAction(() => {
|
|
activeViewer = 0
|
|
}, Cesium.ScreenSpaceEventType.LEFT_DOWN)
|
|
handler0.setInputAction(() => {
|
|
activeViewer = 0
|
|
}, Cesium.ScreenSpaceEventType.RIGHT_DOWN)
|
|
handler0.setInputAction(() => {
|
|
activeViewer = 0
|
|
}, Cesium.ScreenSpaceEventType.WHEEL)
|
|
handlers.push(handler0)
|
|
|
|
let distanceLegendDiv = document.getElementById('distanceLegendDiv')
|
|
function distanceLegendDivMouseMove(e) {
|
|
activeViewer = 0
|
|
}
|
|
distanceLegendDiv.addEventListener('mousemove', distanceLegendDivMouseMove)
|
|
handlers.push({
|
|
destroy: () => {
|
|
distanceLegendDiv.removeEventListener('mousemove', distanceLegendDivMouseMove)
|
|
}
|
|
})
|
|
|
|
|
|
let handler1 = new Cesium.ScreenSpaceEventHandler(
|
|
sdkP.viewer._element.getElementsByClassName('cesium-widget')[1]
|
|
)
|
|
handler1.setInputAction(() => {
|
|
activeViewer = 1
|
|
closeRotateAround(sdkP)
|
|
}, Cesium.ScreenSpaceEventType.LEFT_DOWN)
|
|
handler1.setInputAction(() => {
|
|
activeViewer = 1
|
|
closeRotateAround(sdkP)
|
|
}, Cesium.ScreenSpaceEventType.RIGHT_DOWN)
|
|
handler1.setInputAction(() => {
|
|
activeViewer = 1
|
|
closeRotateAround(sdkP)
|
|
}, Cesium.ScreenSpaceEventType.WHEEL)
|
|
handlers.push(handler1)
|
|
}
|
|
|
|
function syncViewer() {
|
|
let sdk = this.sdks[activeViewer]
|
|
let sdk2
|
|
if (activeViewer === 0) {
|
|
sdk2 = this.sdks[1]
|
|
}
|
|
else if (activeViewer === 1) {
|
|
sdk2 = this.sdks[0]
|
|
}
|
|
let destination = sdk.viewer.camera.position
|
|
// if (this.sdks[0].viewer.trackedEntity) {
|
|
// // console.log(sdk,sdk2)
|
|
// // sdk2.viewer.camera.setView({
|
|
// // orientation: {
|
|
// // heading: sdk.viewer.camera.heading,
|
|
// // pitch: sdk.viewer.camera.pitch,
|
|
// // roll: sdk.viewer.camera.roll
|
|
// // }
|
|
// // })
|
|
// // if(sdk2.viewer.trackedEntity) {
|
|
// // sdk2.viewer.trackedEntity.position = sdk.viewer.trackedEntity.position
|
|
// // }
|
|
// // else {
|
|
// // let trackedEntity = sdk2.viewer.entities.add(sdk.viewer.trackedEntity)
|
|
// // sdk2.viewer.trackedEntity = trackedEntity
|
|
// // }
|
|
// // sdk2.viewer.camera.position = sdk.viewer.camera.position
|
|
// if(!sdk.viewer.trackedEntity) {
|
|
// let id = this.sdks[0].viewer.trackedEntity.id
|
|
// let trackedEntity = sdk2.viewer.entities.getById(id)
|
|
// if(trackedEntity) {
|
|
// trackedEntity.position = this.sdks[0].viewer.trackedEntity.position
|
|
// }
|
|
// else {
|
|
// trackedEntity = sdk2.viewer.entities.add(sdk.viewer.trackedEntity)
|
|
// }
|
|
// sdk.viewer.trackedEntity = trackedEntity
|
|
// }
|
|
// else {
|
|
// sdk.viewer.trackedEntity.position = this.sdks[0].viewer.trackedEntity.position
|
|
// }
|
|
// let distance = Cesium.Cartesian3.distance(sdk.viewer.trackedEntity.position._value, sdk.viewer.camera.positionWC);
|
|
// sdk2.viewer.camera.lookAt(
|
|
// this.sdks[0].viewer.trackedEntity.position._value,
|
|
// new Cesium.HeadingPitchRange(sdk.viewer.camera.heading, sdk.viewer.camera.pitch, distance)
|
|
// )
|
|
// }
|
|
// else {
|
|
// if(this.sdks[1].viewer.trackedEntity) {
|
|
// this.sdks[1].viewer.entities.remove(this.sdks[1].viewer.trackedEntity)
|
|
// this.sdks[1].viewer.trackedEntity = null
|
|
// destination = sdk.viewer.camera.position
|
|
// }
|
|
// sdk2.viewer.camera.setView({
|
|
// destination: destination,
|
|
// orientation: {
|
|
// heading: sdk.viewer.camera.heading,
|
|
// pitch: sdk.viewer.camera.pitch,
|
|
// roll: sdk.viewer.camera.roll
|
|
// }
|
|
// })
|
|
// }
|
|
|
|
sdk2.viewer.camera.setView({
|
|
destination: destination,
|
|
orientation: {
|
|
heading: sdk.viewer.camera.heading,
|
|
pitch: sdk.viewer.camera.pitch,
|
|
roll: sdk.viewer.camera.roll
|
|
}
|
|
})
|
|
|
|
}
|
|
|
|
function getState() {
|
|
return state
|
|
}
|
|
|
|
function getActiveId() {
|
|
return activeIds
|
|
}
|
|
|
|
function setActiveId(ids = []) {
|
|
// console.log('=================================')
|
|
if (Array.isArray(ids)) {
|
|
activeIds = ids
|
|
}
|
|
else {
|
|
activeIds = [ids]
|
|
}
|
|
if (!sdkP || !sdkD) {
|
|
return
|
|
}
|
|
let leftElm = sdkP.viewer._element.getElementsByClassName('YJ-custom-checkbox-left')[0]
|
|
let rightElm = sdkP.viewer._element.getElementsByClassName('YJ-custom-checkbox-right')[0]
|
|
if (!ids || ids.length === 0) {
|
|
if (leftElm && rightElm) {
|
|
leftElm.style.display = 'none'
|
|
rightElm.style.display = 'none'
|
|
}
|
|
}
|
|
else {
|
|
if (leftElm && rightElm) {
|
|
let left = 0
|
|
let right = 0
|
|
for (let i = 0; i < activeIds.length; i++) {
|
|
let status = statusMap.get(activeIds[i])
|
|
if (!status) {
|
|
status = { P: true, D: false }
|
|
statusMap.set(activeIds[i], status)
|
|
}
|
|
if (status.P) {
|
|
left++
|
|
}
|
|
if (status.D) {
|
|
right++
|
|
}
|
|
|
|
|
|
let thatP = sdkP.entityMap.get(activeIds[i])
|
|
let thatD = sdkD.entityMap.get(activeIds[i])
|
|
if (!thatP || (thatP.type === 'terrain' || !thatP.show)) {
|
|
leftElm.style.display = 'none'
|
|
rightElm.style.display = 'none'
|
|
continue
|
|
}
|
|
leftElm.style.display = 'unset'
|
|
rightElm.style.display = 'unset'
|
|
leftElm.checked = false
|
|
rightElm.checked = false
|
|
|
|
|
|
// if (thatP) {
|
|
// if (thatP.type === 'TrajectoryMotion') {
|
|
// if (thatP.entity && (thatP.modelShow || thatP.lineShow || thatP.labelShow || thatP.realTimeRoute) && (thatP.entity.show || thatP.line.show || (thatP.label && thatP.label.entity.show) || thatP.realTimeLine.show)) {
|
|
// leftElm.checked = true
|
|
// }
|
|
// }
|
|
// else if (thatP.type === 'vector') {
|
|
// leftElm.checked = status.P
|
|
// }
|
|
// else {
|
|
// if (thatP.entity && thatP.entity.show) {
|
|
// leftElm.checked = true
|
|
// }
|
|
// }
|
|
// }
|
|
// if (thatD) {
|
|
// if (thatP.type === 'TrajectoryMotion') {
|
|
// if (thatD.show && thatD.entity && (thatD.modelShow || thatD.lineShow || thatD.labelShow || thatD.realTimeRoute) && (thatD.entity.show || thatD.line.show || (thatD.label && thatD.label.entity.show) || thatD.realTimeLine.show)) {
|
|
// rightElm.checked = true
|
|
// }
|
|
// }
|
|
// else if (thatP.type === 'vector') {
|
|
// rightElm.checked = status.D
|
|
// }
|
|
// else {
|
|
// if (thatD.show) {
|
|
// rightElm.checked = true
|
|
// }
|
|
// }
|
|
// }
|
|
}
|
|
if (!left && !right) {
|
|
left++
|
|
}
|
|
leftElm.checked = left ? true : false
|
|
rightElm.checked = right ? true : false
|
|
}
|
|
}
|
|
}
|
|
|
|
function syncSplitData(sdk, id, entityId) {
|
|
if (!sdkP || !sdkD || sdk !== sdkP || !id) {
|
|
return
|
|
}
|
|
let status = statusMap.get(id)
|
|
let thatP = sdkP.entityMap.get(id)
|
|
let thatD = sdkD.entityMap.get(id)
|
|
if (thatP) {
|
|
let value
|
|
if (status) {
|
|
if (status.P && status.D) {
|
|
value = 0
|
|
}
|
|
else {
|
|
if (status.P) {
|
|
value = -1
|
|
}
|
|
if (status.D) {
|
|
value = 1
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
let leftElm = sdk.viewer._element.getElementsByClassName('YJ-custom-checkbox-left')[0]
|
|
let rightElm = sdk.viewer._element.getElementsByClassName('YJ-custom-checkbox-right')[0]
|
|
if (leftElm.style.display === 'none' || rightElm.style.display === 'none') {
|
|
value = -1
|
|
}
|
|
else {
|
|
if (leftElm.checked && rightElm.checked) {
|
|
value = 0
|
|
}
|
|
else {
|
|
if (leftElm.checked) {
|
|
value = -1
|
|
}
|
|
if (rightElm.checked) {
|
|
value = 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (thatD) {
|
|
thatD.options = JSON.parse(JSON.stringify(thatP.options))
|
|
thatD.originalOptions = JSON.parse(JSON.stringify(thatP.options))
|
|
if (thatP.oldData) {
|
|
thatD.oldData = JSON.parse(JSON.stringify(thatP.oldData))
|
|
}
|
|
if (thatD.type === 'TrajectoryMotion') {
|
|
thatD.height = thatD.options.height
|
|
}
|
|
thatD.reset && thatD.reset()
|
|
|
|
|
|
if (thatP.show) {
|
|
setSplitDirection(value, id, false, entityId)
|
|
}
|
|
else {
|
|
thatD.show = false
|
|
}
|
|
|
|
// else {
|
|
// thatD.show = false
|
|
// }
|
|
}
|
|
else {
|
|
let value = -1
|
|
// if (thatP.show) {
|
|
// let leftElm = sdk.viewer._element.getElementsByClassName('YJ-custom-checkbox-left')[0]
|
|
// let rightElm = sdk.viewer._element.getElementsByClassName('YJ-custom-checkbox-right')[0]
|
|
// if (leftElm.checked && rightElm.checked) {
|
|
// value = 0
|
|
// }
|
|
// else {
|
|
// if (leftElm.checked) {
|
|
// value = -1
|
|
// }
|
|
// if (rightElm.checked) {
|
|
// value = 1
|
|
// }
|
|
// }
|
|
// }
|
|
setSplitDirection(value, id, false, entityId)
|
|
}
|
|
}
|
|
else {
|
|
thatD && thatD.remove()
|
|
}
|
|
}
|
|
|
|
function setActiveViewer(v) {
|
|
activeViewer = v
|
|
}
|
|
|
|
function getSdk() {
|
|
return {
|
|
sdkP: sdkP,
|
|
sdkD: sdkD
|
|
}
|
|
}
|
|
|
|
|
|
export { on, off, setSplitDirection, syncSplitData, getState, getActiveId, setActiveId, setActiveViewer, getSdk } |