代码迁移

src/Global/ClickCallback/index.js

@@ -0,0 +1,578 @@
+/**
+ * @name: click
+ * @author: Administrator
+ * @date: 2023-05-28 11:05
+ * @description：click
+ * @update: 2023-05-28 11:05
+ */
+let leftClickHandler = null
+let rightClickHandler = null
+let MoveHandler = null
+let leftClickCallbackMap = new Map()
+let rightClickCallbackMap = new Map()
+let MoveCallbackMap = new Map()
+let selectedFeature;
+
+
+function cartesian3Towgs84(cartesian, viewer) {
+  var ellipsoid = viewer.scene.globe.ellipsoid
+  var cartesian3 = new Cesium.Cartesian3(
+    cartesian.x,
+    cartesian.y,
+    cartesian.z
+  )
+  var cartographic = ellipsoid.cartesianToCartographic(cartesian3)
+  var lat = Cesium.Math.toDegrees(cartographic.latitude)
+  var lng = Cesium.Math.toDegrees(cartographic.longitude)
+  var alt = cartographic.height < 0 ? 0 : cartographic.height
+  return {
+    lng: lng,
+    lat: lat,
+    alt: alt,
+  }
+}
+
+function getcartesian(sdk, movement) {
+  if (movement.endPosition) {
+    movement.endPosition.y -= 2
+  }
+  let position = movement.position || movement.endPosition
+  // 获取世界坐标系地表坐标，考虑地形，不包括模型，倾斜摄影模型表面；
+  let cartesian = sdk.viewer.scene.pickPosition(position)
+  if (!cartesian) {
+    const ray = sdk.viewer.camera.getPickRay(position); //相交的射线
+    cartesian = sdk.viewer.scene.globe.pick(ray, sdk.viewer.scene);
+  }
+  return cartesian
+}
+
+function openLeftClick(sdk, cb) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  let click = true
+  leftClickHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
+  leftClickHandler.setInputAction((movement) => {
+    let cartesian = sdk.viewer.scene.pickPosition(movement.position)
+    if (!cartesian) {
+      const ray = sdk.viewer.camera.getPickRay(movement.position); //相交的射线
+      cartesian = sdk.viewer.scene.globe.pick(ray, sdk.viewer.scene);
+    }
+    if (!cartesian) {
+      return
+    }
+
+    let pos84 = cartesian3Towgs84(cartesian, sdk.viewer)
+
+    cb && cb(pos84)
+
+    if (click) {
+      click = false
+      setTimeout(() => {
+        click = true
+      }, 600);
+      if (!YJ.Measure.GetMeasureStatus() && cartesian) {
+        let flag = false
+        for (let i = leftClickCallbackMap.size - 1; i >= 0; i--) {
+          let key = Array.from(leftClickCallbackMap.keys())[i]
+          let obj = leftClickCallbackMap.get(key)
+          if (obj) {
+
+            if (obj.that) {
+              // 是否为多边形
+              if (obj.that.type === 'PolygonObject') {
+                // 是否可点击y
+                if (obj.that.picking) {
+                  if (obj.that.options.positions && obj.that.options.positions.length >= 3) {
+                    let pt = turf.point([pos84.lng, pos84.lat]);
+                    let polyPos = []
+                    for (let i = 0; i < obj.that.options.positions.length; i++) {
+                      polyPos.push([
+                        obj.that.options.positions[i].lng,
+                        obj.that.options.positions[i].lat
+                      ])
+                    }
+                    polyPos.push([
+                      obj.that.options.positions[0].lng,
+                      obj.that.options.positions[0].lat
+                    ])
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+                }
+              }
+              // 聚集地
+              else if (obj.that.type === 'AssembleObject') {
+                if (obj.that.picking) {
+                  if (obj.that.options.positions && obj.that.options.positions.length >= 3) {
+                    let positions = obj.that.computeAssemble(obj.that.options.positions, true)
+                    let pt = turf.point([pos84.lng, pos84.lat]);
+                    let polyPos = []
+                    for (let i = 0; i < positions.length; i += 2) {
+                      polyPos.push([
+                        positions[i],
+                        positions[i + 1]
+                      ])
+                    }
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+                }
+              }
+              // 单箭头
+              else if (obj.that.type === 'AttackArrowObject') {
+                if (obj.that.picking) {
+                  if (obj.that.options.positions && obj.that.options.positions.length >= 3) {
+                    let pt = turf.point([pos84.lng, pos84.lat]);
+                    let positions = obj.that.computeAttackArrow(obj.that.options.positions)
+                    let polyPos = []
+                    for (let m = 0; m < positions.length; m++) {
+                      let pos84 = cartesian3Towgs84(positions[m], sdk.viewer)
+                      polyPos.push([pos84.lng, pos84.lat])
+                    }
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+                }
+              }
+              // 双箭头
+              else if (obj.that.type === 'PincerArrowObject') {
+                if (obj.that.picking) {
+                  if (obj.that.options.positions && obj.that.options.positions.length >= 5) {
+                    let pt = turf.point([pos84.lng, pos84.lat]);
+                    let positions = obj.that.computePincerArrow(obj.that.options.positions)
+                    let polyPos = []
+                    for (let m = 0; m < positions.length; m++) {
+                      let pos84 = cartesian3Towgs84(positions[m], sdk.viewer)
+                      polyPos.push([pos84.lng, pos84.lat])
+                    }
+                    let pos84_0 = cartesian3Towgs84(positions[0], sdk.viewer)
+                    polyPos.push([pos84_0.lng, pos84_0.lat])
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+                }
+              }
+              // 圆
+              else if (obj.that.type === 'CircleObject') {
+                if (obj.that.picking) {
+                  let pt = turf.point([pos84.lng, pos84.lat]);
+                  if (obj.that.options.center && obj.that.options.radius) {
+                    let center = [obj.that.options.center.lng, obj.that.options.center.lat];
+                    let radius = obj.that.options.radius / 1000;
+                    let options = { steps: 360, units: 'kilometers' };
+                    let circle = turf.circle(center, radius, options);
+                    let contain = turf.booleanPointInPolygon(pt, circle);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+
+                }
+              }
+              // 扇形
+              else if (obj.that.type === 'SectorObject') {
+                if (obj.that.picking) {
+                  let pt = turf.point([pos84.lng, pos84.lat]);
+                  if (obj.that.options.center && obj.that.options.radius && obj.that.options.startAngle && obj.that.options.endAngle) {
+                    let positions = obj.that.calSector(obj.that.options.center, obj.that.options.radius, obj.that.options.startAngle, obj.that.options.endAngle, undefined, true)
+                    let polyPos = []
+                    for (let m = 0; m < positions.length; m++) {
+                      polyPos.push([positions[m].lng, positions[m].lat])
+                    }
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+
+                }
+              }
+            }
+          }
+        }
+        if (!flag) {
+          const pick = sdk.viewer.scene.pick(movement.position)
+          if (pick) {
+            if (pick.id) {
+              let entityId
+              // 矢量
+              if (pick.id.type && pick.id.type === 'vector' && pick.id.parentId) {
+                let obj = leftClickCallbackMap.get(pick.id.parentId)
+                if (obj.that.picking && obj.that.geojson) {
+                  for (let i = 0; i < obj.that.geojson.features.length; i++) {
+                    if (obj.that.geojson.features[i].id === pick.id._id) {
+                      obj.callback(
+                        movement,
+                        obj.that.geojson.features[i].id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                    }
+                  }
+                }
+              }
+              else if (typeof pick.id.id == 'string') {
+                let array = pick.id.id.split('-')
+                array.splice(array.length - 1, 1)
+                entityId = array.join('-')
+              }
+
+              if (pick.id.properties && pick.id.properties.id && leftClickCallbackMap.has(pick.id.properties.id._value)) {
+                let obj = leftClickCallbackMap.get(pick.id.properties.id._value)
+                if (obj.that.picking) {
+                  obj.callback(
+                    movement,
+                    pick.id.properties.id._value,
+                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                }
+              }
+              else if (leftClickCallbackMap.has(pick.id.id)) {
+                let obj = leftClickCallbackMap.get(pick.id.id)
+                if (obj.that.picking) {
+                  obj.callback(
+                    movement,
+                    pick.id.id,
+                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                }
+              }
+              else if (entityId && leftClickCallbackMap.has(entityId)) {
+                let obj = leftClickCallbackMap.get(entityId)
+                if (obj.that.picking) {
+                  obj.callback(
+                    movement,
+                    entityId,
+                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                }
+              }
+              else if (pick.primitive) {
+                if (typeof pick.id == 'string' && leftClickCallbackMap.has(pick.id)) {
+                  let obj = leftClickCallbackMap.get(pick.id)
+                  obj.callback(
+                    movement,
+                    pick.id,
+                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                }
+              }
+            }
+            else {
+              if (pick.primitive && pick.primitive.id) {
+                if (leftClickCallbackMap.has(pick.primitive.id)) {
+                  let obj = leftClickCallbackMap.get(pick.primitive.id)
+                  if (obj.that.picking) {
+                    if (obj.that.type === 'bim') {
+                      if (YJ.Global.getBimPickStatus(sdk)) {
+                        obj.callback(
+                          movement,
+                          pick.primitive,
+                          cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      }
+                    }
+                    else {
+                      obj.callback(
+                        movement,
+                        pick.primitive.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                    }
+                  }
+                }
+              }
+            }
+            if (pick.content && (!pick.primitive || !pick.primitive.id)) {
+              if (leftClickCallbackMap.has(pick.content.tileset.id)) {
+                let obj = leftClickCallbackMap.get(pick.content.tileset.id)
+                if (obj.that.picking) {
+                  if (obj.that.type === 'bim') {
+                    if (YJ.Global.getBimPickStatus(sdk)) {
+                      obj.callback(
+                        movement,
+                        pick.content.tileset,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                    }
+                  }
+                  else {
+                    obj.callback(
+                      movement,
+                      pick.content.tileset.id,
+                      cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+
+    // if (click) {
+    //   click = false
+    //   setTimeout(() => {
+    //     click = true
+    //   }, 300);
+    //   if (!YJ.Measure.GetMeasureStatus()) {
+
+    //   }
+    // }
+  }, Cesium.ScreenSpaceEventType.LEFT_CLICK)
+
+  // leftClickHandler.setInputAction(function (movement) {
+  //   const feature = sdk.viewer.scene.pick(movement.endPosition);
+  //   // unselectFeature(selectedFeature);
+  //   if (selectedFeature) {
+  //     selectedFeature.color = Cesium.Color.WHITE;
+  //   }
+  //   selectedFeature = feature
+  //   if (feature) {
+  //     feature.color = Cesium.Color.YELLOW;
+  //   }
+  // }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+  // }
+
+}
+
+function closeLeftClick(sdk) {
+  leftClickHandler.destroy() //关闭事件句柄
+  leftClickHandler = null
+  // }
+}
+
+function openRightClick(sdk) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  rightClickHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
+  rightClickHandler.setInputAction((movement) => {
+    if (!YJ.Measure.GetMeasureStatus()) {
+      const pick = sdk.viewer.scene.pick(movement.position)
+      if (pick && pick.id) {
+        let id
+        if (pick.id.type && pick.id.type === 'vector' && pick.id.parentId) {
+          let obj = rightClickCallbackMap.get(pick.id.parentId)
+          if (obj.that.picking && obj.that.geojson) {
+            for (let i = 0; i < obj.that.geojson.features.length; i++) {
+              if (obj.that.geojson.features[i].id === pick.id._id) {
+                obj.callback(
+                  movement,
+                  obj.that.geojson.features[i].id,
+                  cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+              }
+            }
+          }
+        }
+        else {
+          if (typeof pick.id === 'string') {
+            id = pick.id
+          }
+          else {
+            id = pick.id.id
+          }
+          if (rightClickCallbackMap.has(id)) {
+            let obj = rightClickCallbackMap.get(id)
+            if (obj.that.picking) {
+              let cartesian = getcartesian(sdk, movement)
+              if (!cartesian) {
+                return
+              }
+              obj.callback(
+                movement,
+                id,
+                cartesian3Towgs84(cartesian, sdk.viewer), obj.that)
+            }
+          }
+        }
+      }
+      if (pick && pick.content) {
+        if (rightClickCallbackMap.has(pick.content.tileset.id)) {
+          let obj = rightClickCallbackMap.get(pick.content.tileset.id)
+          if (obj.that.picking) {
+            if (obj.that.type === 'bim') {
+              if (YJ.Global.getBimPickStatus(sdk)) {
+                let cartesian = getcartesian(sdk, movement)
+                if (!cartesian) {
+                  return
+                }
+                obj.callback(
+                  movement,
+                  pick.getProperty('id'),
+                  cartesian3Towgs84(cartesian, sdk.viewer), obj.that)
+              }
+            }
+            else {
+              let cartesian = getcartesian(sdk, movement)
+              if (!cartesian) {
+                return
+              }
+              obj.callback(
+                movement,
+                pick.content.tileset.id,
+                cartesian3Towgs84(cartesian, sdk.viewer), obj.that)
+            }
+          }
+        }
+      }
+    }
+  }, Cesium.ScreenSpaceEventType.RIGHT_CLICK)
+}
+
+function closeRightClick() {
+  if (rightClickHandler) {
+    rightClickHandler.destroy() //关闭事件句柄
+    rightClickHandler = null
+  }
+}
+
+function openMove(sdk) {
+  MoveHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
+  MoveHandler.setInputAction(function (movement) {
+    const pick = sdk.viewer.scene.pick(movement.endPosition);
+    // unselectFeature(selectedFeature);
+    // if (selectedFeature) {
+    //   let color = '#fff'
+    //   let state = selectedFeature.getProperty('state')
+    //   switch (state) {
+    //     case '0':
+    //       color = '#fff'
+    //       break;
+    //     case '1':
+    //       color = '#f00'
+    //       break;
+    //     case '2':
+    //       color = '#0f0'
+    //       break;
+    //     case '3':
+    //       color = '#00f'
+    //       break;
+    //     default:
+    //   }
+    //   selectedFeature.color = Cesium.Color.fromCssColorString(color).withAlpha(selectedFeature.tileset.transparency)
+    // }
+    // if (pick && pick.id) { }
+    // if (pick && pick.content) {
+    //   if (MoveCallbackMap.has(pick.content.tileset.id)) {
+    //     let obj = MoveCallbackMap.get(pick.content.tileset.id)
+    //     if (obj.that.picking) {
+    //       if (obj.that.type === 'bim') {
+    //         if (YJ.Global.getBimPickStatus(sdk)) {
+    //           selectedFeature = pick
+    //           pick.color = Cesium.Color.YELLOW;
+    //         }
+    //         else {
+    //           selectedFeature = null
+    //         }
+    //       }
+    //       else {
+    //         selectedFeature = pick
+    //         pick.color = Cesium.Color.YELLOW;
+    //       }
+    //     }
+    //     else {
+    //       selectedFeature = null
+    //     }
+    //   }
+    // }
+  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+}
+
+function closeMove() {
+  if (MoveHandler) {
+    MoveHandler.destroy() //关闭事件句柄
+    MoveHandler = null
+  }
+}
+
+/*注册左键回调*/
+function regLeftClickCallback(id, callback, that) {
+
+  leftClickCallbackMap.set(id, { callback, that })
+}/*取消左键回调*/
+function unRegLeftClickCallback(id,) {
+  leftClickCallbackMap.delete(id,)
+}
+
+/*注册右键回调*/
+function regRightClickCallback(id, callback, that) {
+  rightClickCallbackMap.set(id, { callback, that })
+}/*取消右键回调*/
+function unRegRightClickCallback(id,) {
+  rightClickCallbackMap.delete(id,)
+}
+
+/*注册左键回调*/
+function regMoveCallback(id, callback, that) {
+  MoveCallbackMap.set(id, { callback, that })
+}/*取消左键回调*/
+function unregMoveCallback(id,) {
+  MoveCallbackMap.delete(id,)
+}
+
+function getLeftClickState() {
+  if (leftClickHandler) {
+    return true
+  }
+  else {
+    false
+  }
+}
+
+function getRightClickState() {
+  if (rightClickHandler) {
+    return true
+  }
+  else {
+    false
+  }
+}
+
+function getMoveState() {
+  if (MoveHandler) {
+    return true
+  }
+  else {
+    false
+  }
+}
+
+
+export { openLeftClick, closeLeftClick, regLeftClickCallback, unRegLeftClickCallback, openRightClick, closeRightClick, regRightClickCallback, unRegRightClickCallback, openMove, closeMove, regMoveCallback, unregMoveCallback, getLeftClickState, getRightClickState, getMoveState }

src/Global/Contour/index.js

@@ -0,0 +1,253 @@
+/**
+ * 等高线
+ */
+import Dialog from "../../Obj/Element/Dialog";
+import Tools from "../../Tools";
+
+let _DialogObject = null;
+let material = null;
+let handler = null;
+let activeHeightElm = null;
+let tools
+activeHeightElm = document.createElement('div')
+activeHeightElm.className = 'YJ-customize-active-height-elm'
+activeHeightElm.style.position = 'absolute'
+activeHeightElm.style.left = '10px'
+activeHeightElm.style.top = '10px'
+activeHeightElm.style.width = '100px'
+// activeHeightElm.style.backgroundColor = 'rgba(0, 0, 0, 0.5)'
+activeHeightElm.style.textAlign = 'center'
+activeHeightElm.style.pointerEvents = 'none'
+activeHeightElm.style.color = '#ff0000'
+activeHeightElm.style.display = 'none'
+async function dialog(sdk) {
+  if (!sdk || _DialogObject) {
+    return
+  }
+  if (!material) {
+    createMaterial()
+  }
+  if (!tools) {
+    tools = new Tools()
+  }
+
+  _DialogObject = await new Dialog(sdk, {}, {
+    title: "等高线", left: '180px',
+    top: '100px',
+    confirmCallBack: options => { },
+    closeCallBack: () => {
+      _DialogObject = null
+    }
+  });
+
+  _DialogObject._element.body.className =
+    _DialogObject._element.body.className + ' contour'
+  let contentElm = document.createElement('div')
+  contentElm.innerHTML = `
+  <span class="custom-divider"></span>
+  <div class="div-item">
+      <div class="row">
+          <div class="col input-select-unit-box">
+              <span class="label">高差</span>
+              <div class="input-number input-number-unit-1">
+                  <input class="input gap" type="number" title="" min="0" max="1000">
+                  <span class="unit">m</span>
+                  <span class="arrow"></span>
+              </div>
+          </div>
+          <div class="col input-select-unit-box" style="flex: 0 0 120px;">
+              <span class="label">主线颜色</span>
+              <div class="primary-lice-color"></div>
+          </div>
+      </div>
+      <div class="row">
+          <div class="col input-select-unit-box">
+              <span class="label">次线条数</span>
+              <div class="input-number input-number-unit-1">
+                  <input class="input gap2" type="number" title="" min="0" max="10">
+                  <span class="unit"></span>
+                  <span class="arrow"></span>
+              </div>
+          </div>
+          <div class="col input-select-unit-box" style="flex: 0 0 120px;">
+              <span class="label">次线颜色</span>
+              <div class="secondary-lice-color"></div>
+          </div>
+      </div>
+      <div class="row" style="align-items: flex-start;">
+          <div class="col">
+          </div>
+          <div class="col" style="flex: 0 0 120px;">
+              <span class="label">开关</span>
+              <input class="btn-switch" type="checkbox">
+          </div>
+      </div>
+  </div>
+  <span class="custom-divider"></span>
+  `
+  contentElm.innerHTML = `
+  <span class="custom-divider"></span>
+  <div class="div-item">
+      <div class="row" style="align-items: flex-start;">
+          <div class="col" style="flex: 0 0 120px;">
+              <span class="label">开关</span>
+              <input class="btn-switch" type="checkbox">
+          </div>
+      </div>
+  </div>
+  `
+  _DialogObject.contentAppChild(contentElm)
+
+  contentElm.getElementsByClassName('btn-switch')[0].addEventListener('change', (e) => {
+    if (e.target.checked) {
+      if (handler) {
+        handler.destroy()
+      }
+      if (!sdk.viewer.container.getElementsByClassName('YJ-customize-active-height-elm')[0]) {
+        sdk.viewer.container.appendChild(activeHeightElm)
+      }
+
+      handler = new Cesium.ScreenSpaceEventHandler(
+        sdk.viewer.canvas
+      )
+      handler.setInputAction((movement) => {
+        let cartesian = sdk.viewer.scene.pickPosition(movement.endPosition)
+        if (cartesian) {
+          let top = 0
+          let left = 0
+          if (sdk.viewer && sdk.viewer._element) {
+            let element = sdk.viewer._element.getElementsByClassName('cesium-widget')[0].getElementsByTagName('canvas')[0]
+            top = element.getBoundingClientRect().top + window.scrollY
+            left = element.getBoundingClientRect().left + window.scrollX
+          }
+          activeHeightElm.style.left = movement.endPosition.x - 50 + left + 'px'
+          activeHeightElm.style.top = movement.endPosition.y - 40 + top + 'px'
+          activeHeightElm.style.display = 'block'
+          let pos84 = tools.cartesian3Towgs84(cartesian, sdk.viewer)
+          let mainContourHeight = Math.floor(pos84.alt / material.uniforms.spacing) * material.uniforms.spacing
+          let gap = pos84.alt - mainContourHeight
+          let gap2 = material.uniforms.spacing / (material.uniforms.secondaryLinesCount + 1)
+          let activeHeight = Math.floor(gap / gap2) * gap2 + mainContourHeight
+          if ((pos84.alt - activeHeight) > gap2 / 2) {
+            activeHeight = activeHeight + gap2
+          }
+          material.uniforms.mouseHeight = pos84.alt
+          material.uniforms.mousePosition = cartesian
+          activeHeightElm.innerHTML = `${activeHeight.toFixed(0)}`
+        }
+        else {
+          activeHeightElm.style.display = 'none'
+        }
+      }, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
+      sdk.viewer.scene.globe.material = material;
+    } else {
+      if (handler) {
+        handler.destroy()
+        handler = null
+      }
+      if (sdk.viewer.container.getElementsByClassName('YJ-customize-active-height-elm')[0]) {
+        activeHeightElm.style.display = 'none'
+        sdk.viewer.container.removeChild(activeHeightElm)
+      }
+      sdk.viewer.scene.globe.material = null;
+    }
+  })
+}
+
+function createMaterial() {
+  Cesium.Material._materialCache._materials.ElevationContour.fabric.source = `
+uniform vec4 color;
+uniform vec4 secondaryLinesColor;
+uniform float spacing;
+uniform float width;
+uniform float secondaryLinesWidth;
+uniform float mouseHeight;
+uniform float secondaryLinesCount; // 0=无次线, 1=1条次线, 2=2条次线...
+
+czm_material czm_getMaterial(czm_materialInput materialInput)
+{
+    czm_material material = czm_getDefaultMaterial(materialInput);
+
+    // 主等高线计算
+    float distanceToMainContour = mod(materialInput.height, spacing);
+    
+    // 抗锯齿计算
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+    float dxc = abs(dFdx(materialInput.height));
+    float dyc = abs(dFdy(materialInput.height));
+    float dFMain = max(dxc, dyc) * czm_pixelRatio * width;
+#else
+    float dFMain = czm_pixelRatio * width;
+#endif
+
+    bool isMainContour = distanceToMainContour < dFMain;
+    bool isSecondaryContour = false;
+    float dFSecondary = 0.0;
+    float secondarySpacing = 0.0;
+
+    // 只有当存在次线时才计算次线
+    if(secondaryLinesCount > 0.0) {
+        secondarySpacing = spacing / (secondaryLinesCount + 1.0);
+        float distanceToSecondaryContour = mod(materialInput.height, secondarySpacing);
+        
+        // 确保次线不会与主线重叠
+        float minDistanceToMain = min(distanceToMainContour, spacing - distanceToMainContour);
+        bool notCloseToMain = minDistanceToMain > dFMain * 2.0; // 2倍线宽缓冲
+        
+#if (__VERSION__ == 300 || defined(GL_OES_standard_derivatives))
+        dFSecondary = max(dxc, dyc) * czm_pixelRatio * secondaryLinesWidth;
+#else
+        dFSecondary = czm_pixelRatio * secondaryLinesWidth;
+#endif
+
+        isSecondaryContour = (distanceToSecondaryContour < dFSecondary) && notCloseToMain;
+    }
+
+    // 计算当前高度所属的等高线高度
+    float mainContourHeight = floor(materialInput.height / spacing) * spacing;
+    float secondaryContourHeight = floor(materialInput.height / spacing * (secondaryLinesCount + 1.0)) * spacing / (secondaryLinesCount + 1.0);
+
+    // 高亮判断
+    bool shouldHighlight = false;
+    if(isMainContour && abs(mainContourHeight - mouseHeight) < 0.5 * (spacing/(secondaryLinesCount+1.0))) {
+        shouldHighlight = true;
+    } else if(isSecondaryContour && abs(secondaryContourHeight - mouseHeight) < 0.5 * (spacing/(secondaryLinesCount+1.0))) {
+        shouldHighlight = true;
+    }
+
+    // 颜色输出
+    vec4 outColor;
+    if(shouldHighlight) {
+        outColor = vec4(1.0, 0.0, 0.0, 1.0);
+    } else if(isMainContour) {
+        outColor = czm_gammaCorrect(vec4(color.rgb, color.a));
+    } else if(isSecondaryContour) {
+        outColor = czm_gammaCorrect(vec4(secondaryLinesColor.rgb, secondaryLinesColor.a));
+    } else {
+        outColor = vec4(0.0);
+    }
+
+    material.diffuse = outColor.rgb;
+    material.alpha = outColor.a;
+    return material;
+}
+`
+
+  material = new Cesium.Material({
+    fabric: {
+      type: "ElevationContour",
+      uniforms: {
+        width: 2,
+        secondaryLinesWidth: 1, // 次级线宽度
+        spacing: 200,
+        color: Cesium.Color.fromCssColorString('#ffd000'),
+        secondaryLinesColor: Cesium.Color.fromCssColorString('#0dff00').withAlpha(0.5),
+        mouseHeight: -100000,
+        mousePosition: new Cesium.Cartesian3(0, 0, 0),
+        secondaryLinesCount: 3
+      },
+    }
+  });
+}
+
+export { dialog }

src/Global/DTH/changeClassificationPrimitive.js

@@ -0,0 +1,37 @@
+function changeClassificationPrimitive(options, array) {
+  this.options = options
+  this.array = array
+}
+
+changeClassificationPrimitive.prototype.getGeometry = function () {
+  return Cesium.PolygonGeometry.createGeometry(this.options);
+};
+changeClassificationPrimitive.prototype.update = function (context, frameState, commandList) {
+  var geometry = this.getGeometry();
+  if (!geometry) {
+    return;
+  }
+
+  this._primitive = new Cesium.ClassificationPrimitive({
+    geometryInstances: new Cesium.GeometryInstance({
+      geometry: geometry,
+      id: {
+        type: 'dth',
+        ...this.array,
+      },
+      attributes: {
+        color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+          Cesium.Color.fromRandom({ alpha: 0.5 })
+        ),
+        show: new Cesium.ShowGeometryInstanceAttribute(true),
+      }
+    }),
+    classificationType: Cesium.ClassificationType.CESIUM_3D_TILE,
+  });
+  var primitive = this._primitive
+
+  primitive.update(context, frameState, commandList);
+
+};
+
+export { changeClassificationPrimitive }

src/Global/DTH/index.js

@@ -0,0 +1,538 @@
+import { getHost, getToken } from "../../on";
+class DTH {
+  constructor(sdk, options = {}) {
+    this.sdk = sdk
+    this.primitives = {
+      building: [],
+      unit: [],
+      dth: []
+    }
+    this.options = { ...options }
+    this.options.host = this.options.host || getHost()
+    this.temporaryDth = []
+    this.dth = {}
+    this.PickBuildingEvent = new Cesium.Event();
+    this.initEvents()
+    this.activeBuilding
+  }
+
+  /**
+   * @description 注册点击的事件回调
+   * @memberOf DTH
+   * */
+  PickCallback(that, cb) {
+    this.PickBuildingEvent.addEventListener(
+      cb,
+      that
+    )
+  }
+
+  //场景事件
+  initEvents() {
+    new Cesium.ScreenSpaceEventHandler(this.sdk.viewer.scene.canvas).setInputAction(((e) => {
+      if (YJ.Measure.GetMeasureStatus()) {
+        return
+      }
+      if (!this.isActivate) return;
+      let pickFeature = this.sdk.viewer.scene.pick(e.position);
+      if (pickFeature) {
+        //点击了已有的分户单体化
+        if (pickFeature.primitive && pickFeature.primitive instanceof Cesium.ClassificationPrimitive && pickFeature.id && (pickFeature.id.type == "yj-dth-dth" || pickFeature.id.type == "yj-dth-highlight")) {
+          this.getIDBypickFeature(pickFeature); //处理点击到的楼层
+          return;
+        }
+        if (pickFeature.primitive && pickFeature.primitive instanceof Cesium.ClassificationPrimitive && pickFeature.id && pickFeature.id.type == "yj-dth-unit") {
+          this.highlightPrimitive && this.sdk.viewer.scene.primitives.remove(this.highlightPrimitive)
+          this.handlePickEvent(pickFeature.id)
+          return;
+        }
+
+        // if (pickFeature.id && pickFeature.id.type === 'yj-dth-highlight') {
+        //   return;
+        // }
+      }
+
+      this.highlightPrimitive && this.sdk.viewer.scene.primitives.remove(this.highlightPrimitive)
+      let position = this.sdk.viewer.scene.pickPosition(e.position); //屏幕坐标转为笛卡尔空间坐标
+      if (!position) return;
+
+      let c = Cesium.Cartographic.fromCartesian(position); //笛卡尔坐标转为经纬度（弧度）
+      let point = [Cesium.Math.toDegrees(c.longitude), Cesium.Math.toDegrees(c.latitude)]; //转为经纬度点
+      this.queryByPoint(point, c.height);
+    }), Cesium.ScreenSpaceEventType.LEFT_CLICK);
+
+    let coverLabelEntity = this.sdk.viewer.entities.getOrCreateEntity('yj-dth-cover-label')
+    coverLabelEntity.show = false
+    // this.sdk.viewer.entities.add({
+    //   position: Cesium.Cartesian3.fromDegrees(-75.1641667, 39.9522222),
+    //   label: {
+    //     text: "Philadelphia",
+    //     font: "24px Helvetica",
+    //     fillColor: Cesium.Color.SKYBLUE,
+    //     outlineColor: Cesium.Color.BLACK,
+    //     outlineWidth: 2,
+    //     style: Cesium.LabelStyle.FILL_AND_OUTLINE,
+    //   },
+    // });
+    let lastPickTime = 0;
+    let _this = this
+    let timeoutEvent
+    new Cesium.ScreenSpaceEventHandler(this.sdk.viewer.scene.canvas).setInputAction(((movement) => {
+      if (YJ.Measure.GetMeasureStatus()) {
+        return
+      }
+      try {
+        const now = Date.now();
+        if (now - lastPickTime < 100) {
+          clearTimeout(timeoutEvent)
+          timeoutEvent = setTimeout(() => {
+            pick(movement)
+          }, 100);
+          return
+        }
+        clearTimeout(timeoutEvent)
+        lastPickTime = now;
+        pick(movement)
+      } catch (error) {
+      }
+    }), Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+    function pick(e) {
+      let pickFeature = _this.sdk.viewer.scene.pick(e.endPosition);
+      if (pickFeature) {
+        let labelText = ''
+        if (pickFeature.primitive && pickFeature.primitive instanceof Cesium.ClassificationPrimitive && pickFeature.id && (pickFeature.id.type === "yj-dth-dth" || pickFeature.id.type === "yj-dth-highlight")) {
+          labelText = pickFeature.id.build_info.name + ' - ' + pickFeature.id.unit_info.name + ' - ' + pickFeature.id.room_num
+        }
+        else if (pickFeature.primitive && pickFeature.primitive instanceof Cesium.ClassificationPrimitive && pickFeature.id && pickFeature.id.type === "yj-dth-unit") {
+          if (pickFeature.id.build_info.name) {
+            labelText = pickFeature.id.build_info.name + ' - ' + pickFeature.id.name
+          }
+        }
+        else if (pickFeature.primitive && pickFeature.primitive instanceof Cesium.ClassificationPrimitive && pickFeature.id && pickFeature.id.type === "yj-dth-build") {
+          if (pickFeature.id.name) {
+            labelText = pickFeature.id.name
+          }
+        }
+        else if (pickFeature.primitive && pickFeature.primitive.id && pickFeature.primitive.id.id && pickFeature.primitive.id.id === 'yj-dth-cover-label') {
+          coverLabelEntity.position = _this.sdk.viewer.scene.pickPosition(e.endPosition)
+          return
+        }
+        else {
+          coverLabelEntity.show = false
+          return
+        }
+
+        if (labelText) {
+          coverLabelEntity.position = _this.sdk.viewer.scene.pickPosition(e.endPosition)
+          coverLabelEntity.label = new Cesium.LabelGraphics({
+            text: labelText,
+            font: "20px Helvetica",
+            pixelOffset: { x: 0, y: -30 },
+            fillColor: Cesium.Color.fromCssColorString('#ffffff'),
+            outlineColor: Cesium.Color.BLACK,
+            outlineWidth: 1,
+            showBackground: true,
+            backgroundColor: Cesium.Color.fromCssColorString('#000000').withAlpha(0.8),
+            style: Cesium.LabelStyle.FILL_AND_OUTLINE,
+            disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          })
+          coverLabelEntity.show = true
+        }
+      }
+    }
+  }
+
+  /*根据用户信息查询单体化*/
+  queryByUserInfo(data) {
+    this.queryByPoint([data.position.lng, data.position.lat], data.position.alt, data.id)
+  }
+
+  //点查询  点击查询是查询分层的数据
+  async queryByPoint(point) {
+    let url = ""
+    if (this.options.host.endsWith("yjearth4.0")) {
+      url = this.options.host + '/api/v1/dth/build/query_by_point'
+    }
+    else {
+      url = this.options.host + '/yjearth4.0/api/v1/dth/build/query_by_point'
+    }
+    url += '?point=' + JSON.stringify({ 'lng': point[0], 'lat': point[1] })
+    let response = await fetch(url, {
+      method: 'get',
+      // body: JSON.stringify({point: {'lng': point[0],'lat': point[1]}}),
+      headers: {
+        'Content-Type': 'application/json',
+        "token": getToken(),
+        "Authorization": "Bearer " + getToken(),
+      }
+    })
+    if (response.status === 200) {
+      let data = await response.json()
+      if (data.code === 200 || data.code === 0) {
+        this.processQueryByPointResults(data.data)
+      }
+      else {
+        window.ELEMENT && window.ELEMENT.Message({
+          message: data.msg || data.message,
+          type: 'warning',
+          duration: 1500
+        });
+      }
+    }
+  }
+
+  // 处理查询结果
+  async processQueryByPointResults(data, isflyto, offset = { heading: 0.0, pitch: -90.0, roll: 0.0 }) {
+    data.build_info && this.handlePickEvent(data)
+    let range
+    this.clearAllDthPrimitive()
+    this.clearAllUnitPrimitive()
+    if (this.activeBuilding) {
+      this.clearBuildingPrimitive(this.activeBuilding)
+      this.activeBuilding = null
+    }
+
+    if (data.build_info) {
+      range = JSON.parse(data.build_info.range)
+      if (data.dan_yuan.length > 0) {
+        for (let i = 0; i < data.dan_yuan.length; i++) {
+          if (data.dan_yuan[i].children.length > 0) {
+            this.addDthPrimitive(data.dan_yuan[i].children, data.build_info, data.dan_yuan[i])
+          }
+          else {
+            this.addUnitPrimitive([data.dan_yuan[i]], data.build_info, data.dan_yuan[i])
+          }
+        }
+      }
+      else {
+        this.activeBuilding = data.build_info.ID || data.build_info.id
+        this.addBuildingPrimitive([data.build_info])
+      }
+      if (isflyto) {
+        if (data.info && data.info.dan_yuan) {
+          range = JSON.parse(data.info.dan_yuan.range)
+        }
+        if (data.info && data.info.hu) {
+          range = JSON.parse(data.info.hu.range)
+          for (let i = 0; i < range.length; i++) {
+            range[i].alt = data.info.hu.bottom
+          }
+          for (let i = 0; i < this.primitives.dth.length; i++) {
+            await this.primitives.dth[i].readyPromise
+            let primitivesData = this.primitives.dth[i]._primitiveOptions.geometryInstances[0].id
+            if (primitivesData.ID === data.info.hu.ID && primitivesData.room_num === data.info.hu.room_num) {
+              let pickFeature = {
+                id: { ...data.info.hu, build_info: { ...data.build_info }, unit_info: data.info.dan_yuan },
+                primitive: this.primitives.dth[i]
+              }
+              this.getIDBypickFeature(pickFeature)
+              break
+            }
+          }
+        }
+        this.flyTo(range, offset)
+      }
+    }
+  }
+
+  // 添加房屋Primitive
+  async addBuildingPrimitive(array) {
+    for (let i = 0; i < array.length; i++) {
+      let fromDegreesArray = []
+      let extrudedHeight = 0
+      let positions = JSON.parse(array[i].range)
+      for (let m = 0; m < positions.length; m++) {
+        if (extrudedHeight < positions[m].alt) {
+          extrudedHeight = positions[m].alt
+        }
+        fromDegreesArray.push(positions[m].lng, positions[m].lat, 0)
+      }
+      let polygonGeometry = new Cesium.PolygonGeometry({
+        polygonHierarchy: new Cesium.PolygonHierarchy(
+          Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArray)
+        ),
+        // perPositionHeight: true, //使用z坐标 否则高度从0开始
+        extrudedHeight: 100000000, //拉伸高度
+      });
+      this.primitives.building.push(this.sdk.viewer.scene.primitives.add(
+        new Cesium.ClassificationPrimitive({
+          geometryInstances: new Cesium.GeometryInstance({
+            id: {
+              type: 'yj-dth-build',
+              ...array[i],
+            },
+            geometry: Cesium.PolygonGeometry.createGeometry(polygonGeometry),
+            attributes: {
+              color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+                Cesium.Color.fromCssColorString('rgb(255, 235, 59, 0.4)')
+              ),
+              show: new Cesium.ShowGeometryInstanceAttribute(true),
+            }
+          }),
+          classificationType: Cesium.ClassificationType.CESIUM_3D_TILE,
+        })
+      ))
+    }
+  }
+
+  // 根据id删除房屋Primitive
+  clearBuildingPrimitive(id) {
+    for (let i = this.primitives.building.length - 1; i >= 0; i--) {
+      if (id === this.primitives.building[i]._primitiveOptions.geometryInstances[0].id.ID || id === this.primitives.building[i]._primitiveOptions.geometryInstances[0].id.id) {
+        this.sdk.viewer.scene.primitives.remove(this.primitives.building[i])
+        this.primitives.building.splice(i, 1)
+        break
+      }
+    }
+  }
+  // 删除全部房屋Primitive
+  clearAllBuildingPrimitive() {
+    for (let i = this.primitives.building.length - 1; i >= 0; i--) {
+      this.sdk.viewer.scene.primitives.remove(this.primitives.building[i])
+    }
+    this.primitives.building = []
+  }
+
+  // 添加单元Primitive
+  async addUnitPrimitive(array, build_info, unit_info) {
+    for (let i = 0; i < array.length; i++) {
+      let fromDegreesArray = []
+      let extrudedHeight = 0
+      let positions = JSON.parse(array[i].range)
+      for (let m = 0; m < positions.length; m++) {
+        if (extrudedHeight < positions[m].alt) {
+          extrudedHeight = positions[m].alt
+        }
+        fromDegreesArray.push(positions[m].lng, positions[m].lat, 0)
+      }
+      let polygonGeometry = new Cesium.PolygonGeometry({
+        polygonHierarchy: new Cesium.PolygonHierarchy(
+          Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArray)
+        ),
+        // perPositionHeight: true, //使用z坐标 否则高度从0开始
+        extrudedHeight: 100000000, //拉伸高度
+      });
+      this.primitives.unit.push(this.sdk.viewer.scene.primitives.add(
+        new Cesium.ClassificationPrimitive({
+          geometryInstances: new Cesium.GeometryInstance({
+            id: {
+              type: 'yj-dth-unit',
+              ...array[i],
+              build_info: { ...build_info },
+              unit_info: { ...unit_info }
+            },
+            geometry: Cesium.PolygonGeometry.createGeometry(polygonGeometry),
+            attributes: {
+              color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+                Cesium.Color.fromCssColorString('rgb(255, 235, 59, 0.4)')
+              ),
+              show: new Cesium.ShowGeometryInstanceAttribute(true),
+            }
+          }),
+          classificationType: Cesium.ClassificationType.CESIUM_3D_TILE,
+        })
+      ))
+      this.primitives.unit.push(this.sdk.viewer.scene.primitives.add(
+        new Cesium.GroundPolylinePrimitive({
+          geometryInstances: new Cesium.GeometryInstance({
+            geometry: new Cesium.GroundPolylineGeometry({
+              positions: Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArray),
+              width: 2.0
+            }),
+            attributes: {
+              color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.fromCssColorString('#00ff0a').withAlpha(0.8))
+            },
+          }),
+          appearance: new Cesium.PolylineColorAppearance()
+        })
+      ))
+    }
+  }
+
+  // 根据id删除单元Primitive
+  clearUnitPrimitive(id) {
+    for (let i = this.primitives.building.length - 1; i >= 0; i--) {
+      if (id === this.primitives.building[i]._primitiveOptions.geometryInstances[0].id.ID || id === this.primitives.building[i]._primitiveOptions.geometryInstances[0].id.id) {
+        this.sdk.viewer.scene.primitives.remove(this.primitives.unit[i])
+        this.primitives.unit.splice(i, 1)
+        break
+      }
+    }
+  }
+
+  // 删除全部单元Primitive
+  clearAllUnitPrimitive() {
+    for (let i = this.primitives.unit.length - 1; i >= 0; i--) {
+      this.sdk.viewer.scene.primitives.remove(this.primitives.unit[i])
+    }
+    this.primitives.unit = []
+  }
+
+  // 添加单体化Primitive
+  addDthPrimitive(array, build_info, unit_info) {
+    for (let i = 0; i < array.length; i++) {
+      let positions = JSON.parse(array[i].range)
+      let fromDegreesArray = []
+      for (let m = 0; m < positions.length; m++) {
+        fromDegreesArray.push(positions[m].lng, positions[m].lat, array[i].bottom + 0.3)
+      }
+      let polygonGeometry = new Cesium.PolygonGeometry({
+        polygonHierarchy: new Cesium.PolygonHierarchy(
+          Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArray)
+        ),
+        perPositionHeight: true, //使用z坐标 否则高度从0开始
+        extrudedHeight: array[i].height + array[i].bottom, //拉伸高度
+      });
+      let polygonGeometryBorder = new Cesium.PolygonGeometry({
+        polygonHierarchy: new Cesium.PolygonHierarchy(
+          Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArray)
+        ),
+        perPositionHeight: true, //使用z坐标 否则高度从0开始
+        extrudedHeight: array[i].bottom, //拉伸高度
+      });
+      this.primitives.dth.push(this.sdk.viewer.scene.primitives.add(
+        new Cesium.ClassificationPrimitive({
+          geometryInstances: new Cesium.GeometryInstance({
+            id: {
+              type: 'yj-dth-dth',
+              ...array[i],
+              build_info: { ...build_info },
+              unit_info: { ...unit_info }
+            },
+            geometry: Cesium.PolygonGeometry.createGeometry(polygonGeometry),
+            attributes: {
+              color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+                Cesium.Color.fromCssColorString('rgb(0, 64, 255, 0.4)')
+              ),
+              show: new Cesium.ShowGeometryInstanceAttribute(true),
+            }
+          }),
+          classificationType: Cesium.ClassificationType.CESIUM_3D_TILE,
+        })
+      ));
+      this.primitives.dth.push(this.sdk.viewer.scene.primitives.add(
+        new Cesium.ClassificationPrimitive({
+          geometryInstances: new Cesium.GeometryInstance({
+            id: {
+              type: 'yj-dth-dth-border',
+              ...array[i],
+            },
+            geometry: Cesium.PolygonGeometry.createGeometry(polygonGeometryBorder),
+            attributes: {
+              color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+                Cesium.Color.fromCssColorString('rgb(0, 0, 0, 1)')
+              ),
+              show: new Cesium.ShowGeometryInstanceAttribute(true),
+            }
+          }),
+          classificationType: Cesium.ClassificationType.CESIUM_3D_TILE,
+        })
+      ));
+    }
+  }
+  // 根据id删除单体化Primitive
+  clearDthPrimitive(id) {
+    for (let i = this.primitives.dth.length - 1; i >= 0; i--) {
+      if (id === this.primitives.dth[i]._primitiveOptions.geometryInstances[0].id.ID || id === this.primitives.dth[i]._primitiveOptions.geometryInstances[0].id.id) {
+        this.sdk.viewer.scene.primitives.remove(this.primitives.dth[i])
+        this.primitives.dth.splice(i, 1)
+      }
+    }
+  }
+
+  // 删除全部单体化Primitive
+  clearAllDthPrimitive() {
+    this.highlightPrimitive && this.sdk.viewer.scene.primitives.remove(this.highlightPrimitive)
+    for (let i = this.primitives.dth.length - 1; i >= 0; i--) {
+      this.sdk.viewer.scene.primitives.remove(this.primitives.dth[i])
+    }
+    this.primitives.dth = []
+  }
+
+  getIDBypickFeature(pickFeature) {
+    //恢复上一个贴对象面显示
+    if (this.clickHighlightPrimitive) {
+      this.clickHighlightPrimitive.show = true;
+    }
+    this.highlightPrimitive && this.sdk.viewer.scene.primitives.remove(this.highlightPrimitive)
+    this.highlightPrimitive = this.sdk.viewer.scene.primitives.add(
+      new Cesium.ClassificationPrimitive({
+        geometryInstances: new Cesium.GeometryInstance({
+          id: {
+            ...pickFeature.id,
+            type: 'yj-dth-highlight',
+
+          },
+          geometry: pickFeature.primitive._primitiveOptions.geometryInstances[0].geometry,
+          attributes: {
+            color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.fromCssColorString('#ff9800').withAlpha(0.8)),
+            show: new Cesium.ShowGeometryInstanceAttribute(true),
+          }
+        }),
+        classificationType: Cesium.ClassificationType.CESIUM_3D_TILE,
+      })
+    )
+    this.highlightPrimitive.readyPromise.then(() => {
+      //设置当前点击的贴对象面不显示
+      pickFeature.primitive.show = false;
+    })
+    this.clickHighlightPrimitive = pickFeature.primitive;
+
+    let range = pickFeature.id.range
+    if (typeof pickFeature.id.range === 'string') {
+      range = JSON.parse(pickFeature.id.range)
+    }
+    this.getHilightArea(range)
+    this.handlePickEvent(pickFeature.id)
+  }
+
+  //处理点击事件
+  handlePickEvent(id) {
+    this.PickBuildingEvent.raiseEvent(id); //触发选中事件 通知界面更新
+  }
+
+  getHilightArea(points, radius = 1) {
+    let arr = []
+    points.forEach((point) => {
+      arr.push([(point.lng), (point.lat)])
+    })
+    arr.push(arr[0])
+    var poly = turf.polygon([arr])
+    var buffered = turf.buffer(poly, Number(radius) / 1000)
+    return buffered.geometry.coordinates
+  }
+
+  async flyTo(positions, offset = { heading: 0.0, pitch: -90.0, roll: 0.0 }) {
+    let tools = new YJ.Tools(this.sdk)
+    let height = 0
+    let positionArray = []
+    for (let i = 0; i < positions.length; i++) {
+      if (positions[i].alt) {
+        height = positions[i].alt
+      }
+      else {
+        height = await tools.getClampToHeight(positions[i])
+      }
+      let a = Cesium.Cartesian3.fromDegrees(positions[i].lng, positions[i].lat, height)
+      positionArray.push(a.x, a.y, a.z)
+    }
+    let BoundingSphere = await Cesium.BoundingSphere.fromVertices(positionArray)
+    this.sdk.viewer.camera.flyToBoundingSphere(BoundingSphere, {
+      offset: {
+        heading: Cesium.Math.toRadians(offset.heading || 0),
+        pitch: Cesium.Math.toRadians((offset.pitch || offset.pitch === 0) ? offset.pitch : -90),
+        roll: Cesium.Math.toRadians(offset.roll || 0)
+      }
+    })
+  }
+
+  activate() {
+    this.isActivate = true;
+  }
+
+  deactivate() {
+    this.isActivate = false;
+  }
+}
+
+export default DTH

src/Global/DTH/index1.js

@@ -0,0 +1,267 @@
+import { getHost, getToken } from "../../on";
+class DTH {
+  constructor(sdk, options = {}) {
+    this.sdk = sdk
+    this.primitives = {
+      building: [],
+      dth: []
+    }
+    this.options = {...options}
+    this.options.host = this.options.host || getHost()
+    this.temporaryDth = []
+    this.dth = {}
+    this.HandlePickHouseEvent = new Cesium.Event();
+    this.initEvents()
+  }
+
+  /**
+   * @description 注册分户点击的事件回调
+   * @memberOf DTH
+   * */
+  houseSelectedCallback(that, cb) {
+    this.HandlePickHouseEvent.addEventListener(
+      cb,
+      that
+    )
+  }
+
+  //场景事件
+  initEvents() {
+    new Cesium.ScreenSpaceEventHandler(this.sdk.viewer.scene.canvas).setInputAction(((e) => {
+      if (!this.isActivate) return;
+      let pickFeature = this.sdk.viewer.scene.pick(e.position);
+      if (pickFeature) {
+        //点击了已有的分户单体化
+        if (pickFeature.primitive && pickFeature.primitive instanceof Cesium.ClassificationPrimitive && pickFeature.id && pickFeature.id.type == "dth") {
+          this.getIDBypickFeature(pickFeature); //处理点击到的楼层
+          return;
+        }
+
+        if (pickFeature.id && pickFeature.id.type === 'highlight') {
+          return;
+        }
+      }
+
+      this.highlightPrimitive && this.sdk.viewer.scene.primitives.remove(this.highlightPrimitive)
+      let position = this.sdk.viewer.scene.pickPosition(e.position); //屏幕坐标转为笛卡尔空间坐标
+      if (!position) return;
+
+      let c = Cesium.Cartographic.fromCartesian(position); //笛卡尔坐标转为经纬度（弧度）
+      let point = [Cesium.Math.toDegrees(c.longitude), Cesium.Math.toDegrees(c.latitude)]; //转为经纬度点
+      this.queryByPoint(point, c.height);
+    }), Cesium.ScreenSpaceEventType.LEFT_CLICK);
+  }
+
+  /*根据用户信息查询单体化*/
+  queryByUserInfo(data) {
+    this.queryByPoint([data.position.lng, data.position.lat], data.position.alt, data.id)
+  }
+
+  //点查询  点击查询是查询分层的数据
+  async queryByPoint(point) {
+    let url = ""
+    if (this.options.host.endsWith("yjearth4.0")) {
+      url = this.options.host + '/api/v1/dth/query_by_point'
+    }
+    else {
+      url = this.options.host + '/yjearth4.0/api/v1/dth/query_by_point'
+    }
+    url += '?point=' + JSON.stringify({'lng': point[0],'lat': point[1]})
+    let response = await fetch(url, {
+      method: 'get',
+      headers: {
+        'Content-Type': 'application/json',
+        "token": getToken(),
+        "Authorization": "Bearer " + getToken(),
+      }
+    })
+    if (response.status === 200) {
+      let data = await response.json()
+      if (data.code === 200 || data.code === 0) {
+        this.clearAllDthPrimitive()
+        this.addDthPrimitive(data.data.list)
+      }
+      else {
+        window.ELEMENT && window.ELEMENT.Message({
+          message: data.msg || data.message,
+          type: 'warning',
+          duration: 1500
+        });
+      }
+    }
+  }
+
+
+
+  // 添加房屋Primitive
+  async addBuildingPrimitive(array) {
+    for (let i = 0; i < array.length; i++) {
+      let fromDegreesArray = []
+      let extrudedHeight = 0
+      let positions = JSON.parse(array[i].range)
+      for (let m = 0; m < positions.length; m++) {
+        if (extrudedHeight < positions[m].alt) {
+          extrudedHeight = positions[m].alt
+        }
+        fromDegreesArray.push(positions[m].lng, positions[m].lat, 0)
+      }
+      let polygonGeometry = new Cesium.PolygonGeometry({
+        polygonHierarchy: new Cesium.PolygonHierarchy(
+          Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArray)
+        ),
+        // perPositionHeight: true, //使用z坐标 否则高度从0开始
+        extrudedHeight: 100000000, //拉伸高度
+      });
+      this.primitives.building.push(this.sdk.viewer.scene.primitives.add(
+        new Cesium.ClassificationPrimitive({
+          geometryInstances: new Cesium.GeometryInstance({
+            id: {
+              ...array[i],
+            },
+            geometry: Cesium.PolygonGeometry.createGeometry(polygonGeometry),
+            attributes: {
+              color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+                Cesium.Color.fromCssColorString('rgb(255, 235, 59, 0.4)')
+              ),
+              show: new Cesium.ShowGeometryInstanceAttribute(true),
+            }
+          }),
+          classificationType: Cesium.ClassificationType.CESIUM_3D_TILE,
+        }), 0
+      ))
+    }
+  }
+  // 根据id删除房屋Primitive
+  clearBuildingPrimitive(id) {
+    for (let i = this.primitives.building.length - 1; i >= 0; i--) {
+      if (id === this.primitives.building[i]._primitiveOptions.geometryInstances[0].id.ID) {
+        this.sdk.viewer.scene.primitives.remove(this.primitives.building[i])
+        this.primitives.building.splice(i, 1)
+        break
+      }
+    }
+  }
+  // 删除全部房屋Primitive
+  clearAllBuildingPrimitive() {
+    for (let i = this.primitives.building.length - 1; i >= 0; i--) {
+      this.sdk.viewer.scene.primitives.remove(this.primitives.building[i])
+    }
+    this.primitives.building = []
+  }
+
+  // 添加单体化Primitive
+  addDthPrimitive(array) {
+    let readyIndex = 0
+    let Primitives = []
+    for (let i = 0; i < array.length; i++) {
+      let positions = JSON.parse(array[i].range)
+      let fromDegreesArray = []
+      for (let m = 0; m < positions.length; m++) {
+        fromDegreesArray.push(positions[m].lng, positions[m].lat, array[i].bottom)
+      }
+      let polygonGeometry = new Cesium.PolygonGeometry({
+        polygonHierarchy: new Cesium.PolygonHierarchy(
+          Cesium.Cartesian3.fromDegreesArrayHeights(fromDegreesArray)
+        ),
+        perPositionHeight: true, //使用z坐标 否则高度从0开始
+        extrudedHeight: array[i].height + array[i].bottom, //拉伸高度
+      });
+      let Primitive = new Cesium.ClassificationPrimitive({
+        geometryInstances: new Cesium.GeometryInstance({
+          id: {
+            type: 'dth',
+            ...array[i],
+          },
+          geometry: Cesium.PolygonGeometry.createGeometry(polygonGeometry),
+          attributes: {
+            color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+              Cesium.Color.fromCssColorString('rgb(255, 235, 59, 0.4)')
+            ),
+            show: new Cesium.ShowGeometryInstanceAttribute(true),
+          }
+        }),
+        classificationType: Cesium.ClassificationType.CESIUM_3D_TILE,
+      })
+      Primitives.push(Primitive)
+      this.sdk.viewer.scene.primitives.add(Primitive)
+      Primitive._readyPromise.then(()=>{
+        this.clearDthPrimitive(Primitive._primitiveOptions.geometryInstances[0].id.ID)
+        readyIndex ++
+        if(readyIndex >= array.length) {
+          this.primitives.dth.push(...Primitives);
+        }
+      })
+    }
+  }
+  // 根据id删除单体化Primitive
+  clearDthPrimitive(id) {
+    for (let i = this.primitives.dth.length - 1; i >= 0; i--) {
+      if (id === this.primitives.dth[i]._primitiveOptions.geometryInstances[0].id.ID) {
+        this.sdk.viewer.scene.primitives.remove(this.primitives.dth[i])
+        this.primitives.dth.splice(i, 1)
+      }
+    }
+  }
+
+  getDthPrimitive(id) {
+    for (let i = this.primitives.dth.length - 1; i >= 0; i--) {
+      if (id === this.primitives.dth[i]._primitiveOptions.geometryInstances[0].id.ID) {
+        return this.primitives.dth[i]
+      }
+    }
+  }
+
+  // 删除全部单体化Primitive
+  clearAllDthPrimitive() {
+    for (let i = this.primitives.dth.length - 1; i >= 0; i--) {
+      this.sdk.viewer.scene.primitives.remove(this.primitives.dth[i])
+    }
+    this.primitives.dth = []
+  }
+
+  getIDBypickFeature(pickFeature) {
+    //恢复上一个贴对象面显示
+    if (this.clickHighlightPrimitive) {
+      this.clickHighlightPrimitive.show = true;
+    }
+    this.highlightPrimitive && this.sdk.viewer.scene.primitives.remove(this.highlightPrimitive)
+    this.highlightPrimitive = this.sdk.viewer.scene.primitives.add(
+      new Cesium.ClassificationPrimitive({
+        geometryInstances: new Cesium.GeometryInstance({
+          id: {
+            type: 'highlight',
+          },
+          geometry: pickFeature.primitive._primitiveOptions.geometryInstances[0].geometry,
+          attributes: {
+            color: Cesium.ColorGeometryInstanceAttribute.fromColor(
+              Cesium.Color.fromCssColorString('rgb(255, 0, 0, 1)')
+            ),
+            show: new Cesium.ShowGeometryInstanceAttribute(true),
+          }
+        }),
+        classificationType: Cesium.ClassificationType.CESIUM_3D_TILE,
+      })
+    )
+    this.highlightPrimitive.readyPromise.then(() => {
+      //设置当前点击的贴对象面不显示
+      pickFeature.primitive.show = false;
+    })
+    this.clickHighlightPrimitive = pickFeature.primitive;
+    this.handlePickHouse(pickFeature.id)
+  }
+
+  //处理拾取到的户室信息
+  handlePickHouse(id) {
+    this.HandlePickHouseEvent.raiseEvent({}); //触发选中事件 通知界面更新
+  }
+
+  activate() {
+    this.isActivate = true;
+  }
+
+  deactivate() {
+    this.isActivate = false;
+  }
+}
+
+export default DTH

src/Global/ExportKml/index.js

@@ -0,0 +1,53 @@
+/**
+ * @name: index
+ * @author: Administrator
+ * @date: 2023-09-11 16:41
+ * @description：index
+ * @update: 2023-09-11 16:41
+ */
+import BillboardObject from "../../Obj/Base/BillboardObject";
+import PolygonObject from "../../Obj/Base/PolygonObject";
+import PolylineObject from "../../Obj/Base/PolylineObject";
+import Circle from "../../Obj/Base/CircleDiffuse";
+
+function exportKml(list = []) {
+
+  let entities = new Cesium.EntityCollection();
+  list.forEach(entity => {
+    if (
+      entity instanceof BillboardObject ||
+      entity instanceof PolygonObject ||
+      entity instanceof Circle ||
+      entity instanceof PolylineObject
+    ) {
+      entities.add(entity.entity)
+    }
+  })
+  if (entities.values.length) {
+    let promise = Cesium.exportKml({entities})
+    promise.then(e => {
+      // Cesium.exportKml(e.kml,)
+      funDownload(e.kml, new Date().getTime() + ".kml")
+    })
+  } else {
+    console.error("允许导出为kml的对象为空")
+  }
+}
+
+function funDownload(content, filename) {
+  let eleLink = document.createElement("a");
+  eleLink.download = filename;
+  eleLink.style.display = "none";
+  // 字符内容转变成blob地址
+  let blob = new Blob([content]);
+  eleLink.href = URL.createObjectURL(blob);
+  // 触发点击
+  document.body.appendChild(eleLink);
+  eleLink.click();
+  // 然后移除
+  document.body.removeChild(eleLink);
+}
+
+
+export default exportKml
+

src/Global/FlyRoam/_element.js

@@ -0,0 +1,67 @@
+function html() {
+    return `
+    <span class="custom-divider"></span>
+    <div class="div-item">
+        <div class="row">
+            <div class="col">
+                <span class="label">名称</span>
+                <input class="input" type="text" name="name">
+            </div>
+            <div class="col"></div>
+        </div>
+    </div>
+    <span class="custom-divider"></span>
+    <div class="div-item">
+        <div class="row">
+            <div class="col">
+                <input type="checkbox" name="isTotalTime" style="width: 16px; line-height: 15px; height: 15px; cursor: pointer; width: auto; margin-right: 5px;">
+                <span class="label">设置总时长</span>
+                <div class="input-number input-number-unit-3">
+                    <input class="input total-time" type="number" title="" min="0" max="999999.99" step="0.01" name="totalTime" value="0">
+                    <span class="unit" style="top: 6px;">秒(s)</span>
+                    <span class="arrow"></span>
+                </div>
+            </div>
+            <div class="col">
+                <input type="checkbox" name="repeat" style="width: 16px; line-height: 15px; height: 15px; cursor: pointer; width: auto; margin-right: 5px;">
+                <span class="label">是否循环播放</span>
+            </div>
+        </div>
+    </div>
+    <span class="custom-divider"></span>
+    <div class="div-item">
+        <div class="row">
+            <div class="col">
+                <button class="add-point"><svg class="icon-add"><use xlink:href="#yj-icon-add"></use></svg>增加视点</button>
+            </div>
+            <div class="col">
+                <button class="modify-point"><svg class="icon-edit"><use xlink:href="#yj-icon-edit"></use></svg>调整视点</button>
+            </div>
+            <div class="col">
+                <button class="afreshPlay"><svg class="icon-play"><use xlink:href="#yj-icon-play"></use></svg>播放</button>
+            </div>
+            <div class="col">
+                <button class="cease"><svg class="icon-pause"><use xlink:href="#yj-icon-pause"></use></svg>结束</button>
+            </div>
+        </div>
+        <div class="table">
+            <div class="table-head">
+                <div class="tr">
+                    <div class="th">序号</div>
+                    <div class="th">时长(s)</div>
+                    <div class="th">操作</div>
+                </div>
+            </div>
+            <div class="table-body">
+            <div class="table-empty">
+                <div class="empty-img"></div>
+                <p>暂无数据</p>
+            </div>
+            </div>
+        </div>
+    </div>
+    <span class="custom-divider"></span>
+    `
+}
+
+export { html }

src/Global/FlyRoam/index.js

@@ -0,0 +1,389 @@
+
+/**
+ * @description 飞行漫游
+ */
+import Dialog from '../../BaseDialog';
+import { html } from "./_element";
+import Tools from "../../Tools";
+import { closeRotateAround, closeViewFollow} from '../../Global/global'
+let _DialogObject = null
+let clickHandler
+let repeat = 0
+let currentRepeat = 0
+
+
+const open = async (sdk, options = {}, _Dialog = {}) => {
+  let name = options.name || '漫游路径'
+  options.points || (options.points = [])
+  if(options.repeat) {
+    repeat = Number(options.repeat)
+  }
+  let viewer = sdk.viewer
+  let tools = new Tools(sdk)
+  let active = 0
+
+  if (_DialogObject && _DialogObject.close) {
+    _DialogObject.close()
+    _DialogObject = null
+  }
+
+  _DialogObject = await new Dialog(viewer._container, {
+    title: '飞行漫游', left: '180px', top: '100px',
+    closeCallBack: () => {
+      cease({ viewer })
+    },
+  })
+  await _DialogObject.init()
+  let contentElm = document.createElement('div');
+  contentElm.className = 'fly-roam'
+  contentElm.innerHTML = html()
+  _DialogObject.contentAppChild(contentElm)
+
+  let all_elm = contentElm.getElementsByTagName("*")
+  // EventBinding(all_elm)
+
+  let tableBody = contentElm.getElementsByClassName('table-body')[0];
+  let tableEmpty = contentElm.getElementsByClassName('table-empty')[0]
+
+  let handler = {
+    set: function (target, prop, value) {
+      target[prop] = value;
+      if (target.length > 0) {
+        tableEmpty.style.display = 'none'
+      }
+      else {
+        tableEmpty.style.display = 'flex'
+      }
+      return true;
+    },
+  };
+  let i = 0
+  let points = new Proxy([], handler);
+  for (i = 0; i < options.points.length; i++) {
+    points.push(options.points[i])
+    addTrElm(options.points[i])
+  }
+
+
+  // let nameImputBoxElm = contentElm.getElementsByClassName('input-box')[0]
+  // check(nameImputBoxElm, { validator: 'notEmpty', message: '名称不能为空！', trigger: 'input' })
+  let nameElm = contentElm.querySelector("input[name='name']")
+  nameElm.value = name
+  nameElm.addEventListener('input', () => {
+    name = nameElm.value
+  })
+
+  let addListBtn = document.createElement('button');
+  addListBtn.innerHTML = '保存'
+  addListBtn.addEventListener('click', () => {
+    if (!name) {
+      name = '漫游路径'
+      nameElm.value = name
+    }
+    let newPoints = []
+    points.map((item) => {
+      newPoints.push(item)
+    })
+    _Dialog.clickSavePath && _Dialog.clickSavePath(
+      {
+        name: name,
+        points: newPoints,
+        repeat: repeat+''
+      }
+    )
+  })
+  _DialogObject.footAppChild(addListBtn)
+
+  let endBtn = contentElm.getElementsByClassName('cease')[0]
+  endBtn.addEventListener('click', () => {
+    viewer.camera.cancelFlight()
+  })
+
+  let flyBtn = contentElm.getElementsByClassName('afreshPlay')[0]
+  flyBtn.addEventListener('click', () => {
+    if (points.length > 0) {
+      flyTo(sdk, points, 0)
+    }
+  })
+
+  let addBtn = contentElm.getElementsByClassName('add-point')[0]
+  addBtn.addEventListener('click', () => {
+    let position = tools.cartesian3Towgs84(viewer.camera.position, viewer)
+    let time = 0
+    let data = {
+      duration: time,
+      position: position,
+      orientation: {
+        heading: viewer.camera.heading,
+        pitch: viewer.camera.pitch,
+        roll: viewer.camera.roll
+      }
+    }
+    points.splice(active, 0, data)
+    addTrElm(data)
+    i++
+  })
+  let modifyBtn = contentElm.getElementsByClassName('modify-point')[0]
+  modifyBtn.addEventListener('click', () => {
+    if (!active) {
+      return
+    }
+    let position = tools.cartesian3Towgs84(viewer.camera.position, viewer)
+    points[active - 1].position = position
+    points[active - 1].orientation = {
+      heading: viewer.camera.heading,
+      pitch: viewer.camera.pitch,
+      roll: viewer.camera.roll
+    }
+  })
+
+  let totalTimeElm = contentElm.querySelector("input[name='totalTime']")
+  let isTotalTimeElm = contentElm.querySelector("input[name='isTotalTime']")
+  let repeatElm = contentElm.querySelector("input[name='repeat']")
+  isTotalTimeElm.addEventListener('change', () => {
+    let trList = tableBody.getElementsByClassName('tr')
+    if (isTotalTimeElm.checked && trList.length > 0) {
+      let time = Number((Number(totalTimeElm.value) / (trList.length - 1)).toFixed(2))
+      for (let i = 0; i < trList.length - 1; i++) {
+        points[i].duration = time
+        trList[i].querySelector("input[name='time']").value = time
+      }
+      trList[trList.length - 1].querySelector("input[name='time']").value = 0
+    }
+  })
+  totalTimeElm.addEventListener('blur', () => {
+    let trList = tableBody.getElementsByClassName('tr')
+    totalTimeElm.value = Number(totalTimeElm.value)
+    if (totalTimeElm.value < 0) {
+      totalTimeElm.value = 0
+    }
+    if (isTotalTimeElm.checked && trList.length > 0) {
+      let time = Number((Number(totalTimeElm.value) / (trList.length - 1)).toFixed(2))
+      for (let i = 0; i < trList.length - 1; i++) {
+        points[i].duration = time
+        trList[i].querySelector("input[name='time']").value = time
+      }
+      trList[trList.length - 1].querySelector("input[name='time']").value = 0
+    }
+  })
+  repeatElm.checked = (repeat === Infinity ? true : false)
+  repeatElm.addEventListener('change', () => {
+    if (repeatElm.checked) {
+      repeat = Infinity
+    }
+    else {
+      repeat = 0
+    }
+    currentRepeat = repeat
+    _Dialog.changeRepeatStateCallBack && _Dialog.changeRepeatStateCallBack(repeatElm.checked)
+  })
+
+  // Object.defineProperty(options, 'points', {
+  //   get() {
+  //     return e_allArea.value
+  //   },
+  //   set(value) {
+  //     e_allArea.value = value
+  //   }
+  // })
+
+  function addTrElm(data) {
+    let trList = tableBody.getElementsByClassName('tr')
+    if (trList.length > 0) {
+      trList[trList.length - 1].querySelector("input[name='time']").disabled = undefined
+    }
+    let tr_active = tableBody.getElementsByClassName('tr active')[0]
+    tr_active && (tr_active.className = 'tr')
+    let tr = document.createElement('div');
+    tr.className = 'tr active'
+    tr.innerHTML = `
+      <div class="td" style="justify-content: center;">视点${i + 1}</div>
+      <div class="td">
+        <input class="input time" type="number" title="" min="0" max="999.99" step="0.01" name="time" value="${data.duration}">
+      </div>
+      <div class="td action">
+        <button class="play">播放</span>
+        <button class="delete">删除</span>
+      </div>
+      `
+    tr.addEventListener('click', (v) => {
+      if (v.target.parentNode === tr) {
+        let tr_active = tableBody.getElementsByClassName('tr active')[0]
+        tr_active && (tr_active.className = 'tr')
+        tr.className = 'tr active'
+        for (let m = 0; m < trList.length; m++) {
+          if (trList[m] === tr) {
+            active = m + 1
+            break
+          }
+        }
+      }
+    })
+    tr.addEventListener('dblclick', (v) => {
+      if (v.target.parentNode === tr) {
+        for (let m = 0; m < trList.length; m++) {
+          if (trList[m] === tr) {
+            viewer.camera.flyTo({
+              destination: Cesium.Cartesian3.fromDegrees(points[m].position.lng, points[m].position.lat, points[m].position.alt),
+              orientation: points[m].orientation,
+              duration: 1
+            })
+            break
+          }
+        }
+      }
+    })
+    let e_play = tr.getElementsByClassName('play')[0]
+    let e_delete = tr.getElementsByClassName('delete')[0]
+    let e_time = tr.querySelector("input[name='time']")
+    e_play.addEventListener('click', () => {
+      for (let m = 0; m < trList.length; m++) {
+        if (trList[m] === e_delete.parentNode.parentNode) {
+          flyTo(sdk, points, m)
+        }
+      }
+    })
+    e_delete.addEventListener("click", (v) => {
+      for (let m = 0; m < trList.length; m++) {
+        if (trList[m] === e_delete.parentNode.parentNode) {
+          points.splice(m, 1)
+          points[points.length-1] && (points[points.length-1].duration = 0)
+          tableBody.removeChild(tr)
+          if (active > m + 1) {
+            active--
+            trList[active - 1].className = 'tr active'
+          }
+          else if (active == m + 1) {
+            if (trList.length == m) {
+              active -= 1
+            }
+            if (trList.length != 0) {
+              trList[active - 1].className = 'tr active'
+            }
+          }
+          // else if(active == m) {
+          //   console.log(trList.length-1, active)
+          //   if (trList.length == active-1) {
+          //     trList[active-2].className = 'tr active'
+          //   }
+          //   else {
+          //     trList[active-1].className = 'tr active'
+          //   }
+          // }
+          if (trList.length > 0) {
+            let lastElm = trList[trList.length - 1].querySelector("input[name='time']")
+            lastElm.disabled = 'disabled'
+            lastElm.value = 0
+          }
+          break
+        }
+      }
+      // points.splice(i, 1)
+      // tableBody.removeChild(tr)
+      // if (trList.length > 0) {
+      //   trList[trList.length - 1].querySelector("input[name='time']").disabled = 'disabled'
+      // }
+    })
+    e_time.addEventListener('input', (v) => {
+      isTotalTimeElm.checked = false
+      data.duration = Number(e_time.value)
+      if (data.duration < 0) {
+        data.duration = 0
+      }
+    })
+    e_time.addEventListener('blur', () => {
+      e_time.value = Number(Number(e_time.value).toFixed(2))
+      if (e_time.value < 0) {
+        e_time.value = 0
+      }
+    });
+    tableBody.insertBefore(tr, trList[active])
+    active++
+    trList[trList.length - 1].querySelector("input[name='time']").disabled = 'disabled'
+  }
+
+
+}
+
+const close = () => {
+  if (_DialogObject && _DialogObject.close) {
+    _DialogObject.close()
+    _DialogObject = null
+  }
+}
+
+const executeFlyTo = (sdk, points = [], index = 0, noStart) => {
+  if (clickHandler) {
+    clickHandler.destroy()
+  }
+  clickHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
+  clickHandler.setInputAction((movement) => {
+    cease(sdk)
+  }, Cesium.ScreenSpaceEventType.RIGHT_CLICK)
+  let viewer = sdk.viewer
+  viewer.camera.cancelFlight()
+  // function pauseExecution(seconds) {
+  //   return new Promise(resolve => setTimeout(resolve, seconds * 1000));
+  // }
+  closeRotateAround(sdk)
+  closeViewFollow(sdk)
+  viewer.camera.flyTo({
+    destination: Cesium.Cartesian3.fromDegrees(points[index].position.lng, points[index].position.lat, points[index].position.alt),
+    orientation: points[index].orientation,
+    duration: noStart ? points[index - 1].duration : 0.5,
+    maximumHeight: points[index].position.alt,
+    complete: async () => {
+      if (!noStart) {
+        // await pauseExecution(2)
+      }
+      index++
+      if (index <= points.length - 1) {
+        executeFlyTo(sdk, points, index, true)
+      }
+      else if (currentRepeat && points.length > 1) {
+        currentRepeat--
+        executeFlyTo(sdk, points, 0)
+      }
+      else {
+        if (clickHandler) {
+          clickHandler.destroy()
+        }
+      }
+
+    },
+    easingFunction: noStart ? Cesium.EasingFunction.LINEAR_NONE : Cesium.EasingFunction.EXPONENTIAL_OUT
+  })
+}
+
+const flyTo = (sdk, points = [], index = 0, noStart) => {
+  currentRepeat = repeat
+  executeFlyTo(sdk, points, index, noStart)
+}
+
+/**设置循环次数 (Infinity: 无限循环)*/
+const setRepeat = (v) => {
+  if (repeat != Number(v)) {
+    repeat = Number(v)
+    currentRepeat = repeat
+    if (_DialogObject && _DialogObject._element && _DialogObject._element.content) {
+      let repeatElm = _DialogObject._element.content.querySelector("input[name='repeat']")
+      if (v === Infinity) {
+        repeatElm.checked = true
+      }
+      else {
+        repeatElm.checked = false
+      }
+    }
+  }
+}
+
+
+/** 停止 */
+const cease = (sdk) => {
+  sdk && sdk.viewer && sdk.viewer.camera.cancelFlight()
+  if (clickHandler) {
+    clickHandler.destroy()
+  }
+}
+
+export { open, close, flyTo, setRepeat, cease }

src/Global/KeyBoard/index.js

@@ -0,0 +1,235 @@
+/*
+ * @Description: 使用键盘控制地图漫游
+ * @Version: 1.0
+ * @Author: Julian
+ * @Date: 2022-04-07 16:04:07
+ * @LastEditors: Julian
+ * @LastEditTime: 2022-04-07 18:40:40
+ */
+
+
+/**
+ * @description: 使用键盘控制地图漫游初始化
+ * @param {*} _viewer
+ * @return {*}
+ */
+function keyboardMapRoamingInit(_viewer) {
+  // 添加键盘监听事件
+  document.addEventListener('keydown', keyDown.bind(_viewer), false);
+  document.addEventListener('keyup', keyUp.bind(_viewer), false);
+
+  // 为每一帧添加监听事件
+  _viewer && _viewer.clock.onTick.addEventListener(function () {
+    keyboardMapRoamingRender(_viewer);
+  });
+}
+
+// 定义事件组
+let flags = {
+  // 相机位置
+  moveForward: false,
+  moveBackward: false,
+  moveLeft: false,
+  moveRight: false,
+  moveUp: false,
+  moveDown: false,
+  // 相机姿态
+  lookUp: false,
+  lookDown: false,
+  lookLeft: false,
+  lookRight: false,
+  twistLeft: false,
+  twistRight: false,
+  // 缩放
+  zoomIn: false,
+  zoomOut: false
+}
+
+
+// 相机位置：W：向前；S：向后；D：向右；A：向左；Q：升高；E：降低；
+// 相机姿态：↑：抬头；↓：低头；←：左转；→：右转；0：顺时针；.：逆时针
+// 缩放：+：放大，-：缩小；
+
+/**
+ * @description: 根据键盘输入字符返回事件信息
+ * @param {*} key
+ * @return {*}
+ */
+function getFlagFromKeyboard(key) {
+  switch (key) {
+    // 按字符的Unicode编码
+    // 相机位置
+    case 87:
+      return 'moveForward';
+    case 83:
+      return 'moveBackward';
+    case 68:
+      return 'moveRight';
+    case 65:
+      return 'moveLeft';
+    case 81:
+      return 'moveUp';
+    case 69:
+      return 'moveDown';
+    // 相机姿态
+    case 38:
+      return 'lookUp';
+    case 40:
+      return 'lookDown';
+    case 37:
+      return 'lookLeft';
+    case 39:
+      return 'lookRight';
+    case 96:
+      return 'twistLeft';
+    case 110:
+      return 'twistRight';
+    // 缩放
+    case 107:
+      return 'zoomIn';
+    case 109:
+      return 'zoomOut';
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * @description: 键盘按下
+ * @param {*} event
+ * @return {*}
+ */
+function keyDown(event) {
+  let _viewer = this
+  // 判断是否有输入框聚焦
+  function isInputFocused() {
+    const activeElement = document.activeElement;
+    return (activeElement.tagName.toLowerCase() === 'input' && activeElement.type !== 'checkbox') ||
+      activeElement.tagName.toLowerCase() === 'textarea' ||
+      activeElement.getAttribute('role') === 'textarea';
+  }
+
+  if (isInputFocused()) {
+    // console.log('页面上有输入框已经获取焦点');
+  } else if (_viewer.trackedEntity) {
+    // console.log('视角跟随中');
+  } else if (_viewer._firstPersonView) {
+    // console.log('第一人称视角中');
+  } else if (_viewer._disableKeyboardEvent) {
+    // console.log('禁用键盘事件');
+  } else if (event.ctrlKey && event.altKey) {
+    if (event.key === 'v' || event.key === 'V') {
+      let camera = _viewer.camera
+      _viewer._CAMERA_SHORTCUT_VIEW = {
+        orientation: { heading: camera.heading, pitch: camera.pitch, roll: camera.roll },
+        position: { x: camera.position.x, y: camera.position.y, z: camera.position.z }
+      }
+      localStorage.setItem('CAMERA_SHORTCUT_VIEW', JSON.stringify(_viewer._CAMERA_SHORTCUT_VIEW))
+    }
+    if (event.key === 'f' || event.key === 'F') {
+      let CAMERA_SHORTCUT_VIEW = localStorage.getItem('CAMERA_SHORTCUT_VIEW')
+      _viewer._CAMERA_SHORTCUT_VIEW = JSON.parse(CAMERA_SHORTCUT_VIEW)
+      if (_viewer._CAMERA_SHORTCUT_VIEW && _viewer._CAMERA_SHORTCUT_VIEW.position && _viewer._CAMERA_SHORTCUT_VIEW.orientation) {
+        _viewer.camera.flyTo({
+          destination: _viewer._CAMERA_SHORTCUT_VIEW.position,
+          orientation: _viewer._CAMERA_SHORTCUT_VIEW.orientation
+        })
+      }
+    }
+  } else {
+    // console.log('页面上没有输入框获取焦点');
+    let flagName = getFlagFromKeyboard(event.keyCode);
+    if (typeof flagName !== 'undefined') {
+      flags[flagName] = true;
+    }
+  }
+}
+
+/**
+ * @description: 键盘弹起
+ * @param {*} event
+ * @return {*}
+ */
+function keyUp(event) {
+  let flagName = getFlagFromKeyboard(event.keyCode);
+  if (typeof flagName !== 'undefined') {
+    flags[flagName] = false;
+  }
+}
+
+
+/**
+ * @description: 根据事件调整相机
+ * @param {*} _viewer
+ * @return {*}
+ */
+function keyboardMapRoamingRender(_viewer) {
+  if(!_viewer.scene.screenSpaceCameraController.enableTilt) {
+    return
+  }
+  let camera = _viewer.camera;
+  let ellipsoid = _viewer.scene.globe.ellipsoid;
+  let cameraHeight = ellipsoid.cartesianToCartographic(camera.position).height;
+
+  // 根据相机高度设置移动距离，比默认距离移动效果更好
+  let moveRate = cameraHeight / 20.0;
+  let rotationRate = moveRate / 500000 / Cesium.Math.toDegrees(camera.pitch);
+
+  if (flags.moveForward) {
+    // camera.moveForward(moveRate);
+    camera.rotate(camera.right, -rotationRate);
+  }
+  if (flags.moveBackward) {
+    // camera.moveBackward(moveRate);
+    camera.rotate(camera.right, rotationRate);
+  }
+  if (flags.moveLeft) {
+    // camera.moveLeft(moveRate);
+    camera.rotate(camera.up, -rotationRate);
+  }
+  if (flags.moveRight) {
+    // camera.moveRight(moveRate);
+    camera.rotate(camera.up, rotationRate);
+  }
+  if (flags.moveUp) {
+    camera.moveUp(moveRate);
+  }
+  if (flags.moveDown) {
+    camera.moveDown(moveRate);
+  }
+  if (flags.lookUp) {
+    camera.lookUp();
+  }
+  if (flags.lookDown) {
+    camera.lookDown();
+  }
+  if (flags.lookLeft) {
+    camera.lookLeft();
+  }
+  if (flags.lookRight) {
+    camera.lookRight();
+  }
+  if (flags.twistLeft) {
+    camera.twistLeft();
+  }
+  if (flags.twistRight) {
+    camera.twistRight();
+  }
+  // 根据相机高度设置缩放参数
+  if (flags.zoomIn) {
+    let height = cameraHeight / 2
+    if (height < 1) {
+      height = 0
+    }
+    camera.zoomIn(height);
+  }
+  if (flags.zoomOut) {
+    let height = cameraHeight / 2
+    if ((cameraHeight + cameraHeight) >= 50000000) {
+      height = 50000000 - cameraHeight
+    }
+    camera.zoomOut(height);
+  }
+}
+
+export { keyboardMapRoamingInit }

src/Global/MapPrint/dataSource.js

@@ -0,0 +1,117 @@
+function getTemplateData(tools) {
+  return [
+    {
+      "name": "模板一",
+      "value": "模板一",
+      "id": "1",
+      margin: 0.03,
+      title: {
+        text: '标题一',
+        height: 0.05,
+        bgColor: '#5d5d5d',
+        color: '#ffffff',
+        show: true,
+      },
+      border: {
+        show: false,
+        url: '/custom/img/map-border1.svg',
+        width: 0.01,
+        color: ''
+      },
+      plottingScale: {
+        cell: 2,
+        color: '#ffffff',
+        show: true,
+        isSelected: false,
+        x: 0.87,
+        y: 0.97,
+      },
+      data: [
+        {
+          text: '',
+          x: 0.02,
+          y: 0.93,
+          isSelected: false,
+          show: true,
+          color: '#ffffff',
+          height: 0.03
+        },
+        {
+          text: '',
+          x: 0.02,
+          y: 0.97,
+          isSelected: false,
+          show: true,
+          color: '#ffffff',
+          height: 0.03
+        },
+        {
+          x: 0.02,
+          y: 0.1,
+          show: false,
+          isSelected: false,
+          url: '/custom/img/icon-compass1.svg',
+          width: 0.1,
+          height: 0.1
+        }
+      ]
+    },
+    {
+      "name": "模板二",
+      "value": "模板二",
+      "id": "2",
+      margin: 0.03,
+      border: {
+        show: true,
+        url: '/custom/img/map-border2.svg',
+        width: 0.01,
+      },
+      title: {
+        text: '标题二',
+        height: 0.05,
+        bgColor: '#5d5d5d',
+        color: '#ffffff',
+        show: true,
+      },
+      plottingScale: {
+        cell: 2,
+        color: '#ffffff',
+        show: true,
+        isSelected: false,
+        x: 0.02,
+        y: 0.97,
+      },
+      data: [
+        {
+          text: '',
+          x: 0.88,
+          y: 0.93,
+          isSelected: false,
+          show: true,
+          color: '#ffffff',
+          height: 0.03
+        },
+        {
+          text: '',
+          x: 0.87,
+          y: 0.97,
+          isSelected: false,
+          show: true,
+          color: '#ffffff',
+          height: 0.03
+        },
+        {
+          x: 0.91,
+          y: 0.1,
+          show: true,
+          isSelected: false,
+          url: '/custom/img/icon-compass4.svg',
+          width: 0.1,
+          height: 0.1
+        }
+      ]
+    }
+  ]
+}
+
+export { getTemplateData };

src/Global/MapX/index.js

@@ -0,0 +1,170 @@
+import Tools from '../../Tools'
+import Event from '../../Event'
+
+let tools
+let Xevent
+let mapx = {}
+let curRectangle = undefined;
+let centerResult = undefined
+let mouseStart = false
+let syncObject = {}
+const init = (sdk) => {
+  tools = new Tools()
+  let div = document.createElement('div');
+  div.id = 'mapxDiv'
+  div.style.width = '222px';
+  div.style.height = '112px';
+  div.style.position = 'absolute';
+  div.style.right = '10px';
+  div.style.bottom = '82px';
+  div.style.zIndex = '1';
+  document.getElementById(sdk.div_id).appendChild(div)
+  let options = {
+    imageryProvider: new Cesium.TileMapServiceImageryProvider({
+      url: Cesium.buildModuleUrl("Assets/Textures/NaturalEarthII"),
+    }),
+    sceneMode: Cesium.SceneMode.SCENE2D,
+    // mapMode2D: Cesium.MapMode2D.ROTATE,
+    baseLayerPicker: false,
+    geocoder: false,
+    animation: false,
+    fullscreenButton: false,
+    navigationHelpButton: false,
+    // vrButton?: boolean;
+    homeButton: false,
+    infoBox: false,
+    sceneModePicker: false,
+    selectionIndicator: false,
+    timeline: false,
+    shouldAnimate: true
+  }
+  mapx.viewer = new Cesium.Viewer('mapxDiv', options);
+  mapx.viewer.camera.setView({
+    destination: Cesium.Cartesian3.fromDegrees(0, 0, 40000000),
+  })
+  mapx.viewer.trackedEntity = undefined;
+  mapx.viewer.cesiumWidget.screenSpaceEventHandler.removeInputAction(
+    Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK
+  );
+  mapx.viewer.scene.screenSpaceCameraController.enableRotate = false;
+  mapx.viewer.scene.screenSpaceCameraController.enableTranslate = false;
+  mapx.viewer.scene.screenSpaceCameraController.enableZoom = false;
+  mapx.viewer.scene.screenSpaceCameraController.enableTilt = false;
+  mapx.viewer.scene.screenSpaceCameraController.enableLook = false;
+
+  // 创建范围框
+  let entity = mapx.viewer.entities.add({
+    name: 'mapX rectangle',
+    position: new Cesium.CallbackProperty(function () {
+      return (
+        centerResult || Cesium.Cartesian3.fromDegrees(0, 0, 0)
+      );
+    }, false),
+    rectangle: {
+      coordinates: new Cesium.CallbackProperty(function () {
+        return (
+          curRectangle || Cesium.Rectangle.fromDegrees(0.0, 0.0, 0.01, 0.01)
+        );
+      }, false),
+      material: Cesium.Color.RED.withAlpha(0.01),
+      outline: true,
+      outlineColor: Cesium.Color.RED,
+      outlineWidth: 2,
+      height: 1,
+    },
+    billboard: {
+      image: tools.getSourceRootPath() + '/img/cross.svg',
+      scale: 1,
+      width: 16,
+      height: 16
+    },
+  });
+  syncObject = { sdk, entity }
+  mapx.viewer.camera.percentageChanged = 0.001;
+  sdk.viewer.scene.preRender.addEventListener(syncViewer, syncObject); // 鹰眼与主图同步
+  let pick
+  Xevent = new Event({ viewer: mapx.viewer })
+  Xevent.mouse_left_down((movement, cartesian) => {
+    mouseStart = true
+    pick = mapx.viewer.scene.pick(movement.position)
+  })
+  Xevent.mouse_left_up((movement, cartesian) => {
+    mouseStart = false
+  })
+  Xevent.mouse_move((movement, cartesian) => {
+    if (pick && mouseStart) {
+      let sdkCH = tools.cartesian3Towgs84(sdk.viewer.camera.position, sdk.viewer).alt
+      let pos84 = tools.cartesian3Towgs84(cartesian, mapx.viewer)
+      // sdk.viewer.camera.position = Cesium.Cartesian3.fromDegrees(pos84.lng, pos84.lat, sdkCH)
+      sdk.viewer.camera.flyTo({
+        destination: Cesium.Cartesian3.fromDegrees(pos84.lng, pos84.lat, sdkCH),
+        duration: 0
+      })
+    }
+  })
+}
+function syncViewer() {
+  if(!this.sdk || !this.sdk.viewer) {
+    return
+  }
+  // 视角中心点(伪)
+  centerResult = this.sdk.viewer.camera.pickEllipsoid(
+    new Cesium.Cartesian2(
+      this.sdk.viewer.canvas.clientWidth / 2,
+      this.sdk.viewer.canvas.clientHeight / (2 - ((90 + this.sdk.viewer.camera.pitch / (Cesium.Math.PI / 180)) / 110)),
+    ),
+  )
+  if (!centerResult) {
+    centerResult = this.sdk.viewer.camera.position
+  }
+  let height = tools.cartesian3Towgs84(this.sdk.viewer.camera.position, this.sdk.viewer).alt
+  let centerResult84 = tools.cartesian3Towgs84(centerResult, this.sdk.viewer)
+  let stepX = 120000
+  let stepY = 280000
+  if (height > 9000000) {
+    height = 9000000
+  }
+  if (height < 100000) {
+    this.entity.billboard.show = true
+    this.entity.rectangle.show = false
+  }
+  else {
+    this.entity.billboard.show = false
+    this.entity.rectangle.show = true
+  }
+  curRectangle = new Cesium.Rectangle(Cesium.Math.toRadians(centerResult84.lng - (height / stepX)), Cesium.Math.toRadians(centerResult84.lat - (height / stepY)), Cesium.Math.toRadians(centerResult84.lng + (height / stepX)), Cesium.Math.toRadians(centerResult84.lat + (height / stepY)))
+};
+function open(sdk) {
+  if (!mapx.viewer) {
+    init(sdk)
+  }
+  else {
+    mapx.viewer.container.style.display = 'block';
+    let entity
+    let entities = mapx.viewer.entities.values
+    for (let i = 0; i < entities.length; i++) {
+      if (entities[i].name === 'mapX rectangle') {
+        entity = entities[i]
+        break
+      }
+    }
+    sdk.viewer.scene.preRender.addEventListener(syncViewer, syncObject); // 鹰眼与主图同步
+  }
+}
+function close(sdk) {
+  if (!mapx.viewer) {
+    return
+  }
+  mapx.viewer.container.style.display = 'none';
+  let entity
+  let entities = mapx.viewer.entities.values
+  for (let i = 0; i < entities.length; i++) {
+    if (entities[i].name === 'mapX rectangle') {
+      entity = entities[i]
+      break
+    }
+  }
+  sdk.viewer.scene.preRender.removeEventListener(syncViewer, syncObject)
+}
+
+export { open, close }

src/Global/MouseCoordinate/index.js

@@ -0,0 +1,112 @@
+/**
+ * 鼠标坐标
+ */
+import Tools from "../../Tools";
+import { getCoordinateSystem } from "../../Global/global";
+import MouseEvent from '../../Event/index'
+
+let event
+let MouseCoordinateElm
+let requestAnimationFrameEventId
+
+const MouseCoordinate = (sdk, status) => {
+  let tools = new Tools(sdk)
+  if (status) {
+    if (event) {
+      event.destroy()
+    }
+    event = new MouseEvent(sdk)
+    let position = {
+      x: '',
+      y: '',
+      z: ''
+    }
+    let contentElm
+    if (MouseCoordinateElm) {
+      contentElm = MouseCoordinateElm
+    }
+    else {
+      contentElm = document.createElement('div');
+      contentElm.style.position = 'absolute';
+      contentElm.style['z-index'] = 777;
+      contentElm.style.color = '#ff0000';
+      contentElm.style.left = '0px';
+      contentElm.style.top = '0px';
+      contentElm.style.width = '100%';
+      contentElm.style.height = '100%';
+      contentElm.style['font-size'] = '12px';
+      contentElm.style['pointer-events'] = 'none';
+      contentElm.style.background = `url(${tools.getSourceRootPath()}/img/cross.png) no-repeat 100% 100%`;
+      contentElm.style['background-size'] = `200% 200%`;
+      MouseCoordinateElm = contentElm
+    }
+    sdk.viewer._element.appendChild(contentElm)
+    let tmovement
+    event.mouse_move((movement, cartesian) => {
+      tmovement = { ...movement }
+    })
+
+    const getPosition = () => {
+      if(!tmovement) {
+        return
+      }
+      let canvas = sdk.viewer._element.getElementsByTagName('canvas')[0]
+      let left = tmovement.endPosition.x;
+      let top = tmovement.endPosition.y;
+      let cartesian = event.getcartesian(tmovement)
+      contentElm.style['background-position-x'] = `${-canvas.width + left + 4}px`;
+      contentElm.style['background-position-y'] = `${-canvas.height + top - 2}px`;
+      // this.entity.position = cartesian
+      if (cartesian) {
+        let degrees = tools.cartesian3Towgs84(cartesian, sdk.viewer)
+        let coordinateSystem = getCoordinateSystem()
+        if (coordinateSystem === 'EPSG:4326') {
+          position = {
+            x: degrees.lng,
+            y: degrees.lat,
+            z: degrees.alt
+          }
+          contentElm.innerHTML = `<div style='width: 150px;position: absolute; z-index: 777; color: #ff0000; font-size: 12px; left:${left + 20}px; top:${top + 10}px;'><p style='margin: 0;'>经度：${degrees.lng.toFixed(6)}°</p><p style='margin: 0;'>维度：${degrees.lat.toFixed(6)}°</p><p style='margin: 0;'>海拔：${degrees.alt.toFixed(2)} m</p></div>`
+        }
+        else {
+          let result = tools.convert([{ x: degrees.lng, y: degrees.lat, z: degrees.alt }], 'EPSG:4326', coordinateSystem)
+          position = result.points[0]
+          contentElm.innerHTML = `<div style='width: 150px;position: absolute; z-index: 777; color: #ff0000; font-size: 12px; left:${left + 20}px; top:${top + 10}px;'><p style='margin: 0;'>x：${position.x.toFixed(6)}</p><p style='margin: 0;'>y：${position.y.toFixed(6)}</p><p style='margin: 0;'>z：${position.z.toFixed(6)}</p></div>`
+        }
+      }
+      else {
+        let coordinateSystem = getCoordinateSystem()
+        if (coordinateSystem === 'EPSG:4326') {
+          contentElm.innerHTML = `<div style='width: 150px;position: absolute; z-index: 777; color: #ff0000; font-size: 12px; left:${left + 20}px; top:${top + 10}px;'><p style='margin: 0;'>经度：-</p><p style='margin: 0;'>维度：-</p><p style='margin: 0;'>海拔：-</p></div>`
+        }
+        else {
+          contentElm.innerHTML = `<div style='width: 150px;position: absolute; z-index: 777; color: #ff0000; font-size: 12px; left:${left + 20}px; top:${top + 10}px;'><p style='margin: 0;'>x：-</p><p style='margin: 0;'>y：-</p><p style='margin: 0;'>z：-</p></div>`
+        }
+      }
+
+    }
+
+    animateUpdate()
+    function animateUpdate() {
+      requestAnimationFrameEventId = requestAnimationFrame(
+        animateUpdate
+      )
+      getPosition()
+    }
+  }
+  else {
+    if (event) {
+      event.destroy()
+      event = undefined
+    }
+    if (MouseCoordinateElm) {
+      sdk.viewer._element.removeChild(MouseCoordinateElm)
+      MouseCoordinateElm = undefined
+    }
+    if (requestAnimationFrameEventId) {
+      cancelAnimationFrame(requestAnimationFrameEventId)
+    }
+  }
+}
+
+export { MouseCoordinate }

src/Global/MultiViewportMode/index.js

@@ -0,0 +1,561 @@
+/**
+ * 多视口模式 
+ * */
+import Tools from "../../Tools";
+import MouseEvent from '../../Event'
+import { CesiumContainer } from '../global'
+import { off as offSplitScreen } from "../SplitScreen";
+import { FlwStatusSwitch, JwwStatusSwitch, getFlwStatus, getJwwStatus } from "../global"
+import { SheetIndexStatusSwitch, getStatus } from '../SheetIndex'
+
+let sdk2D
+let sdk3D
+let activeViewer
+let controlViewer
+let syncObject = {}
+let handlers = []
+async function init(sdk) {
+  sdk3D = sdk
+  activeViewer = 0
+  let tools = new Tools()
+  let sdk2 = await new YJ.YJEarth(sdk.div_id)
+  sdk2.viewer._element.className = 'cesium-viewer 2d'
+  SheetIndexStatusSwitch(sdk2, getStatus())
+  // 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
+  sdk2D = await sdk2
+  // window.sdk2D = sdk2D
+  solveBug()
+  syncObject = { sdks: [sdk, sdk2], tools }
+  await eventBind(sdk, 0, syncObject)
+  await eventBind(sdk2, 1, syncObject)
+  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);
+  let imageryLayers = [...sdk.viewer.imageryLayers._layers]
+  imageryLayers.sort((a, b) => a._layerIndex - b._layerIndex);
+  sdk2D.viewer.imageryLayers.removeAll()
+  for (let i = 0; i < imageryLayers.length; i++) {
+    let entity = sdk2D.viewer.imageryLayers.addImageryProvider(imageryLayers[i].imageryProvider, imageryLayers[i]._layerIndex)
+    entity.show = imageryLayers[i].show
+  }
+  // sdk.viewer.entities.collectionChanged.addEventListener(syncEntities)
+  // sdk.viewer.dataSources.dataSourceAdded.addEventListener(syncDataSources)
+
+  if (getFlwStatus(sdk)) {
+    FlwStatusSwitch(sdk2, true)
+  }
+  if (getJwwStatus(sdk)) {
+    JwwStatusSwitch(sdk2, true)
+  }
+
+}
+async function on(sdk) {
+  if (sdk2D) {
+
+  }
+  else {
+    init(sdk)
+    offSplitScreen()
+  }
+}
+
+function off(sdk) {
+  sdk.viewer.scene.preRender.removeEventListener(syncViewer, syncObject)
+  sdk.viewer.imageryLayers.layerAdded.removeEventListener(syncImageryLayerAdded);
+  sdk.viewer.imageryLayers.layerMoved.removeEventListener(syncImageryLayerMoved);
+  sdk.viewer.imageryLayers.layerRemoved.removeEventListener(syncImageryLayerRemoved);
+  sdk.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 (sdk2D) {
+    sdk2D.destroy()
+    handlers = []
+    sdk2D = null
+    sdk3D = null
+    activeViewer = null
+    syncObject = {}
+  }
+}
+
+async function syncData2(sdk, id, entityId) {
+  if (sdk && sdk.viewer && sdk.viewer._element && sdk.viewer._element.className === 'cesium-viewer 2d') {
+    return
+  }
+  if (!sdk3D || !sdk2D) {
+    return
+  }
+  let entityMap = sdk3D.entityMap
+  if (id) {
+    let that = entityMap.get(id)
+    if (that) {
+      let that2 = sdk2D.entityMap.get(id)
+      if (that2) {
+        await that2.remove()
+      }
+      let options = syncObject.tools.deepCopyObj(that.options)
+      if (that.type === 'BillboardObject') {
+        options.heightReference = 1
+      }
+      if (that.type === 'PolygonObject') {
+        options.heightMode = 0
+        options.height = 0
+      }
+      if (!that.type || (that.type !== 'tileset' && that.type !== 'bim' && that.type !== 'glb' && that.type !== 'layer')) {
+        let newObject = await new that.constructor(sdk2D, options)
+        newObject.onClick = that.onClick
+        newObject.onRightClick = that.onRightClick
+        newObject.onMouseMove = that.onMouseMove
+        if (that.type === 'TrajectoryMotion') {
+          that.firstPersonView = false
+          if (that.TweenAnimate) {
+            let state = that.state
+            if (state) {
+              that.state = false
+            }
+            if (!newObject.state) {
+              setTimeout(() => {
+                newObject.setMovePositionByDistance(Number(that.TweenAnimate._object.distance.toFixed(8)) + 0.00000001)
+                setTimeout(() => {
+                  newObject.setMovePositionByDistance(Number(that.TweenAnimate._object.distance.toFixed(8)) + 0.00000002)
+                }, 500);
+              }, 500);
+            }
+            else {
+              newObject.setMovePositionByDistance(Number(that.TweenAnimate._object.distance.toFixed(8)))
+            }
+            that.state = state
+          }
+          else {
+            setTimeout(() => {
+              newObject.setMovePositionByDistance(0.00000001)
+              setTimeout(() => {
+                newObject.setMovePositionByDistance(0.00000002)
+              }, 500)
+            }, 500)
+          }
+          if (that.viewFollow) {
+            newObject.viewFollow = true
+          }
+        }
+        if (that.type === 'AttackArrowObject' || that.type === 'StraightArrowObject') {
+          if (that.spreadState && that.TweenAnimate && that.TweenAnimate._object) {
+            newObject.setSpreadProgressByTime(that.TweenAnimate._object.distance / that.TweenAnimate._valuesEnd.distance * that.spreadTime)
+          }
+        }
+        if (that.type === 'PincerArrowObject') {
+          if (that.spreadState && that.TweenAnimate && that.TweenAnimate._object) {
+            newObject.setSpreadProgressByTime(that.TweenAnimate._object.distance1 / that.TweenAnimate._valuesEnd.distance1 * that.spreadTime)
+          }
+        }
+        if (newObject.on && newObject.type !== 'glb') {
+          if (newObject.type === 'vector') {
+            newObject.data = that.data
+            newObject.load(() => {
+              if (newObject.entity) {
+                for (let i = 0; i < newObject.entity.entities.values.length; i++) {
+                  newObject.entity.entities.values[i].show = that.entity.entities.values[i]._customShow === false ? false : true
+                }
+              }
+            })
+          }
+          await newObject.on()
+        }
+        // if (newObject.type && (newObject.type === 'tileset' || newObject.type === 'bim')) {
+        //   newObject.height = -10000
+        // }
+        // // Cesium1.98版本二维模式下初次显示有问题，1.110以上版本正常
+        // if (newObject.type && (newObject.type === 'glb')) {
+        //   newObject.options.position.alt = 0
+        // }
+      }
+    }
+    else {
+      let that2 = sdk2D.entityMap.get(id)
+      if (that2) {
+        await that2.remove()
+      }
+    }
+  }
+  else {
+    for (let [key, obj] of sdk2D.entityMap) {
+      let that = sdk2D.entityMap.get(key)
+      if (that) {
+        await that.remove()
+      }
+    }
+    for (let [key, obj] of entityMap) {
+      if (obj.type === 'BillboardObject') {
+        obj.options.heightReference = 1
+      }
+      let options = syncObject.tools.deepCopyObj(obj.options)
+      if (!obj.type || (obj.type !== 'tileset' && obj.type !== 'bim' && obj.type !== 'glb' && obj.type !== 'layer')) {
+        let target = await new obj.constructor(sdk2D, options)
+        target.onClick = obj.onClick
+        target.onRightClick = obj.onRightClick
+        target.onMouseMove = obj.onMouseMove
+        if (obj.type === 'TrajectoryMotion') {
+          obj.firstPersonView = false
+          if (obj.TweenAnimate) {
+            let state = obj.state
+            if (state) {
+              obj.state = false
+            }
+            if (!target.state) {
+              setTimeout(() => {
+                target.setMovePositionByDistance(Number(obj.TweenAnimate._object.distance.toFixed(8)) + 0.000000001)
+                setTimeout(() => {
+                  target.setMovePositionByDistance(Number(obj.TweenAnimate._object.distance.toFixed(8)) + 0.000000002)
+                }, 1500);
+              }, 1500);
+            }
+            else {
+              target.setMovePositionByDistance(Number(obj.TweenAnimate._object.distance.toFixed(8)))
+            }
+            obj.state = state
+          }
+          else {
+            setTimeout(() => {
+              target.setMovePositionByDistance(0.000000001)
+              setTimeout(() => {
+                target.setMovePositionByDistance(0.000000002)
+              }, 1500);
+            }, 1500);
+          }
+          if (obj.viewFollow) {
+            target.viewFollow = true
+          }
+          // else {
+          //   newObject.viewFollow = false
+          // }
+        }
+        if (obj.type === 'AttackArrowObject' || obj.type === 'StraightArrowObject') {
+          if (obj.spreadState && obj.TweenAnimate && obj.TweenAnimate._object) {
+            target.setSpreadProgressByTime(obj.TweenAnimate._object.distance / obj.TweenAnimate._valuesEnd.distance * obj.spreadTime)
+          }
+        }
+        if (obj.type === 'PincerArrowObject') {
+          if (obj.spreadState && obj.TweenAnimate && obj.TweenAnimate._object) {
+            target.setSpreadProgressByTime(obj.TweenAnimate._object.distance1 / obj.TweenAnimate._valuesEnd.distance1 * obj.spreadTime)
+          }
+        }
+        if (target.on && obj.type !== 'glb') {
+          if (target.type === 'vector') {
+            target.data = obj.data
+            target.load(() => {
+              if (target.entity) {
+                for (let i = 0; i < target.entity.entities.values.length; i++) {
+                  target.entity.entities.values[i].show = obj.entity.entities.values[i]._customShow === false ? false : true
+                }
+              }
+            })
+          }
+          await target.on()
+        }
+        // if (obj.type && (obj.type === 'tileset' || obj.type === 'bim')) {
+        //   target.height = -10000
+        // }
+        // if (obj.type && (obj.type === 'glb')) {
+        //   target.options.position.alt = 0
+        // }
+      }
+    }
+  }
+}
+
+async function syncData(sdk, id, entityId) {
+  syncData2(sdk, id, entityId)
+  // syncEntities()
+  // syncDataSources()
+}
+
+function syncEntities(entities1, entities2) {
+  if (!sdk3D) {
+    return
+  }
+  if (sdk2D) {
+    if (Array.isArray(entities1) || Array.isArray(entities2)) {
+      entities1 = null
+      entities2 = null
+    }
+    if (!entities1) {
+      entities1 = sdk2D.viewer.entities
+    }
+    if (!entities2) {
+      entities2 = sdk3D.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 (!sdk3D) {
+    return
+  }
+  if (sdk2D) {
+    let dataSources2D = sdk2D.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) {
+  sdk2D.viewer.imageryLayers.addImageryProvider(layer.imageryProvider, index)
+}
+function syncImageryLayerMoved(layer, newindxe, oldindex) {
+  let layer2d = sdk2D.viewer.imageryLayers._layers[oldindex]
+  if (!layer2d) {
+    return
+  }
+  // 移到最底层
+  if (newindxe === 0) {
+    sdk2D.viewer.imageryLayers.lowerToBottom(layer2d)
+  }
+  // 移到最高层
+  else if (newindxe === sdk3D.viewer.imageryLayers._layers.length - 1) {
+    sdk2D.viewer.imageryLayers.raiseToTop(layer2d)
+  }
+  else {
+    if (newindxe < oldindex) {
+      sdk2D.viewer.imageryLayers.lower(layer2d)
+    }
+    else {
+      sdk2D.viewer.imageryLayers.raise(layer2d)
+    }
+  }
+}
+function syncImageryLayerRemoved(layer, index) {
+  let layer2d = sdk2D.viewer.imageryLayers._layers[index]
+  if (!layer2d) {
+    return
+  }
+  sdk2D.viewer.imageryLayers.remove(layer2d)
+}
+function syncImageryLayerShownOrHidden(layer, index, state) {
+  let layer2d = sdk2D.viewer.imageryLayers._layers[index]
+  if (!layer2d) {
+    return
+  }
+  layer2d.show = state
+}
+
+async function syncPrimitives(primitive) {
+  if (!sdk3D) {
+    return
+  }
+  if (sdk2D) {
+    // await sdk2D.viewer.scene.primitives.remove(primitive)
+    // await sdk2D.viewer.scene.primitives.add(primitive)
+    let primitives2D = sdk2D.viewer.scene.primitives._primitives
+    let primitives3D = sdk3D.viewer.scene.primitives._primitives
+    // console.log(primitives2D, primitives3D)
+    // setTimeout(() => {
+    //   sdk2D.viewer.scene.primitives._primitives[1] = sdk3D.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) {
+        sdk2D.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) {
+        sdk2D.viewer.scene.primitives.add(primitives3D[m])
+      }
+    }
+  }
+}
+
+function eventBind(sdk, i, syncObject) {
+  let handler = new Cesium.ScreenSpaceEventHandler(
+    sdk.viewer.canvas
+  )
+  handler.setInputAction(() => {
+    activeViewer = i
+  }, Cesium.ScreenSpaceEventType.LEFT_DOWN)
+  handler.setInputAction(() => {
+    activeViewer = i
+  }, Cesium.ScreenSpaceEventType.RIGHT_DOWN)
+  handler.setInputAction(() => {
+    activeViewer = i
+  }, Cesium.ScreenSpaceEventType.WHEEL)
+  handlers.push(handler)
+}
+
+function syncViewer() {
+  let sdk = this.sdks[activeViewer]
+  let sdk2
+
+  if (activeViewer === 0) {
+    sdk2 = this.sdks[1]
+  }
+  else if (activeViewer === 1) {
+    sdk2 = this.sdks[0]
+  }
+  // this.sdks[0].viewer.trackedEntity = null
+  // this.sdks[1].viewer.trackedEntity = null
+  if (sdk.viewer.scene.mode === 2) {
+    if (this.sdks[0].viewer.trackedEntity) {
+      let distance = sdk.viewer.camera.positionCartographic.height
+      sdk2.viewer.camera.lookAt(
+        Cesium.Cartesian3.fromRadians(sdk.viewer.camera.positionCartographic.longitude, sdk.viewer.camera.positionCartographic.latitude, 0),
+        new Cesium.HeadingPitchRange(0, Cesium.Math.toRadians(-90), 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
+      }
+      let centerResult84 = this.tools.cartesian3Towgs84(Cesium.Cartesian3.fromRadians(sdk.viewer.camera.positionCartographic.longitude, sdk.viewer.camera.positionCartographic.latitude, sdk.viewer.camera.positionCartographic.height), sdk.viewer)
+      sdk2.viewer.camera.setView({
+        destination: Cesium.Cartesian3.fromDegrees(centerResult84.lng, centerResult84.lat, centerResult84.alt),
+      })
+    }
+  }
+  else {
+    // 视角中心点(伪)
+    let centerResult = sdk.viewer.camera.pickEllipsoid(
+      new Cesium.Cartesian2(
+        sdk.viewer.canvas.clientWidth / 2,
+        sdk.viewer.canvas.clientHeight / (2 - ((90 + sdk.viewer.camera.pitch / (Cesium.Math.PI / 180)) / 110)),
+      ),
+    )
+    if (!centerResult) {
+      centerResult = sdk.viewer.camera.positionWC
+    }
+
+    let height = this.tools.cartesian3Towgs84(sdk.viewer.camera.positionWC, sdk.viewer).alt
+    let centerResult84 = this.tools.cartesian3Towgs84(centerResult, sdk.viewer)
+
+    // console.log('--------------', sdk.viewer.camera.position, sdk.viewer.camera.positionWC, centerResult84, height)
+
+    sdk2.viewer.camera.setView({
+      destination: Cesium.Cartesian3.fromDegrees(centerResult84.lng, centerResult84.lat, height),
+      // orientation: {
+      //   heading: sdk2.viewer.camera.heading,
+      //   pitch: sdk2.viewer.camera.pitch,
+      //   roll: sdk2.viewer.camera.roll
+      // }
+    })
+  }
+
+
+}
+
+function get2DView() {
+  return sdk2D
+}
+
+function get3DView() {
+  return sdk3D
+}
+
+function solveBug() {
+  // 在能显示的地方加载一个多边形，解决二维模式下某些地方无法显示多边形的bug，原因不明
+  sdk2D && sdk2D.viewer.entities.add({
+    show: false,
+    polygon: {
+      hierarchy: new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromDegreesArray([100, 50, 100.0001, 50, 100.0001, 50.0001]))
+    }
+  })
+}
+
+function setActiveViewer(v) {
+  activeViewer = v
+}
+
+
+export { on, off, syncData, syncEntities, syncDataSources, syncPrimitives, get2DView, get3DView, setActiveViewer }

src/Global/ScreenRecord/index.js

@@ -0,0 +1,92 @@
+class ScreenRecord {
+  constructor() {
+    this.start()
+  }
+
+  start() {
+    navigator.mediaDevices.getDisplayMedia({
+      video: true
+      })
+      .then((stream) => {
+        // 需要更好的浏览器支持
+        // const mime = MediaRecorder.isTypeSupported('video/webm; codecs=vp9')
+        //   ? 'video/webm; codecs=vp9'
+        //   : 'video/webm'
+        this.mediaRecorder = new MediaRecorder(stream, {
+          // mimeType: mime,
+          mimeType: 'video/webm',
+        })
+
+        let chunks = []
+        this.mediaRecorder.addEventListener('dataavailable', function (e) {
+          chunks.push(e.data)
+        })
+
+        this.mediaRecorder.addEventListener('stop', async () => {
+          try {
+            let blob = new Blob(chunks, {
+              type: 'video/mp4',
+            })
+            const opts = {
+              suggestedName: '视频录制.mp4',
+              types: [
+                {
+                  description: '文件类型',
+                  accept: {
+                    'video/mp4': ['.mp4'],
+                  }
+                }
+              ],
+              excludeAcceptAllOption: true
+            };
+
+            const handle = await window.showSaveFilePicker(opts); // 打开保存文件对话框
+            const writable = await handle.createWritable(); // 创建可写入的文件对象
+            // 写入视频内容
+            writable.write(blob);
+            await writable.close();
+            YJ.Global.ScreenRecord.screenRecord = null
+          } catch (error) {
+            console.info('文件保存失败:', error);
+          }
+
+          // let blob = new Blob(chunks, {
+          //   type: chunks[0].type,
+          // })
+          // let url = URL.createObjectURL(blob)
+
+          // let a = document.createElement('a')
+          // a.href = url
+          // a.download = 'video.webm'
+          // a.click()
+          // this.recording = false
+          // YJ.Global.ScreenRecord.screenRecord = null
+        })
+
+        // 必须手动启动
+        this.mediaRecorder.start()
+      })
+      .catch((e) => {
+        console.info('取消录屏')
+        console.info(e)
+        YJ.Global.ScreenRecord.screenRecord = null
+      })
+  }
+}
+
+function startScreenRecord() {
+  if (YJ.Global.ScreenRecord.screenRecord) {
+    return '录屏任务进行中'
+  } else {
+    YJ.Global.ScreenRecord.screenRecord = new ScreenRecord()
+  }
+}
+
+function stopScreenRecord() {
+  if (YJ.Global.ScreenRecord && YJ.Global.ScreenRecord.screenRecord && YJ.Global.ScreenRecord.screenRecord) {
+    YJ.Global.ScreenRecord.screenRecord.mediaRecorder.stop()
+    YJ.Global.ScreenRecord.screenRecord = null
+  }
+}
+
+export { startScreenRecord, stopScreenRecord }

src/Global/ScreenShot/index.js

@@ -0,0 +1,707 @@
+import Tools from '../../Tools'
+import Dialog from '../../Obj/Element/Dialog';
+import { legp } from '../../Obj/Element/datalist';
+import MapPrint from '../MapPrint';
+import { off as offSplitScreen } from "../SplitScreen";
+import { off as offMultiViewportMode } from "../MultiViewportMode";
+
+// 生成快照
+const convertToImage = (container, options = {}) => {
+  // 设置放大倍数
+  const scale = window.devicePixelRatio;
+
+  // 传入节点原始宽高
+  const width = container.offsetWidth;
+  const height = container.offsetHeight;
+
+  // html2canvas配置项
+  const ops = {
+    scale,//比例，越大分辨率越高，图片越小
+    width,
+    height,
+    async: false,
+    x: 0,
+    y: 0,
+    backgroundColor: 'rgb(20,47,65)',
+    imageTimeout: 0,
+    useCORS: true,//允许跨域
+    allowTaint: false, //允许跨域数据污染'被污染'的canvas
+    tainttest: true,
+    foreignObjectRendering: true,   //在浏览器支持的情况下使用ForeignObject模式渲染图片                 
+    ...options
+  };
+
+  return html2canvas(container, ops).then(canvas => {
+    // 返回图片的二进制数据
+    return canvas.toDataURL("image/png");
+  });
+}
+
+async function ScreenShot(sdk, cd = () => { }) {
+  // const imgBlobData = await convertToImage(sdk.viewer.canvas);
+  const imgBlobData = sdk.viewer.canvas.toDataURL()
+  cd && cd(imgBlobData)
+  // try {
+  //   const imgBlobData = await convertToImage(sdk.viewer.canvas);
+  //   let arr = imgBlobData.split(','), mime = arr[0].match(/:(.*?);/)[1],
+  //     bstr = atob(arr[1]), i = bstr.length, u8arr = new Uint8Array(i);
+  //   while (i--) {
+  //     u8arr[i] = bstr.charCodeAt(i);
+  //   }
+
+  //   let blob = new Blob([u8arr], { type: mime });
+  //   const opts = {
+  //     suggestedName: '截图.png',
+  //     types: [
+  //       {
+  //         description: '文件类型',
+  //         accept: {
+  //           'image/png': ['.png'],
+  //           'image/jpg': ['.jpg']
+  //         }
+  //       }
+  //     ],
+  //     excludeAcceptAllOption: true
+  //   };
+
+  //   const handle = await window.showSaveFilePicker(opts); // 打开保存文件对话框
+  //   const writable = await handle.createWritable(); // 创建可写入的文件对象
+  //   // 写入视频内容
+  //   writable.write(blob);
+  //   await writable.close();
+  //   YJ.Global.ScreenRecord.screenRecord = null
+  // } catch (error) {
+  //   console.info('文件保存失败:', error);
+  // }
+}
+
+let _DialogObject
+
+async function ScreenShotHD(sdk, options = {}, cd = () => { }) {
+  if (!sdk) {
+    return
+  }
+  offSplitScreen(sdk)
+  offMultiViewportMode(sdk)
+  if (_DialogObject) {
+    _DialogObject.close()
+    _DialogObject = null
+  }
+
+  let enableTranslate = sdk.viewer.scene.screenSpaceCameraController.enableTranslate
+  let enableTilt = sdk.viewer.scene.screenSpaceCameraController.enableTilt
+  let enableLook = sdk.viewer.scene.screenSpaceCameraController.enableLook
+
+  let scale = 1
+  let level
+
+  let progressInputElm
+  let progressBarElm
+  let rangeNodeActive
+  let rangeNodeActiveText
+  let startScreenShotObject
+  let tools = new Tools();
+  _DialogObject = await new Dialog(sdk, {}, {
+    title: '高清出图', left: '180px', top: '100px',
+    confirmCallBack: (options) => {
+      if (startScreenShotObject) {
+        startScreenShotObject.desist()
+        startScreenShotObject = null
+      }
+      progressInputElm && (progressInputElm.style.width = '0%')
+      rangeNodeActive && (rangeNodeActive.style.left = '0%')
+      progressBarElm && (progressBarElm.style.width = '0%')
+      rangeNodeActiveText && (rangeNodeActiveText.innerHTML = '0%')
+      startScreenShotObject = new startScreenShot()
+    },
+    closeCallBack: () => {
+      sdk.viewer.scene.screenSpaceCameraController.enableTranslate = enableTranslate;
+      sdk.viewer.scene.screenSpaceCameraController.enableTilt = enableTilt;
+      sdk.viewer.scene.screenSpaceCameraController.enableLook = enableLook;
+      sdk.viewer._element.getElementsByClassName('compass')[0].style.pointerEvents = 'auto'
+      if (startScreenShotObject) {
+        startScreenShotObject.desist()
+        startScreenShotObject = null
+      }
+      _DialogObject = undefined
+    }
+  })
+  _DialogObject._element.body.className = _DialogObject._element.body.className + ' screenShotHD'
+  let contentElm = document.createElement('div');
+  contentElm.innerHTML = `
+  <span class="custom-divider"></span>
+  <div class="div-item">
+        <div class="row text" style="align-items: flex-start;">
+            <div class="col">
+                <span>当前窗口长宽：<span class="input-width">${sdk.viewer.canvas.width}</span>*<span class="input-height">${sdk.viewer.canvas.height}</span>像素</span>
+            </div>
+        </div>
+        <div class="row scale-box" style="align-items: flex-start;">
+            <div class="col">
+                <span class="label">图片大小</span>
+                <div class="input input-select scale"></div>
+                <span>倍窗口</span>
+            </div>
+        </div>
+        <div class="row text" style="align-items: flex-start;">
+            <div class="col">
+                <span>输出图片长宽：<span class="output-width">${sdk.viewer.canvas.width * scale}</span>*<span class="output-height">${sdk.viewer.canvas.height * scale}</span>像素</span>
+            </div>
+        </div>
+        <div class="row" style="align-items: flex-start; margin-bottom: 20px;">
+            <div class="col">
+                <span class="label">输出进度</span>
+                <div class="range-box">
+                    <div class="range-bg">
+                        <div class="range-process-box">
+                            <div class="range-process"></div>
+                        </div>
+                    </div>
+                    <div class="range-node-box">
+                        <span class="range-node-text">0%</span>
+                        <span class="range-node-text">100%</span>
+                        <div class="range-node-active"><span class="range-node-active-text">0%</span></div>
+                    </div>
+                    <input class="progress-input" type="range" max="100" min="0" step="0.01">
+                </div>
+            </div>
+        </div>
+    </div>
+    <span class="custom-divider"></span>
+  `
+  _DialogObject.contentAppChild(contentElm)
+
+  sdk.viewer.scene.screenSpaceCameraController.enableTranslate = false;
+  sdk.viewer.scene.screenSpaceCameraController.enableTilt = false;
+  sdk.viewer.scene.screenSpaceCameraController.enableLook = false;
+  sdk.viewer._element.getElementsByClassName('compass')[0].style.pointerEvents = 'none'
+
+
+  let centerResult = sdk.viewer.camera.pickEllipsoid(
+    new Cesium.Cartesian2(
+      sdk.viewer.canvas.clientWidth / 2,
+      sdk.viewer.canvas.clientHeight / 2,
+    ),
+  )
+  if (!centerResult) {
+    centerResult = sdk.viewer.camera.pickEllipsoid(
+      new Cesium.Cartesian2(
+        sdk.viewer.canvas.clientWidth / 2,
+        sdk.viewer.canvas.clientHeight / (2 - ((90 + sdk.viewer.camera.pitch / (Cesium.Math.PI / 180)) / 110)),
+      ),
+    )
+    if (!centerResult) {
+      centerResult = sdk.viewer.camera.position
+    }
+  }
+  let height = tools.cartesian3Towgs84(sdk.viewer.camera.position, sdk.viewer).alt
+  let centerResult84 = tools.cartesian3Towgs84(centerResult, sdk.viewer)
+  sdk.viewer.camera.flyTo({
+    destination: Cesium.Cartesian3.fromDegrees(centerResult84.lng, centerResult84.lat, height),
+    orientation: { heading: 0, pitch: Cesium.Math.toRadians(-90), roll: 0 },
+    duration: 1,
+  })
+
+
+  let scaleData = []
+  for (let i = 1; i <= 10; i++) {
+    scaleData.push({
+      name: i,
+      value: i
+    })
+  }
+  progressInputElm = document.getElementsByClassName('progress-input')[0]
+  progressBarElm = document.getElementsByClassName('range-process')[0]
+  rangeNodeActive = contentElm.getElementsByClassName('range-node-active')[0]
+  rangeNodeActiveText = contentElm.getElementsByClassName('range-node-active-text')[0]
+  let scaleDataLegpObject = legp(_DialogObject._element.content.getElementsByClassName('scale-box')[0], ".scale")
+  if (scaleDataLegpObject) {
+    scaleDataLegpObject.legp_search(scaleData)
+    let scaleDataLegpElm = _DialogObject._element.content.getElementsByClassName('scale')[0].getElementsByTagName('input')[0]
+    scale = scaleData[0].value
+    scaleDataLegpObject.legp_searchActive(scaleData[0].value)
+    scaleDataLegpElm.value = scaleData[0].value
+    scaleDataLegpElm.addEventListener('input', () => {
+      for (let i = 0; i < scaleData.length; i++) {
+        if (scaleData[i].value == scaleDataLegpElm.value) {
+          scale = scaleData[i].value
+          _DialogObject._element.content.getElementsByClassName('output-width')[0].innerHTML = sdk.viewer.canvas.width * scale
+          _DialogObject._element.content.getElementsByClassName('output-height')[0].innerHTML = sdk.viewer.canvas.height * scale
+          break
+        }
+      }
+    })
+  }
+
+  class startScreenShot {
+    constructor() {
+      this.state = false
+      this.start()
+    }
+    start() {
+      if (sdk.viewer.scene.imageryLayers._layers.length <= 1) {
+        this.error = '未加载底图！'
+        window.ELEMENT && window.ELEMENT.Message({
+          message: this.error,
+          type: 'warning',
+          duration: 1500
+        });
+        console.warn(this.error)
+        return
+      }
+      let haveBaseMap = false
+      for (let i = 0; i < sdk.viewer.scene.imageryLayers._layers.length; i++) {
+        let layer = sdk.viewer.scene.imageryLayers._layers[i];
+        if (layer && layer.show && (!layer.notes || layer.notes !== 'default-base-map')) {
+          haveBaseMap = true
+        }
+      }
+      if (!haveBaseMap) {
+        this.error = '未加载底图！'
+        window.ELEMENT && window.ELEMENT.Message({
+          message: this.error,
+          type: 'warning',
+          duration: 1500
+        });
+        console.warn(this.error)
+        return
+      }
+      let scaleZoom = 0;
+      this.state = true;
+      let _this = this
+      computeLayers(1);
+
+      function computeLayers(s) {
+        let num = s * 2;
+        if (num <= scale) {
+          scaleZoom++;
+          computeLayers(num);
+        }
+      }
+      scaleZoom = scaleZoom + 1;
+      let centerResult = sdk.viewer.camera.pickEllipsoid(
+        new Cesium.Cartesian2(
+          sdk.viewer.canvas.width / 2,
+          sdk.viewer.canvas.height / (2 - ((90 + sdk.viewer.camera.pitch / (Cesium.Math.PI / 180)) / 110))
+        )
+      );
+      if (!centerResult) {
+        centerResult = sdk.viewer.camera.position;
+      }
+      function altitudeToZoom(altitude) {
+        let A = 40487.57;
+        let B = 0.00007096758;
+        let C = 91610.74;
+        let D = -40467.74;
+        return Math.round(D + (A - D) / (1 + Math.pow(altitude / C, B)));
+      }
+      let height = tools.cartesian3Towgs84(sdk.viewer.camera.position, sdk.viewer).alt;
+      let zoom = altitudeToZoom(height) + 1;
+
+      let rectangle = sdk.viewer.camera.computeViewRectangle();
+      // if (height > 9000000) {
+      //   height = 9000000
+      // }
+      // let curRectangle = new Cesium.Rectangle(Cesium.Math.toRadians(centerResult84.lng - (height / stepX)), Cesium.Math.toRadians(centerResult84.lat - (height / stepY)), Cesium.Math.toRadians(centerResult84.lng + (height / stepX)), Cesium.Math.toRadians(centerResult84.lat + (height / stepY)))
+      // for (let i = 1; i < sdk.viewer.scene.imageryLayers._layers.length; i++) {
+      //   let layer = sdk.viewer.scene.imageryLayers._layers[i]
+      //   createCanvas(layer)
+      // }
+      let total;
+      let totalCount = 0;
+      let progress = {};
+      let index = 0;
+      let layerLength = 0
+      let countIndex = 0
+      for (let i = 0; i < sdk.viewer.scene.imageryLayers._layers.length; i++) {
+        let layer = sdk.viewer.scene.imageryLayers._layers[i];
+        if (layer && layer.show && layer.imageryProvider && layer.imageryProvider.url && Cesium.Rectangle.intersection(rectangle, layer.imageryProvider.rectangle) && (!layer.notes || layer.notes !== 'default-base-map')) {
+          layerLength++
+        }
+      }
+      let itemTotalProgress = 100 / layerLength
+      let flag = false
+      createCanvas(index);
+      function createCanvas(i, totalCanvas) {
+        let layer = sdk.viewer.scene.imageryLayers._layers[i];
+        if (!layer) {
+          if (!flag) {
+            _this.error = '当前范围内未找到底图数据！'
+            window.ELEMENT && window.ELEMENT.Message({
+              message: _this.error,
+              type: 'warning',
+              duration: 1500
+            });
+            console.warn(_this.error)
+          }
+          return
+        }
+        if (!layer.show || !layer.imageryProvider || !layer.imageryProvider.url || !Cesium.Rectangle.intersection(rectangle, layer.imageryProvider.rectangle) || (layer.notes && layer.notes === 'default-base-map')) {
+          let m = i += 1;
+          createCanvas(m, totalCanvas);
+          return;
+        }
+        flag = true
+        countIndex++
+        progress[i] = {
+          value: 0
+        }
+        let itemTotalCount = 0;
+        let targetLevel
+        let imageryProvider = layer.imageryProvider;
+        if (level || level === 0) {
+          targetLevel = level
+        }
+        else {
+          targetLevel = (zoom + scaleZoom - 1)
+          if (targetLevel > imageryProvider.maximumLevel) {
+            targetLevel = imageryProvider.maximumLevel
+          }
+          if (targetLevel < imageryProvider.minimumLevel) {
+            targetLevel = imageryProvider.minimumLevel
+          }
+        }
+        function readyPromise() {
+          let MinTile = imageryProvider.tilingScheme.positionToTileXY(
+            Cesium.Rectangle.northwest(rectangle),
+            targetLevel
+          );
+          let MaxTile = imageryProvider.tilingScheme.positionToTileXY(
+            Cesium.Rectangle.southeast(rectangle),
+            targetLevel
+          );
+          if (!MinTile || !MaxTile) {
+            let error = '超出地球范围！'
+            window.ELEMENT && window.ELEMENT.Message({
+              message: error,
+              type: 'warning',
+              duration: 1500
+            });
+            console.warn(error)
+            return
+          }
+          let OfXTilesAtLevel = imageryProvider.tilingScheme.getNumberOfXTilesAtLevel(targetLevel)
+          let OfYTilesAtLevel = imageryProvider.tilingScheme.getNumberOfYTilesAtLevel(targetLevel)
+          let MinTileX = MinTile.x;
+          let MinTileY = MinTile.y;
+          let MaxTileX = MaxTile.x;
+          let MaxTileY = MaxTile.y;
+
+          // if (MinTileX > MaxTileX) {
+          //   MinTileX = MinTileX - OfXTilesAtLevel
+          // }
+
+          let imgWidth = 256;
+          let imgHeight = 256;
+
+          let itemTotal = (MaxTileX - MinTileX + 1) * (MaxTileY - MinTileY + 1);
+          // var canvas = new fabric.Canvas();
+          let canvas = document.createElement('canvas');
+          canvas.width = (MaxTileX - MinTileX + 1) * imgWidth;
+          canvas.height = (MaxTileY - MinTileY + 1) * imgHeight;
+          let ctx = canvas.getContext('2d');
+          let maxRectangle = imageryProvider.tilingScheme.tileXYToRectangle(MaxTileX, MaxTileY, targetLevel);
+          let minRectangle = imageryProvider.tilingScheme.tileXYToRectangle(MinTileX, MinTileY, targetLevel);
+          let canvasNativeRectangle = new Cesium.Rectangle(minRectangle.west, maxRectangle.south, maxRectangle.east, minRectangle.north);
+          // sdk.viewer.entities.add({
+          //   rectangle: {
+          //     coordinates: canvasNativeRectangle,
+          //     material: Cesium.Color.YELLOW.withAlpha(0.2),
+          //   },
+          // });
+          // sdk.viewer.entities.add({
+          //   rectangle: {
+          //     coordinates: rectangle,
+          //     material: Cesium.Color.BLACK.withAlpha(0.2),
+          //   },
+          // });
+          let nativeRectangle = rectangle;
+          let x1 = nativeRectangle.west - canvasNativeRectangle.west;
+          let x2 = canvasNativeRectangle.east - nativeRectangle.east;
+          let y1 = canvasNativeRectangle.north - nativeRectangle.north;
+          let y2 = nativeRectangle.south - canvasNativeRectangle.south;
+
+          let ratioX1 = x1 / (canvasNativeRectangle.east - canvasNativeRectangle.west);
+          if (ratioX1 === Infinity) {
+            ratioX1 = 0;
+          }
+          let ratioX2 = x2 / (canvasNativeRectangle.east - canvasNativeRectangle.west);
+          if (ratioX2 === Infinity) {
+            ratioX2 = 0;
+          }
+          let ratioY1 = y1 / (canvasNativeRectangle.north - canvasNativeRectangle.south);
+          if (ratioY1 === Infinity) {
+            ratioY1 = 0;
+          }
+          let ratioY2 = y2 / (canvasNativeRectangle.north - canvasNativeRectangle.south);
+          if (ratioY2 === Infinity) {
+            ratioY2 = 0;
+          }
+          let differenceX1 = canvas.width * ratioX1;
+          let differenceY1 = canvas.height * ratioY1;
+          let differenceX2 = canvas.width * ratioX2;
+          let differenceY2 = canvas.height * ratioY2;
+          canvas.width = canvas.width - differenceX1 - differenceX2;
+          canvas.height = canvas.height - differenceY1 - differenceY2;
+          if (canvas.width == 0) {
+            canvas.width = 1
+          }
+          if (canvas.height == 0) {
+            canvas.height = 1
+          }
+
+          let y = MaxTileY;
+          let x = MaxTileX;
+
+          let tileArray = []
+          for (let y = MaxTileY; y >= MinTileY; y--) {
+            for (let x = MaxTileX; x >= MinTileX; x--) {
+              tileArray.push({ x, y })
+            }
+          }
+
+          let speed = 30
+
+          let obj = {
+            count: 0
+          };
+          let count = 0;
+
+          let times = -1
+          let obj2 = {
+            count: 0
+          }
+          let count2 = 0
+          Object.defineProperty(obj2, 'count', {
+            get: function () {
+              return count2;
+            },
+            set: function (newValue) {
+              count2 = newValue;
+              if (count2 >= speed) {
+                traversal10()
+              }
+            }
+          });
+          Object.defineProperty(obj, 'count', {
+            get: function () {
+              return count;
+            },
+            set: function (newValue) {
+              count = newValue;
+              progress[i].value = itemTotalCount / itemTotal * itemTotalProgress;
+              let totalProgress = 0
+              for (const key in progress) {
+                totalProgress = totalProgress + progress[key].value
+              }
+              progressBarElm.style.width = totalProgress * 0.99 + '%';
+              rangeNodeActive.style.left = totalProgress * 0.99 + '%';
+              rangeNodeActiveText.innerHTML = Math.floor(totalProgress * 0.99 * 100) / 100 + '%';
+              if (count === (MaxTileX - MinTileX + 1) * (MaxTileY - MinTileY + 1)) {
+                let ctx = canvas.getContext('2d');
+                let cloneCanvas = canvas.cloneNode(true);
+                let cloneCtx = cloneCanvas.getContext('2d');
+                let imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+                cloneCtx.putImageData(imageData, 0, 0);
+                canvas.width = sdk.viewer.canvas.width * scale;
+                canvas.height = sdk.viewer.canvas.height * scale;
+                ctx.drawImage(cloneCanvas, 0, 0, canvas.width, canvas.height);
+                if (totalCanvas) {
+                  let ctx = totalCanvas.getContext('2d');
+                  ctx.drawImage(canvas, 0, 0);
+                  if (countIndex != layerLength) {
+                    let m = i += 1;
+                    createCanvas(m, totalCanvas);
+                    return;
+                  }
+                  else {
+                    let imgBlobData = totalCanvas.toDataURL('image/jpeg', 0.95);
+                    const tempCanvas = document.createElement('canvas');
+                    const tempCtx = tempCanvas.getContext('2d');
+                    tempCanvas.width = totalCanvas.width / scale
+                    tempCanvas.height = totalCanvas.height / scale
+                    tempCtx.drawImage(totalCanvas, 0, 0, tempCanvas.width, tempCanvas.height);
+                    MapPrint(sdk, tempCanvas.toDataURL('image/jpeg', 0.95), rectangle, imgBlobData)
+                    progressBarElm.style.width = '100%';
+                    rangeNodeActive.style.left = '100%';
+                    rangeNodeActiveText.innerHTML = '100%';
+                    _this.state = false
+                  }
+                }
+                else {
+
+                  if (countIndex != layerLength) {
+                    let m = i += 1;
+                    createCanvas(m, canvas);
+                    return;
+                  }
+                  else {
+                    let imgBlobData = canvas.toDataURL('image/jpeg', 0.95);
+                    const tempCanvas = document.createElement('canvas');
+                    const tempCtx = tempCanvas.getContext('2d');
+                    tempCanvas.width = canvas.width / scale;
+                    tempCanvas.height = canvas.height / scale;
+                    tempCtx.drawImage(canvas, 0, 0, tempCanvas.width, tempCanvas.height);
+                    // canvas.width = canvas.width / scale
+                    // canvas.height = canvas.height / scale
+                    MapPrint(sdk, tempCanvas.toDataURL('image/jpeg', 0.95), rectangle, imgBlobData)
+                    progressBarElm.style.width = '100%';
+                    rangeNodeActive.style.left = '100%';
+                    rangeNodeActiveText.innerHTML = '100%';
+                    _this.state = false
+                  }
+                }
+              }
+            }
+          });
+          if (imageryProvider._readyError) {
+            obj.count = (MaxTileX - MinTileX + 1) * (MaxTileY - MinTileY + 1)
+          }
+          else {
+            traversal10()
+          }
+
+          function traversal10() {
+            obj2.count = 0
+            count2 = 0
+            times++
+            for (let i = times * speed; i < (times + 1) * speed; i++) {
+              if (i >= tileArray.length) {
+                return
+              }
+              traversal(i)
+            }
+          }
+
+          function traversal(i) {
+            if (!_this.state) {
+              return
+            }
+            try {
+              let x = tileArray[i].x
+              if (x < 0) {
+                x = x + OfXTilesAtLevel
+              }
+              const img = new Image();
+              img.setAttribute('crossOrigin', 'anonymous');
+              img.onload = async function () {
+                ctx.drawImage(img, ((tileArray[i].x - MinTileX) * imgWidth) - parseFloat(differenceX1.toFixed(0)), ((tileArray[i].y - MinTileY) * imgHeight) - parseFloat(differenceY1.toFixed(0)), imgWidth, imgHeight);
+                itemTotalCount++;
+                obj.count++;
+                obj2.count++;
+              };
+              img.onerror = function () {
+                itemTotalCount++;
+                obj.count++;
+                obj2.count++;
+              };
+
+              let url;
+              if (imageryProvider.url.indexOf('{x}') !== -1 && imageryProvider.url.indexOf('{y}') !== -1 && imageryProvider.url.indexOf('{z}') !== -1) {
+                url = imageryProvider.url.replace(/\{x\}/g, x).replace(/\{y\}/g, tileArray[i].y).replace(/\{z\}/g, targetLevel);
+              }
+              else if (imageryProvider.url.indexOf('{TileMatrix}') !== -1 && imageryProvider.url.indexOf('{TileRow}') !== -1 && imageryProvider.url.indexOf('{TileCol}') !== -1) {
+                url = imageryProvider.url.replace(/\{TileCol\}/g, x).replace(/\{TileRow\}/g, tileArray[i].y).replace(/\{TileMatrix\}/g, targetLevel);
+              }
+              else if (imageryProvider._layer && imageryProvider._style && imageryProvider._tileMatrixSetID && imageryProvider._format) {
+                url = imageryProvider.url + `&tilematrix=${targetLevel}&layer=${imageryProvider._layer}&style=${imageryProvider._style}&tilerow=${y}&tilecol=${x}&tilematrixset=${imageryProvider._tileMatrixSetID}&format=${imageryProvider._format}`;
+              }
+              else {
+                url = imageryProvider.url + `tile/${targetLevel}/${tileArray[i].y}/${x}`;
+              }
+              img.src = url;
+            } catch (error) {
+              itemTotalCount++;
+              obj.count++;
+              obj2.count++;
+            }
+          }
+
+          function traversal2() {
+            if (!_this.state) {
+              return
+            }
+            try {
+              const img = new Image();
+              img.setAttribute('crossOrigin', 'anonymous');
+              img.onload = async function () {
+                ctx.drawImage(img, ((x - MinTileX) * imgWidth) - parseFloat(differenceX1.toFixed(0)), ((y - MinTileY) * imgHeight) - parseFloat(differenceY1.toFixed(0)), imgWidth, imgHeight);
+                itemTotalCount++;
+                obj.count++;
+
+                if (x > MinTileX) {
+                  x--
+                }
+                else {
+                  if (y > MinTileY) {
+                    y--
+                    x = MaxTileX
+                  }
+                  else {
+                    return
+                  }
+                }
+                traversal()
+              };
+
+              let url;
+              if (imageryProvider.url.indexOf('{x}') !== -1 && imageryProvider.url.indexOf('{y}') !== -1 && imageryProvider.url.indexOf('{z}') !== -1) {
+                url = imageryProvider.url.replace(/\{x\}/g, x).replace(/\{y\}/g, y).replace(/\{z\}/g, targetLevel);
+              }
+              else if (imageryProvider.url.indexOf('{TileMatrix}') !== -1 && imageryProvider.url.indexOf('{TileRow}') !== -1 && imageryProvider.url.indexOf('{TileCol}') !== -1) {
+                url = imageryProvider.url.replace(/\{TileCol\}/g, x).replace(/\{TileRow\}/g, y).replace(/\{TileMatrix\}/g, targetLevel);
+              }
+              else if (imageryProvider._layer && imageryProvider._style && imageryProvider._tileMatrixSetID && imageryProvider._format) {
+                url = imageryProvider.url + `&tilematrix=${targetLevel}&layer=${imageryProvider._layer}&style=${imageryProvider._style}&tilerow=${y}&tilecol=${x}&tilematrixset=${imageryProvider._tileMatrixSetID}&format=${imageryProvider._format}`;
+              }
+              else {
+                url = imageryProvider.url + `tile/${targetLevel}/${y}/${x}`;
+              }
+              img.src = url;
+            } catch (error) {
+              itemTotalCount++;
+              obj.count++;
+              if (x >= MinTileX) {
+                x--
+              }
+              else {
+                if (y >= MinTileY) {
+                  y--
+                  x = MaxTileX
+                }
+                else {
+                  return
+                }
+              }
+              traversal()
+            }
+          }
+
+
+        }
+        if (imageryProvider._readyError) {
+          progress[i] = {
+            value: itemTotalProgress
+          }
+          readyPromise()
+          return
+        }
+        imageryProvider.readyPromise.then(() => {
+          readyPromise()
+        }).catch((e) => {
+          imageryProvider._readyError = true
+          progress[i] = {
+            value: itemTotalProgress
+          }
+          readyPromise()
+        });
+      }
+    }
+    desist() {
+      this.state = false
+    }
+  }
+
+}
+
+export { ScreenShot, ScreenShotHD }

src/Global/SheetIndex/index.js

@@ -0,0 +1,655 @@
+
+import { get2DView } from '../MultiViewportMode'
+import { getSdk } from '../SplitScreen'
+import { flyTo } from '../global'
+import Tools from '../../Tools'
+
+let tools
+let state = false
+let scale = '1:100万'
+
+function SheetIndexStatusSwitch(sdk, s = false) {
+  if(!sdk) {
+    return
+  }
+  if (!tools) {
+    tools = new Tools()
+  }
+  state = s ? true : false
+
+  if (state) {
+    changeScale(sdk, scale)
+  } else {
+    close(sdk)
+  }
+  let sdk2D = get2DView()
+  if (sdk2D) {
+    if (state) {
+      changeScale(sdk, scale)
+    } else {
+      close(sdk2D)
+    }
+  }
+
+  let sdkD = getSdk().sdkD
+  if(sdkD && sdk !== sdkD) {
+    SheetIndexStatusSwitch(sdkD, s)
+  }
+
+  // return new Promise(async (resolve, reject) => {
+  //   setTimeout(() => {
+  //     resolve()
+  //   }, 1000);
+  // })
+
+}
+
+function changeScale(sdk, v) {
+  scale = v
+  if (state) {
+    open(sdk)
+  }
+  let sdk2D = get2DView()
+  if (sdk2D) {
+    if (state) {
+      open(sdk2D)
+    }
+  }
+  return new Promise(async (resolve, reject) => {
+    setTimeout(() => {
+      resolve()
+    }, 1000);
+  })
+}
+
+function getStatus() {
+  return state
+}
+
+function open(sdk) {
+  close(sdk)
+  let cartographic = sdk.viewer.camera.positionCartographic
+  let options = {
+    position: {
+      lng: Cesium.Math.toDegrees(cartographic.longitude),
+      lat: Cesium.Math.toDegrees(cartographic.latitude),
+      alt: cartographic.height,
+    },
+  }
+  let viewer = sdk.viewer;
+  switch (scale) {
+    case '1:100万':
+      options.position.alt = 16000000
+      break
+    case '1:50万':
+      options.position.alt = 5000000
+      break
+    case '1:25万':
+      options.position.alt = 2300000
+      break
+    case '1:10万':
+      options.position.alt = 680000
+      break
+    case '1:5万':
+      options.position.alt = 385000
+      break
+    case '1:2.5万':
+      options.position.alt = 180000
+      break
+    case '1:1万':
+      options.position.alt = 90000
+      break
+    case '1:5000':
+      options.position.alt = 46000
+      break
+  }
+
+  let gridPrimitives
+  let labelCollection
+  for (let i = 0; i < viewer.scene.primitives._primitives.length; i++) {
+    if (viewer.scene.primitives._primitives[i].name === 'SheetIndexGridPrimitives') {
+      gridPrimitives = viewer.scene.primitives._primitives[i];
+      for (let j = 0; j < gridPrimitives._primitives.length; j++) {
+        if (gridPrimitives._primitives[j].name === 'SheetIndexLabelCollection') {
+          labelCollection = gridPrimitives._primitives[j];
+          break;
+        }
+      }
+      break;
+    }
+  }
+
+  if (!gridPrimitives) {
+    gridPrimitives = new Cesium.PrimitiveCollection();
+    gridPrimitives.name = 'SheetIndexGridPrimitives';
+    viewer.scene.primitives.add(gridPrimitives);
+  }
+  if (!labelCollection) {
+    labelCollection = new Cesium.LabelCollection();
+    labelCollection.name = 'SheetIndexLabelCollection';
+  }
+
+  let stationaryFrames = 0;
+  let maxRectangle = null;
+  gridPrimitives.postRenderEvent = () => {
+    let height = sdk.viewer.camera.positionCartographic.height
+    switch (scale) {
+      case '1:100万':
+        options.position.alt = 16000000
+        break
+      case '1:50万':
+        options.position.alt = 5000000
+        break
+      case '1:25万':
+        options.position.alt = 2300000
+        break
+      case '1:10万':
+        options.position.alt = 680000
+        break
+      case '1:5万':
+        options.position.alt = 385000
+        break
+      case '1:2.5万':
+        options.position.alt = 180000
+        break
+      case '1:1万':
+        options.position.alt = 90000
+        break
+      case '1:5000':
+        options.position.alt = 46000
+        break
+    }
+    if (height > options.position.alt * 5) {
+      maxRectangle = null;
+      gridPrimitives.removeAll();
+      return
+    }
+    let isChanged = false
+    let rectangle = getViewExtend();
+
+    let minLng = Cesium.Math.toDegrees(rectangle.west)
+    let minLat = Cesium.Math.toDegrees(rectangle.south)
+    let maxLng = Cesium.Math.toDegrees(rectangle.east)
+    let maxLat = Cesium.Math.toDegrees(rectangle.north)
+    if (minLng > maxLng) {
+      maxLng += 360
+    }
+    rectangle = { minLng, minLat, maxLng, maxLat }
+    if (maxRectangle) {
+      if ((maxRectangle.minLng > rectangle.minLng || maxRectangle.minLat > rectangle.minLat || maxRectangle.maxLng < rectangle.maxLng || maxRectangle.maxLat < rectangle.maxLat) && Cesium.Math.toDegrees(sdk.viewer.camera.pitch) < 0) {
+        isChanged = true
+      }
+    }
+    else {
+      countMapSheet(scale)
+    }
+
+    if (isChanged) {
+      stationaryFrames++;
+      // 确认相机已经静止足够多帧
+      if (stationaryFrames >= 50) {
+        countMapSheet(scale)
+        isChanged = false
+      }
+    } else {
+      stationaryFrames = 0;
+    }
+  }
+
+  options.complete = () => {
+    viewer.scene.postRender.addEventListener(gridPrimitives.postRenderEvent);
+  }
+  flyTo(sdk, options, 0.5)
+
+  /**
+  * 根据比例尺创建图幅线
+  * @param {string} scale - 比例尺（可选值：'1:100万', '1:50万', '1:25万', '1:10万', '1:5万', '1:2.5万', '1:1万', '1:5000'）
+  */
+  function countMapSheet(scale) {
+    labelCollection.removeAll();
+    gridPrimitives.removeAll();
+    labelCollection = new Cesium.LabelCollection();
+    labelCollection.name = 'SheetIndexLabelCollection';
+    gridPrimitives.add(labelCollection);
+    let rectangle = getViewExtend();
+
+    let lngStep // 经度步长
+    let latStep // 纬度步长
+    // let limitLng // 显示界限（根据图幅线数量显隐）
+    // let limitLat
+    // Math.abs(maxLng-minLng)/lngStep, Math.abs(maxLat-minLat)/latStep
+    let scaleByDistance
+    switch (scale) {
+      case '1:100万':
+        lngStep = 6;
+        latStep = 4;
+        scaleByDistance = new Cesium.NearFarScalar(
+          20000000,
+          1,
+          80000000,
+          0
+        )
+        break
+      case '1:50万':
+        lngStep = 3;
+        latStep = 2;
+        scaleByDistance = new Cesium.NearFarScalar(
+          5000000,
+          1,
+          30000000,
+          0
+        )
+        break
+      case '1:25万':
+        lngStep = 1.5;
+        latStep = 1;
+        scaleByDistance = new Cesium.NearFarScalar(
+          2300000,
+          1,
+          20000000,
+          0
+        )
+        break
+      case '1:10万':
+        lngStep = 0.5;
+        latStep = 1 / 3;
+        scaleByDistance = new Cesium.NearFarScalar(
+          680000,
+          1,
+          5000000,
+          0
+        )
+        break
+      case '1:5万':
+        lngStep = 0.25;
+        latStep = 1 / 6;
+        scaleByDistance = new Cesium.NearFarScalar(
+          385000,
+          1,
+          2400000,
+          0
+        )
+        break
+      case '1:2.5万':
+        lngStep = 0.125;
+        latStep = 1 / 12;
+        scaleByDistance = new Cesium.NearFarScalar(
+          180000,
+          1,
+          1200000,
+          0
+        )
+        break
+      case '1:1万':
+        lngStep = 0.0625;
+        latStep = 1 / 24;
+        scaleByDistance = new Cesium.NearFarScalar(
+          90000,
+          1,
+          700000,
+          0
+        )
+        break
+      case '1:5000':
+        lngStep = 0.03125;
+        latStep = 1 / 48;
+        scaleByDistance = new Cesium.NearFarScalar(
+          46000,
+          1,
+          300000,
+          0
+        )
+        break
+      // case '1:1000':
+      //     lngStep = 0.01041667;
+      //     latStep = 0.00694444;
+      //     break
+      // case '1:2000':
+      //     lngStep = 0.00520833;
+      //     latStep = 0.00347222;
+      //     break
+    }
+
+    let minLng = Math.floor((180 + Cesium.Math.toDegrees(rectangle.west)) / lngStep) * lngStep - 180;
+    let minLat = Math.floor((88 + Cesium.Math.toDegrees(rectangle.south)) / latStep) * latStep - 88;
+    let maxLng = Math.ceil((180 + Cesium.Math.toDegrees(rectangle.east)) / lngStep) * lngStep - 180;
+    let maxLat = Math.ceil((88 + Cesium.Math.toDegrees(rectangle.north)) / latStep) * latStep - 88;
+
+    if (minLng > maxLng) {
+      maxLng += 360
+    }
+
+    maxRectangle = { minLng, minLat, maxLng, maxLat }
+    if (minLat < -88) {
+      minLat = -88
+    }
+    if (maxLat > 88) {
+      maxLat = 88
+    }
+
+    if (((maxRectangle.maxLng - maxRectangle.minLng) / lngStep) * ((maxRectangle.maxLat - maxRectangle.minLat) / latStep) > 7000) {
+      maxRectangle = null
+      return
+    }
+
+
+    // 绘制经线
+    for (let lng = minLng; lng <= maxLng; lng += lngStep) {
+      const positions = [];
+      let a = []
+      for (let lat = minLat; Math.floor(lat * 1000000000) / 1000000000 <= maxLat; lat += (latStep / 2)) {
+        a.push([lng, lat])
+        positions.push(Cesium.Cartesian3.fromDegrees(lng, lat, 8848));
+      }
+      if (maxLat != 88 && maxLat + (latStep / 2) >= 88) {
+        positions.push(Cesium.Cartesian3.fromDegrees(lng, 88, 8848));
+      }
+      const geometryInstances = new Cesium.GeometryInstance({
+        geometry: new Cesium.PolylineGeometry({
+          positions: positions,
+          width: 1,
+          vertexFormat: Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
+          arcType: Cesium.ArcType.RHUMB,
+        })
+      });
+
+      gridPrimitives.add(new Cesium.Primitive({
+        geometryInstances: geometryInstances,
+        appearance: new Cesium.PolylineMaterialAppearance({
+          material: Cesium.Material.fromType('Color', {
+            color: Cesium.Color.fromCssColorString('#fcfc00')
+          })
+        })
+      }));
+
+      if (lng < maxLng) {
+        // 计算图幅中心坐标
+        for (let lat = minLat; lat < maxLat; lat += latStep) {
+          let position = { lng: lng + (lngStep / 2), lat: lat + (latStep / 2) };
+          if (position.lat > maxLat) {
+            break
+          }
+          let sheetNumber = calculateMapSheetNumber(position.lng, position.lat, scale);
+          labelCollection.add({
+            position: Cesium.Cartesian3.fromDegrees(position.lng, position.lat, 8848),
+            text: sheetNumber,
+            font: '16px Inter, sans-serif',
+            fillColor: Cesium.Color.fromCssColorString('#fcfc00'),
+            // backgroundColor: Cesium.Color.fromCssColorString('#FFA145'),
+            // backgroundPadding: new Cesium.Cartesian2(8, 4),
+            pixelOffset: new Cesium.Cartesian2(0, 0),
+            showBackground: false,
+            verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+            horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+            scale: 1.0,
+            distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, 80000000),
+            scaleByDistance: scaleByDistance
+          })
+          // labelCollection.add({
+          //     position: Cesium.Cartesian3.fromDegrees(position.lng, position.lat, 10000),
+          //     text: position.lng + ' , ' + position.lat,
+          //     font: '16px Inter, sans-serif',
+          //     fillColor: Cesium.Color.WHITE,
+          //     backgroundColor: Cesium.Color.fromCssColorString('#165DFF').withAlpha(0.8),
+          //     backgroundPadding: new Cesium.Cartesian2(8, 4),
+          //     pixelOffset: new Cesium.Cartesian2(0, 30),
+          //     showBackground: true,
+          //     verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
+          //     horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+          //     scale: 1.0,
+          //     distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, 20000000),
+          //     scaleByDistance: new Cesium.NearFarScalar(
+          //         5000000,
+          //         1,
+          //         20000000,
+          //         0
+          //     )
+          // })
+        }
+      }
+    }
+
+    // 绘制纬线
+    for (let lat = minLat; Math.floor(lat * 1000000000) / 1000000000 <= maxLat; lat += latStep) {
+      const positions = [];
+      let a = []
+      for (let lng = minLng; lng <= maxLng; lng += (lngStep / 2)) {
+        a.push([lng, lat])
+        positions.push(Cesium.Cartesian3.fromDegrees(lng, lat, 8848));
+      }
+      const geometryInstances = new Cesium.GeometryInstance({
+        geometry: new Cesium.PolylineGeometry({
+          positions: positions,
+          width: 1,
+          vertexFormat: Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
+          arcType: Cesium.ArcType.RHUMB,
+        })
+      });
+
+      gridPrimitives.add(new Cesium.Primitive({
+        geometryInstances: geometryInstances,
+        appearance: new Cesium.PolylineMaterialAppearance({
+          material: Cesium.Material.fromType('Color', {
+            color: Cesium.Color.fromCssColorString('#fcfc00')
+          })
+        })
+      }));
+    }
+
+  }
+
+  /**
+  * 根据经纬度和比例尺计算地图图幅编号
+  * @param {number} longitude - 经度（十进制格式）
+  * @param {number} latitude - 纬度（十进制格式）
+  * @param {string} scale - 比例尺（可选值：'1:100万', '1:50万', '1:25万', '1:10万', '1:5万', '1:2.5万', '1:1万', '1:5000'）
+  * @returns {string} 对应的图幅编号
+  */
+  function calculateMapSheetNumber(lng, lat, scale) {
+    let lngStep // 经度步长
+    let latStep // 纬度步长
+    switch (scale) {
+      case '1:100万':
+        lngStep = 6;
+        latStep = 4;
+        break
+      case '1:50万':
+        lngStep = 3;
+        latStep = 2;
+        break
+      case '1:25万':
+        lngStep = 1.5;
+        latStep = 1;
+        break
+      case '1:10万':
+        lngStep = 0.5;
+        latStep = 1 / 3;
+        break
+      case '1:5万':
+        lngStep = 0.25;
+        latStep = 1 / 6;
+        break
+      case '1:2.5万':
+        lngStep = 0.125;
+        latStep = 1 / 12;
+        break
+      case '1:1万':
+        lngStep = 0.0625;
+        latStep = 1 / 24;
+        break
+      case '1:5000':
+        lngStep = 0.03125;
+        latStep = 1 / 48;
+        break
+      // case '1:1000':
+      //     lngStep = 0.01041667;
+      //     latStep = 0.00694444;
+      //     break
+      // case '1:2000':
+      //     lngStep = 0.00520833;
+      //     latStep = 0.00347222;
+      //     break
+    }
+    // 确保纬度在 -88 到 88 度之间（因为 88° 以上采用特殊分幅）
+    lat = Math.max(-88, Math.min(88, lat));
+    lat = Math.abs(lat); // 取绝对值
+
+    let B6 = 'ABCDEFGHIJKLMNOPQRSTUV'
+    let B2 = lng
+    let B3 = lat
+
+    // 计算 1:100 万地形图的列号
+    const col100W = Math.floor(B2 / 6 + 31);
+    // 1:100 万地形图的行号对应的字母（A-V）
+    const rowChar = B6.charAt(Math.floor(B3 / 4 + 1) - 1);
+
+    // 比例尺代码映射
+    const scaleCodeMap = {
+      '1:100万': '',     // 1:100万不需要额外代码
+      '1:50万': 'B',
+      '1:25万': 'C',
+      '1:10万': 'D',
+      '1:5万': 'E',
+      '1:2.5万': 'F',
+      '1:1万': 'G',
+      '1:5000': 'H'
+    };
+
+
+    // 获取比例尺代码
+    const scaleCode = scaleCodeMap[scale];
+    if (!scaleCode && scale !== '1:100万') {
+      throw new Error('不支持的比例尺，请使用: 1:100万, 1:50万, 1:25万, 1:10万, 1:5万, 1:2.5万, 1:1万, 1:5000');
+    }
+
+    // 计算在 1:100 万图幅内的行列号（根据不同比例尺）
+    let rowIn100W, colIn100W;
+    rowIn100W = rowChar + col100W;
+
+    const num1 = Math.floor((Math.ceil(B3 / 4) * 4 - B3) / latStep) + 1;
+    const rowNum = ("000" + num1).slice(-3);
+    const remainder = B2 - Math.floor(B2 / 6) * 6;
+    const num2 = Math.floor(remainder / lngStep) + 1;
+    const colNum = ("000" + num2).slice(-3);
+
+    switch (scale) {
+      case '1:100万':
+        // 1:100万直接使用行号和列号
+        return rowIn100W;
+      case '1:50万':
+        break;
+      case '1:25万':
+        break;
+      case '1:10万':
+        break;
+
+      case '1:5万':
+        break;
+
+      case '1:2.5万':
+        break;
+
+      case '1:1万':
+        break;
+
+      case '1:5000':
+        break;
+
+      default:
+        throw new Error('不支持的比例尺');
+    }
+
+    // 生成最终编号
+    return rowIn100W + scaleCode + rowNum + colNum;
+  }
+
+  // 获取当前视角矩形范围（二维模式）
+  function getViewExtend() {
+    let params = {};
+    let extend = viewer.camera.computeViewRectangle();
+    if (viewer.scene.mode == 2) {
+      //2D下会可能拾取不到坐标，extend返回undefined,所以做以下转换
+      let canvas = viewer.scene.canvas;
+      let upperLeft = new Cesium.Cartesian2(0, 0);//canvas左上角坐标转2d坐标
+      let lowerRight = new Cesium.Cartesian2(
+        canvas.clientWidth,
+        canvas.clientHeight
+      );//canvas右下角坐标转2d坐标
+
+      let ellipsoid = viewer.scene.globe.ellipsoid;
+      let upperLeft3 = viewer.camera.pickEllipsoid(
+        upperLeft,
+        ellipsoid
+      );//2D转3D世界坐标
+
+      let lowerRight3 = viewer.camera.pickEllipsoid(
+        lowerRight,
+        ellipsoid
+      );//2D转3D世界坐标
+
+      if (!upperLeft3) {
+        let cartesian2 = Cesium.SceneTransforms.wgs84ToWindowCoordinates(viewer.scene, { x: 0, y: 0, z: 6356755 });
+        upperLeft.y = cartesian2.y + 5
+        upperLeft3 = viewer.camera.pickEllipsoid(
+          upperLeft,
+          ellipsoid
+        );
+      }
+      if (!lowerRight3) {
+        let cartesian2 = Cesium.SceneTransforms.wgs84ToWindowCoordinates(viewer.scene, { x: 0, y: 0, z: -6356755 });
+        lowerRight.y = cartesian2.y - 5
+        lowerRight3 = viewer.camera.pickEllipsoid(
+          lowerRight,
+          ellipsoid
+        );
+        // console.log('lowerRight3', lowerRight, lowerRight3)
+      }
+      let upperLeftCartographic = viewer.scene.globe.ellipsoid.cartesianToCartographic(
+        upperLeft3
+      );//3D世界坐标转弧度
+      let lowerRightCartographic = viewer.scene.globe.ellipsoid.cartesianToCartographic(
+        lowerRight3
+      );//3D世界坐标转弧度
+
+      if ((lowerRight.y - upperLeft.y) / (lowerRight.x - upperLeft.x) <= 0.49998752339363695) {
+        extend = new Cesium.Rectangle(Cesium.Math.toRadians(-180), Cesium.Math.toRadians(-90), Cesium.Math.toRadians(180), Cesium.Math.toRadians(90))
+      }
+      else {
+        extend = new Cesium.Rectangle(upperLeftCartographic.longitude, lowerRightCartographic.latitude, lowerRightCartographic.longitude, upperLeftCartographic.latitude);
+      }
+
+      // console.log("经度：" + minx + "----" + maxx);
+      // console.log("纬度：" + miny + "----" + maxy);
+
+      return extend;
+    } else {
+      //3D获取方式
+      return extend;
+    }
+
+  }
+
+}
+function close(sdk) {
+  let viewer = sdk.viewer;
+  let gridPrimitives
+  let labelCollection
+  for (let i = 0; i < viewer.scene.primitives._primitives.length; i++) {
+    if (viewer.scene.primitives._primitives[i].name === 'SheetIndexGridPrimitives') {
+      gridPrimitives = viewer.scene.primitives._primitives[i];
+      for (let j = 0; j < gridPrimitives._primitives.length; j++) {
+        if (gridPrimitives._primitives[j].name === 'SheetIndexLabelCollection') {
+          labelCollection = gridPrimitives._primitives[j];
+          break;
+        }
+      }
+      break;
+    }
+  }
+
+  labelCollection && (labelCollection.removeAll());
+  gridPrimitives && (gridPrimitives.removeAll());
+  gridPrimitives && (viewer.scene.postRender.removeEventListener(gridPrimitives.postRenderEvent));
+}
+
+export { SheetIndexStatusSwitch, changeScale, getStatus }

src/Global/Skin/index.js

@@ -0,0 +1,30 @@
+let theme = {
+  "yingguangse": new Map(),
+  "gonganlan": new Map(),
+  "hong": new Map(),
+}
+// 主色
+theme.yingguangse.set("--color-sdk-base", "#00ffff")
+// 辅色
+theme.yingguangse.set("--color-sdk-auxiliary", "#004242")
+theme.yingguangse.set("--color-sdk-auxiliary-public", "#ffffff")
+// 预警色
+theme.yingguangse.set("--color-sdk-warning-0", "#1BF8C3")
+theme.yingguangse.set("--color-sdk-warning-1", "#F16C55")
+theme.yingguangse.set("--color-sdk-warning-2", "#FFA145")
+theme.yingguangse.set("--color-sdk-warning-3", "#FFDF53")
+// 文本色
+theme.yingguangse.set("--color-sdk-text-head", "#FFFFFF")
+theme.yingguangse.set("--color-sdk-text-head-1", "#E6F7FF")
+theme.yingguangse.set("--color-sdk-text-head-2", "#ADF1FF")
+// 渐变色
+theme.yingguangse.set("--color-sdk-gradual", "#00ffff 6.25%, #00ffff 100%")
+theme.yingguangse.set("--color-sdk-bg-gradual", "#00ffff33 0%, #00ffff00 100%")
+
+export default theme;
+
+function setSkin(name) {
+  document.documentElement.style.setProperty('--color-sdk-base', 'rgba(0, 55, 55, 1)');
+}
+
+export { setSkin }

src/Global/SplitScreen/ClickCallback/index.js

@@ -0,0 +1,578 @@
+/**
+ * @name: click
+ * @author: Administrator
+ * @date: 2023-05-28 11:05
+ * @description：click
+ * @update: 2023-05-28 11:05
+ */
+let leftClickHandler = null
+let rightClickHandler = null
+let MoveHandler = null
+let leftClickCallbackMap = new Map()
+let rightClickCallbackMap = new Map()
+let MoveCallbackMap = new Map()
+let selectedFeature;
+
+
+function cartesian3Towgs84(cartesian, viewer) {
+  var ellipsoid = viewer.scene.globe.ellipsoid
+  var cartesian3 = new Cesium.Cartesian3(
+    cartesian.x,
+    cartesian.y,
+    cartesian.z
+  )
+  var cartographic = ellipsoid.cartesianToCartographic(cartesian3)
+  var lat = Cesium.Math.toDegrees(cartographic.latitude)
+  var lng = Cesium.Math.toDegrees(cartographic.longitude)
+  var alt = cartographic.height < 0 ? 0 : cartographic.height
+  return {
+    lng: lng,
+    lat: lat,
+    alt: alt,
+  }
+}
+
+function getcartesian(sdk, movement) {
+  if (movement.endPosition) {
+    movement.endPosition.y -= 2
+  }
+  let position = movement.position || movement.endPosition
+  // 获取世界坐标系地表坐标，考虑地形，不包括模型，倾斜摄影模型表面；
+  let cartesian = sdk.viewer.scene.pickPosition(position)
+  if (!cartesian) {
+    const ray = sdk.viewer.camera.getPickRay(position); //相交的射线
+    cartesian = sdk.viewer.scene.globe.pick(ray, sdk.viewer.scene);
+  }
+  return cartesian
+}
+
+function openLeftClick(sdk, cb) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  let click = true
+  leftClickHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
+  leftClickHandler.setInputAction((movement) => {
+    let cartesian = sdk.viewer.scene.pickPosition(movement.position)
+    if (!cartesian) {
+      const ray = sdk.viewer.camera.getPickRay(movement.position); //相交的射线
+      cartesian = sdk.viewer.scene.globe.pick(ray, sdk.viewer.scene);
+    }
+    if (!cartesian) {
+      return
+    }
+
+    let pos84 = cartesian3Towgs84(cartesian, sdk.viewer)
+
+    cb && cb(pos84)
+
+    if (click) {
+      click = false
+      setTimeout(() => {
+        click = true
+      }, 600);
+      if (!YJ.Measure.GetMeasureStatus() && cartesian) {
+        let flag = false
+        for (let i = leftClickCallbackMap.size - 1; i >= 0; i--) {
+          let key = Array.from(leftClickCallbackMap.keys())[i]
+          let obj = leftClickCallbackMap.get(key)
+          if (obj) {
+
+            if (obj.that) {
+              // 是否为多边形
+              if (obj.that.type === 'PolygonObject') {
+                // 是否可点击y
+                if (obj.that.picking) {
+                  if (obj.that.options.positions && obj.that.options.positions.length >= 3) {
+                    let pt = turf.point([pos84.lng, pos84.lat]);
+                    let polyPos = []
+                    for (let i = 0; i < obj.that.options.positions.length; i++) {
+                      polyPos.push([
+                        obj.that.options.positions[i].lng,
+                        obj.that.options.positions[i].lat
+                      ])
+                    }
+                    polyPos.push([
+                      obj.that.options.positions[0].lng,
+                      obj.that.options.positions[0].lat
+                    ])
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+                }
+              }
+              // 聚集地
+              else if (obj.that.type === 'AssembleObject') {
+                if (obj.that.picking) {
+                  if (obj.that.options.positions && obj.that.options.positions.length >= 3) {
+                    let positions = obj.that.computeAssemble(obj.that.options.positions, true)
+                    let pt = turf.point([pos84.lng, pos84.lat]);
+                    let polyPos = []
+                    for (let i = 0; i < positions.length; i += 2) {
+                      polyPos.push([
+                        positions[i],
+                        positions[i + 1]
+                      ])
+                    }
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+                }
+              }
+              // 单箭头
+              else if (obj.that.type === 'AttackArrowObject') {
+                if (obj.that.picking) {
+                  if (obj.that.options.positions && obj.that.options.positions.length >= 3) {
+                    let pt = turf.point([pos84.lng, pos84.lat]);
+                    let positions = obj.that.computeAttackArrow(obj.that.options.positions)
+                    let polyPos = []
+                    for (let m = 0; m < positions.length; m++) {
+                      let pos84 = cartesian3Towgs84(positions[m], sdk.viewer)
+                      polyPos.push([pos84.lng, pos84.lat])
+                    }
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+                }
+              }
+              // 双箭头
+              else if (obj.that.type === 'PincerArrowObject') {
+                if (obj.that.picking) {
+                  if (obj.that.options.positions && obj.that.options.positions.length >= 5) {
+                    let pt = turf.point([pos84.lng, pos84.lat]);
+                    let positions = obj.that.computePincerArrow(obj.that.options.positions)
+                    let polyPos = []
+                    for (let m = 0; m < positions.length; m++) {
+                      let pos84 = cartesian3Towgs84(positions[m], sdk.viewer)
+                      polyPos.push([pos84.lng, pos84.lat])
+                    }
+                    let pos84_0 = cartesian3Towgs84(positions[0], sdk.viewer)
+                    polyPos.push([pos84_0.lng, pos84_0.lat])
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+                }
+              }
+              // 圆
+              else if (obj.that.type === 'CircleObject') {
+                if (obj.that.picking) {
+                  let pt = turf.point([pos84.lng, pos84.lat]);
+                  if (obj.that.options.center && obj.that.options.radius) {
+                    let center = [obj.that.options.center.lng, obj.that.options.center.lat];
+                    let radius = obj.that.options.radius / 1000;
+                    let options = { steps: 360, units: 'kilometers' };
+                    let circle = turf.circle(center, radius, options);
+                    let contain = turf.booleanPointInPolygon(pt, circle);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+
+                }
+              }
+              // 扇形
+              else if (obj.that.type === 'SectorObject') {
+                if (obj.that.picking) {
+                  let pt = turf.point([pos84.lng, pos84.lat]);
+                  if (obj.that.options.center && obj.that.options.radius && obj.that.options.startAngle && obj.that.options.endAngle) {
+                    let positions = obj.that.calSector(obj.that.options.center, obj.that.options.radius, obj.that.options.startAngle, obj.that.options.endAngle, undefined, true)
+                    let polyPos = []
+                    for (let m = 0; m < positions.length; m++) {
+                      polyPos.push([positions[m].lng, positions[m].lat])
+                    }
+                    let poly = turf.polygon([polyPos]);
+                    let contain = turf.booleanPointInPolygon(pt, poly);
+                    if (contain) {
+                      obj.callback(
+                        movement,
+                        obj.that.options.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      flag = true
+                      break
+                    }
+                  }
+
+                }
+              }
+            }
+          }
+        }
+        if (!flag) {
+          const pick = sdk.viewer.scene.pick(movement.position)
+          if (pick) {
+            if (pick.id) {
+              let entityId
+              // 矢量
+              if (pick.id.type && pick.id.type === 'vector' && pick.id.parentId) {
+                let obj = leftClickCallbackMap.get(pick.id.parentId)
+                if (obj.that.picking && obj.that.geojson) {
+                  for (let i = 0; i < obj.that.geojson.features.length; i++) {
+                    if (obj.that.geojson.features[i].id === pick.id._id) {
+                      obj.callback(
+                        movement,
+                        obj.that.geojson.features[i].id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                    }
+                  }
+                }
+              }
+              else if (typeof pick.id.id == 'string') {
+                let array = pick.id.id.split('-')
+                array.splice(array.length - 1, 1)
+                entityId = array.join('-')
+              }
+
+              if (pick.id.properties && pick.id.properties.id && leftClickCallbackMap.has(pick.id.properties.id._value)) {
+                let obj = leftClickCallbackMap.get(pick.id.properties.id._value)
+                if (obj.that.picking) {
+                  obj.callback(
+                    movement,
+                    pick.id.properties.id._value,
+                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                }
+              }
+              else if (leftClickCallbackMap.has(pick.id.id)) {
+                let obj = leftClickCallbackMap.get(pick.id.id)
+                if (obj.that.picking) {
+                  obj.callback(
+                    movement,
+                    pick.id.id,
+                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                }
+              }
+              else if (entityId && leftClickCallbackMap.has(entityId)) {
+                let obj = leftClickCallbackMap.get(entityId)
+                if (obj.that.picking) {
+                  obj.callback(
+                    movement,
+                    entityId,
+                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                }
+              }
+              else if (pick.primitive) {
+                if (typeof pick.id == 'string' && leftClickCallbackMap.has(pick.id)) {
+                  let obj = leftClickCallbackMap.get(pick.id)
+                  obj.callback(
+                    movement,
+                    pick.id,
+                    cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                }
+              }
+            }
+            else {
+              if (pick.primitive && pick.primitive.id) {
+                if (leftClickCallbackMap.has(pick.primitive.id)) {
+                  let obj = leftClickCallbackMap.get(pick.primitive.id)
+                  if (obj.that.picking) {
+                    if (obj.that.type === 'bim') {
+                      if (YJ.Global.getBimPickStatus(sdk)) {
+                        obj.callback(
+                          movement,
+                          pick.primitive,
+                          cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                      }
+                    }
+                    else {
+                      obj.callback(
+                        movement,
+                        pick.primitive.id,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                    }
+                  }
+                }
+              }
+            }
+            if (pick.content && (!pick.primitive || !pick.primitive.id)) {
+              if (leftClickCallbackMap.has(pick.content.tileset.id)) {
+                let obj = leftClickCallbackMap.get(pick.content.tileset.id)
+                if (obj.that.picking) {
+                  if (obj.that.type === 'bim') {
+                    if (YJ.Global.getBimPickStatus(sdk)) {
+                      obj.callback(
+                        movement,
+                        pick.content.tileset,
+                        cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                    }
+                  }
+                  else {
+                    obj.callback(
+                      movement,
+                      pick.content.tileset.id,
+                      cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+
+    // if (click) {
+    //   click = false
+    //   setTimeout(() => {
+    //     click = true
+    //   }, 300);
+    //   if (!YJ.Measure.GetMeasureStatus()) {
+
+    //   }
+    // }
+  }, Cesium.ScreenSpaceEventType.LEFT_CLICK)
+
+  // leftClickHandler.setInputAction(function (movement) {
+  //   const feature = sdk.viewer.scene.pick(movement.endPosition);
+  //   // unselectFeature(selectedFeature);
+  //   if (selectedFeature) {
+  //     selectedFeature.color = Cesium.Color.WHITE;
+  //   }
+  //   selectedFeature = feature
+  //   if (feature) {
+  //     feature.color = Cesium.Color.YELLOW;
+  //   }
+  // }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+  // }
+
+}
+
+function closeLeftClick(sdk) {
+  leftClickHandler.destroy() //关闭事件句柄
+  leftClickHandler = null
+  // }
+}
+
+function openRightClick(sdk) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  rightClickHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
+  rightClickHandler.setInputAction((movement) => {
+    if (!YJ.Measure.GetMeasureStatus()) {
+      const pick = sdk.viewer.scene.pick(movement.position)
+      if (pick && pick.id) {
+        let id
+        if (pick.id.type && pick.id.type === 'vector' && pick.id.parentId) {
+          let obj = rightClickCallbackMap.get(pick.id.parentId)
+          if (obj.that.picking && obj.that.geojson) {
+            for (let i = 0; i < obj.that.geojson.features.length; i++) {
+              if (obj.that.geojson.features[i].id === pick.id._id) {
+                obj.callback(
+                  movement,
+                  obj.that.geojson.features[i].id,
+                  cartesian3Towgs84(getcartesian(sdk, movement), sdk.viewer), obj.that)
+              }
+            }
+          }
+        }
+        else {
+          if (typeof pick.id === 'string') {
+            id = pick.id
+          }
+          else {
+            id = pick.id.id
+          }
+          if (rightClickCallbackMap.has(id)) {
+            let obj = rightClickCallbackMap.get(id)
+            if (obj.that.picking) {
+              let cartesian = getcartesian(sdk, movement)
+              if (!cartesian) {
+                return
+              }
+              obj.callback(
+                movement,
+                id,
+                cartesian3Towgs84(cartesian, sdk.viewer), obj.that)
+            }
+          }
+        }
+      }
+      if (pick && pick.content) {
+        if (rightClickCallbackMap.has(pick.content.tileset.id)) {
+          let obj = rightClickCallbackMap.get(pick.content.tileset.id)
+          if (obj.that.picking) {
+            if (obj.that.type === 'bim') {
+              if (YJ.Global.getBimPickStatus(sdk)) {
+                let cartesian = getcartesian(sdk, movement)
+                if (!cartesian) {
+                  return
+                }
+                obj.callback(
+                  movement,
+                  pick.getProperty('id'),
+                  cartesian3Towgs84(cartesian, sdk.viewer), obj.that)
+              }
+            }
+            else {
+              let cartesian = getcartesian(sdk, movement)
+              if (!cartesian) {
+                return
+              }
+              obj.callback(
+                movement,
+                pick.content.tileset.id,
+                cartesian3Towgs84(cartesian, sdk.viewer), obj.that)
+            }
+          }
+        }
+      }
+    }
+  }, Cesium.ScreenSpaceEventType.RIGHT_CLICK)
+}
+
+function closeRightClick() {
+  if (rightClickHandler) {
+    rightClickHandler.destroy() //关闭事件句柄
+    rightClickHandler = null
+  }
+}
+
+function openMove(sdk) {
+  MoveHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
+  MoveHandler.setInputAction(function (movement) {
+    const pick = sdk.viewer.scene.pick(movement.endPosition);
+    // unselectFeature(selectedFeature);
+    // if (selectedFeature) {
+    //   let color = '#fff'
+    //   let state = selectedFeature.getProperty('state')
+    //   switch (state) {
+    //     case '0':
+    //       color = '#fff'
+    //       break;
+    //     case '1':
+    //       color = '#f00'
+    //       break;
+    //     case '2':
+    //       color = '#0f0'
+    //       break;
+    //     case '3':
+    //       color = '#00f'
+    //       break;
+    //     default:
+    //   }
+    //   selectedFeature.color = Cesium.Color.fromCssColorString(color).withAlpha(selectedFeature.tileset.transparency)
+    // }
+    // if (pick && pick.id) { }
+    // if (pick && pick.content) {
+    //   if (MoveCallbackMap.has(pick.content.tileset.id)) {
+    //     let obj = MoveCallbackMap.get(pick.content.tileset.id)
+    //     if (obj.that.picking) {
+    //       if (obj.that.type === 'bim') {
+    //         if (YJ.Global.getBimPickStatus(sdk)) {
+    //           selectedFeature = pick
+    //           pick.color = Cesium.Color.YELLOW;
+    //         }
+    //         else {
+    //           selectedFeature = null
+    //         }
+    //       }
+    //       else {
+    //         selectedFeature = pick
+    //         pick.color = Cesium.Color.YELLOW;
+    //       }
+    //     }
+    //     else {
+    //       selectedFeature = null
+    //     }
+    //   }
+    // }
+  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+}
+
+function closeMove() {
+  if (MoveHandler) {
+    MoveHandler.destroy() //关闭事件句柄
+    MoveHandler = null
+  }
+}
+
+/*注册左键回调*/
+function regLeftClickCallback(id, callback, that) {
+
+  leftClickCallbackMap.set(id, { callback, that })
+}/*取消左键回调*/
+function unRegLeftClickCallback(id,) {
+  leftClickCallbackMap.delete(id,)
+}
+
+/*注册右键回调*/
+function regRightClickCallback(id, callback, that) {
+  rightClickCallbackMap.set(id, { callback, that })
+}/*取消右键回调*/
+function unRegRightClickCallback(id,) {
+  rightClickCallbackMap.delete(id,)
+}
+
+/*注册左键回调*/
+function regMoveCallback(id, callback, that) {
+  MoveCallbackMap.set(id, { callback, that })
+}/*取消左键回调*/
+function unregMoveCallback(id,) {
+  MoveCallbackMap.delete(id,)
+}
+
+function getLeftClickState() {
+  if (leftClickHandler) {
+    return true
+  }
+  else {
+    false
+  }
+}
+
+function getRightClickState() {
+  if (rightClickHandler) {
+    return true
+  }
+  else {
+    false
+  }
+}
+
+function getMoveState() {
+  if (MoveHandler) {
+    return true
+  }
+  else {
+    false
+  }
+}
+
+
+export { openLeftClick, closeLeftClick, regLeftClickCallback, unRegLeftClickCallback, openRightClick, closeRightClick, regRightClickCallback, unRegRightClickCallback, openMove, closeMove, regMoveCallback, unregMoveCallback, getLeftClickState, getRightClickState, getMoveState }

src/Global/cluster/cluster.js

@@ -0,0 +1,366 @@
+
+
+/*
+let datasource=null
+let dataSourcePromise = null
+// let enabled = true
+let dataSourcexg = null
+function createCluster(viewer) {
+    datasource = new Cesium.CustomDataSource("dataSource1");
+    dataSourcePromise = viewer.dataSources.add(datasource);
+    dataSourcePromise.then((dataSource)=> {
+        // return;
+        const pixelRange = 15;
+        const minimumClusterSize = 3;
+        const enabled = false;
+        dataSourcexg = dataSource
+
+        dataSource.clustering.enabled = enabled; //聚合开启
+        dataSource.clustering.pixelRange = pixelRange; //设置像素范围，以扩展显示边框
+        dataSource.clustering.minimumClusterSize = minimumClusterSize; //设置最小的聚合点数目，超过此数目才能聚合
+
+        let removeListener;
+
+        //按聚合层级创建对应图标
+        const pinBuilder = new Cesium.PinBuilder();
+        // console.log('pinBuilder',pinBuilder);
+        var pin100 = pinBuilder
+            .fromText("100+", Cesium.Color.BLUE, 48)
+            .toDataURL();
+        var pin50 = pinBuilder
+            .fromText("50+", Cesium.Color.BLUE, 48)
+            .toDataURL();
+        var pin40 = pinBuilder
+            .fromText("40+", Cesium.Color.RED, 48)
+            .toDataURL();
+        var pin30 = pinBuilder
+            .fromText("30+", Cesium.Color.RED, 48)
+            .toDataURL();
+        var pin20 = pinBuilder
+            .fromText("20+", Cesium.Color.RED, 48)
+            .toDataURL();
+        var pin10 = pinBuilder
+            .fromText("10+", Cesium.Color.RED, 48)
+            .toDataURL();
+        // 10以内聚合图标
+        const singleDigitPins = new Array(8);
+        for (let i = 0; i < singleDigitPins.length; ++i) {
+            singleDigitPins[i] = pinBuilder
+                .fromText(`${i + 2}`, Cesium.Color.VIOLET, 48)
+                .toDataURL();
+        }
+
+
+        function customStyle() {
+            if (Cesium.defined(removeListener)) {
+                removeListener();
+                removeListener = undefined;
+            } else {
+                removeListener = dataSource.clustering.clusterEvent.addEventListener(
+                    function(clusteredEntities, cluster) {
+                        cluster.label.show = false;
+                        cluster.billboard.show = true;
+                        cluster.billboard.id = cluster.label.id;
+                        cluster.billboard.verticalOrigin = Cesium.VerticalOrigin.BOTTOM;
+                        if (clusteredEntities.length >= 100) {
+                            cluster.billboard.image = pin100;
+                        } else if (clusteredEntities.length >= 50) {
+                            cluster.billboard.image = pin50;
+                        } else if (clusteredEntities.length >= 40) {
+                            cluster.billboard.image = pin40;
+                        } else if (clusteredEntities.length >= 30) {
+                            cluster.billboard.image = pin30;
+                        } else if (clusteredEntities.length >= 20) {
+                            cluster.billboard.image = pin20;
+                        } else if (clusteredEntities.length >= 10) {
+                            cluster.billboard.image = pin10;
+                        } else {
+                            cluster.billboard.image =
+                                singleDigitPins[clusteredEntities.length - 2];
+                        }
+                    }
+                );
+            }
+
+            // force a re-cluster with the new styling
+            const pixelRange = dataSource.clustering.pixelRange;
+            dataSource.clustering.pixelRange = 0;
+            dataSource.clustering.pixelRange = pixelRange;
+        }
+
+      customStyle();
+
+      var viewModel = {
+        pixelRange: pixelRange,
+        minimumClusterSize: minimumClusterSize,
+      };
+      Cesium.knockout.track(viewModel);
+
+
+      function subscribeParameter(name) {
+        Cesium.knockout
+          .getObservable(viewModel, name)
+          .subscribe(function (newValue) {
+            dataSource.clustering[name] = newValue;
+          });
+      }
+
+      subscribeParameter("pixelRange");
+      subscribeParameter("minimumClusterSize");
+    });
+}
+
+function addCluster(entity) {
+    datasource.entities.add(entity)
+}
+function remove_entity_from_cluster(entity) {
+    datasource.entities.remove(entity)
+}
+
+function switchCluster(status){
+    dataSourcexg.clustering.enabled = status
+}
+
+*/
+
+import Tools from '../../Tools'
+import {
+  getGroundCover
+} from '../../Global/global'
+
+
+/*创建聚合,只能聚合point ，billboard，label*/
+function createCluster(viewer) {
+  let tools = new Tools()
+  let cluster = new Cesium.CustomDataSource("sdk-dataSource1")
+  let dataSourcePromise = viewer.dataSources.add(cluster)
+  dataSourcePromise.then(dataSource => {
+    // if (!get2DView()) {
+    //   dataSource.entities.collectionChanged.addEventListener((entities) => {
+    //     syncDataSources(dataSource, 'entities')
+    //   })
+    // }
+    var pixelRange = 15;
+    var minimumClusterSize = 2;
+    var enabled = false;
+    dataSource.clustering.enabled = enabled;
+    dataSource.clustering.pixelRange = pixelRange;
+    dataSource.clustering.minimumClusterSize = minimumClusterSize;
+    var removeListener;
+
+    var pinBuilder = new Cesium.PinBuilder();
+    var pin50 = pinBuilder
+      .fromText("50+", Cesium.Color.RED, 48)
+      .toDataURL();
+    var pin40 = pinBuilder
+      .fromText("40+", Cesium.Color.ORANGE, 48)
+      .toDataURL();
+    var pin30 = pinBuilder
+      .fromText("30+", Cesium.Color.YELLOW, 48)
+      .toDataURL();
+    var pin20 = pinBuilder
+      .fromText("20+", Cesium.Color.GREEN, 48)
+      .toDataURL();
+    var pin10 = pinBuilder
+      .fromText("10+", Cesium.Color.BLUE, 48)
+      .toDataURL();
+
+    var singleDigitPins = new Array(8);
+    for (var i = 0; i < singleDigitPins.length; ++i) {
+      singleDigitPins[i] = pinBuilder
+        .fromText("" + (i + 2), Cesium.Color.VIOLET, 48)
+        .toDataURL();
+    }
+
+    function customStyle() {
+      if (Cesium.defined(removeListener)) {
+        removeListener();
+        removeListener = undefined;
+      } else {
+        removeListener = dataSource.clustering.clusterEvent.addEventListener(
+          function (clusteredEntities, cluster) {
+            // cluster.label.show = false;
+            // cluster.label.verticalOrigin = false;
+            cluster.billboard.show = true;
+            cluster.billboard.id = cluster.label.id;
+            cluster.billboard.verticalOrigin =
+              Cesium.VerticalOrigin.BOTTOM;
+            // 根据聚合数量的多少设置不同层级的图片以及大小
+            /*if (clusteredEntities.length >= 50) {
+            cluster.billboard.image = that.combineIconAndLabel(host + '1_大红.png', clusteredEntities.length, 64);
+            cluster.billboard.width = 72;
+            cluster.billboard.height = 72;
+          } else if (clusteredEntities.length >= 40) {
+            cluster.billboard.image = that.combineIconAndLabel(host + '1_大黄.png', clusteredEntities.length, 64);
+            cluster.billboard.width = 56;
+            cluster.billboard.height = 56;
+          } else if (clusteredEntities.length >= 30) {
+            cluster.billboard.image = that.combineIconAndLabel(host + '1_大蓝.png', clusteredEntities.length, 64);
+            cluster.billboard.width = 48;
+            cluster.billboard.height = 48;
+          } else if (clusteredEntities.length >= 20) {
+            cluster.billboard.image = that.combineIconAndLabel(host + '1_小红.png', clusteredEntities.length, 64);
+            cluster.billboard.width = 48;
+            cluster.billboard.height = 48;
+          } else if (clusteredEntities.length >= 10) {
+            cluster.billboard.image = that.combineIconAndLabel(host + '1_小黄.png', clusteredEntities.length, 64);
+            cluster.billboard.width = 48;
+            cluster.billboard.height = 48;
+          } else {
+            cluster.billboard.image = that.combineIconAndLabel(host + '1_小蓝.png', clusteredEntities.length, 64);
+            cluster.billboard.width = 40;
+            cluster.billboard.height = 40;
+          }*/
+
+
+            cluster.billboard.image = tools.getSourceRootPath() + '/img/cluster.png'
+            cluster.billboard.disableDepthTestDistance = getGroundCover() ? undefined : Number.POSITIVE_INFINITY
+
+            cluster.label.verticalOrigin = Cesium.VerticalOrigin.CENTER
+            cluster.label.font = "18px Arial,sans-serif",
+              // cluster.label.scale = 0.5
+              cluster.label.disableDepthTestDistance = getGroundCover() ? undefined : Number.POSITIVE_INFINITY
+            cluster.label.style = Cesium.LabelStyle.FILL
+            cluster.label.showBackground = true
+            cluster.label.backgroundColor = Cesium.Color.WHITE.withAlpha(0.0)
+
+            if (clusteredEntities.length >= 1000) {
+              cluster.billboard.scale = 1.5;
+              cluster.label.pixelOffset = new Cesium.Cartesian2(-28, -46)
+            } else if (clusteredEntities.length >= 100) {
+              cluster.billboard.scale = 1.25;
+              cluster.label.pixelOffset = new Cesium.Cartesian2(-21, -40)
+            } else if (clusteredEntities.length >= 50) {
+              cluster.billboard.scale = 1.1;
+              cluster.label.pixelOffset = new Cesium.Cartesian2(-16, -36)
+            } else if (clusteredEntities.length >= 40) {
+              cluster.billboard.scale = 1.05;
+              cluster.label.pixelOffset = new Cesium.Cartesian2(-16, -34)
+            } else if (clusteredEntities.length >= 30) {
+              cluster.billboard.scale = 1;
+              cluster.label.pixelOffset = new Cesium.Cartesian2(-16, -32)
+            } else if (clusteredEntities.length >= 20) {
+              cluster.billboard.scale = 0.95;
+              cluster.label.pixelOffset = new Cesium.Cartesian2(-16, -30)
+            } else if (clusteredEntities.length >= 10) {
+              cluster.billboard.scale = 0.9;
+              cluster.label.pixelOffset = new Cesium.Cartesian2(-16, -28)
+            } else {
+              cluster.billboard.scale = 0.8;
+              cluster.label.pixelOffset = new Cesium.Cartesian2(-11, -25)
+            }
+
+            // if (clusteredEntities.length >= 50) {
+            //   cluster.billboard.image = pin50;
+            // } else if (clusteredEntities.length >= 40) {
+            //   cluster.billboard.image = pin40;
+            // } else if (clusteredEntities.length >= 30) {
+            //   cluster.billboard.image = pin30;
+            // } else if (clusteredEntities.length >= 20) {
+            //   cluster.billboard.image = pin20;
+            // } else if (clusteredEntities.length >= 10) {
+            //   cluster.billboard.image = pin10;
+            // } else {
+            //   cluster.billboard.image =
+            //     singleDigitPins[clusteredEntities.length - 2];
+            // }
+          }
+        );
+      }
+
+      // force a re-cluster with the new styling
+      var pixelRange = dataSource.clustering.pixelRange;
+      dataSource.clustering.pixelRange = 0;
+      dataSource.clustering.pixelRange = pixelRange;
+    }
+
+    // start with custom style
+    customStyle();
+
+    var viewModel = {
+      pixelRange: pixelRange,
+      minimumClusterSize: minimumClusterSize,
+    };
+    Cesium.knockout.track(viewModel);
+
+
+    function subscribeParameter(name) {
+      Cesium.knockout
+        .getObservable(viewModel, name)
+        .subscribe(function (newValue) {
+          dataSource.clustering[name] = newValue;
+        });
+    }
+
+    subscribeParameter("pixelRange");
+    subscribeParameter("minimumClusterSize");
+    // var handler = new Cesium.ScreenSpaceEventHandler(this.sdk.viewer.scene.canvas);
+    // handler.setInputAction((movement) => {
+    //     var pickedLabel = this.sdk.viewer.scene.pick(movement.position);
+    //
+    //     if (Cesium.defined(pickedLabel)) {
+    //         this.log(pickedLabel)
+    //         var ids = pickedLabel.id;
+    //         if (Array.isArray(ids)) {
+    //             for (var i = 0; i < ids.length; ++i) {
+    //                 ids[i].billboard.color = Cesium.Color.RED;
+    //             }
+    //         }
+    //     }
+    // }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+  })
+}
+
+/**
+ * @description 开启/关闭聚合效果
+ * @method set_cluster_status
+ * @param [enable=false] {boolean}默认关闭
+ * @memberOf Tool-3D
+ * */
+function switchCluster(sdk, enable = false) {
+  let viewer = sdk.viewer
+  for (let i = 0; i < viewer.dataSources._dataSources.length; i++) {
+    if (viewer.dataSources._dataSources[i].name === "sdk-dataSource1") {
+      viewer.dataSources._dataSources[i].clustering.enabled = enable
+      // syncDataSources(viewer.dataSources._dataSources[i], 'clustering')
+      break
+    }
+  }
+}
+
+function addCluster(sdk, entity) {
+  let viewer = sdk.viewer
+  if(!viewer) {
+    return
+  }
+  for (let i = 0; i < viewer.dataSources._dataSources.length; i++) {
+    if (viewer.dataSources._dataSources[i].name === "sdk-dataSource1") {
+      viewer.dataSources._dataSources[i].entities.add(entity)
+      break
+    }
+  }
+}
+
+function remove_entity_from_cluster(viewer, entity) {
+  for (let i = 0; i < viewer.dataSources._dataSources.length; i++) {
+    if (viewer.dataSources._dataSources[i].name === "sdk-dataSource1") {
+      viewer.dataSources._dataSources[i].entities.remove(entity)
+      break
+    }
+  }
+}
+
+function updateCluster(viewer) {
+  if(!viewer) {
+    return
+  }
+  for (let i = 0; i < viewer.dataSources._dataSources.length; i++) {
+    if (viewer.dataSources._dataSources[i].name === "sdk-dataSource1") {
+      viewer.dataSources._dataSources[i].clustering._cluster()
+      break
+    }
+  }
+}
+
+
+export { createCluster, addCluster, switchCluster, remove_entity_from_cluster, updateCluster }

src/Global/efflect/index.js

@@ -0,0 +1,159 @@
+/*全局特效*/
+
+let rainStages = null;
+let snowStages = null;
+let fogStages = null;
+let nightVisionStages = null;
+
+// 雨
+const FS_Rain = `uniform sampler2D colorTexture;//输入的场景渲染照片
+  varying vec2 v_textureCoordinates;
+  uniform float tiltAngle;
+  uniform float rainSize;
+  uniform float rainWidth;
+  uniform float rainSpeed;
+
+  float hash(float x){
+      return fract(sin(x*133.3)*13.13);
+  }
+  void main(void){
+      float time = czm_frameNumber / rainSpeed;
+      vec2 resolution = czm_viewport.zw;
+      vec2 uv=(gl_FragCoord.xy*2.-resolution.xy)/min(resolution.x,resolution.y);
+      vec3 c=vec3(.6,.7,.8);
+      float a= tiltAngle;
+      float si=sin(a),co=cos(a);
+      uv*=mat2(co,-si,si,co);
+      uv*=length(uv+vec2(0,4.9))*rainSize+1.;
+      float v=1.-sin(hash(floor(uv.x*rainWidth))*2.);
+      float b=clamp(abs(sin(20.*time*v+uv.y*(5./(2.+v))))-.95,0.,1.)*20.;
+      c*=v*b; //屏幕上雨的颜色
+      gl_FragColor = mix(texture2D(colorTexture, v_textureCoordinates), vec4(c,1), 0.5); //将雨和三维场景融合
+  }`
+
+// 雪
+const FS_Snow = `uniform sampler2D colorTexture;
+  varying vec2 v_textureCoordinates;
+  uniform float snowSize;
+  uniform float snowSpeed;
+  
+  float snow(vec2 uv,float scale)
+  {
+      float time = czm_frameNumber / snowSpeed;
+      float w=smoothstep(1.,0.,-uv.y*(scale/10.));if(w<.1)return 0.;
+      uv+=time/scale;uv.y+=time*2./scale;uv.x+=sin(uv.y+time*.5)/scale;
+      uv*=scale;vec2 s=floor(uv),f=fract(uv),p;float k=3.,d;
+      p=.5+.35*sin(11.*fract(sin((s+p+scale)*mat2(7,3,6,5))*5.))-f;d=length(p);k=min(d,k);
+      k=smoothstep(0.,k,sin(f.x+f.y)*0.01*snowSize);
+      return k*w;
+  }
+  void main(void){
+      vec2 resolution = czm_viewport.zw;
+      vec2 uv=(gl_FragCoord.xy*2.-resolution.xy)/min(resolution.x,resolution.y);
+      vec3 finalColor=vec3(0);
+      //float c=smoothstep(1.,0.3,clamp(uv.y*.3+.8,0.,.75));
+      float c = 0.0;
+      c+=snow(uv,30.)*.0;
+      c+=snow(uv,20.)*.0;
+      c+=snow(uv,15.)*.0;
+      c+=snow(uv,10.);
+      c+=snow(uv,8.);
+      c+=snow(uv,6.);
+      c+=snow(uv,5.);
+      finalColor=(vec3(c));
+      gl_FragColor = mix(texture2D(colorTexture, v_textureCoordinates), vec4(finalColor,1), 0.5);
+  }
+  `;
+
+// 雾
+const FS_Fog = `
+  uniform sampler2D colorTexture;
+  uniform sampler2D depthTexture;
+  uniform float visibility;
+  uniform vec4 fogColor;
+  varying vec2 v_textureCoordinates;
+  void main(void)
+  {
+    vec4 origcolor = texture2D(colorTexture, v_textureCoordinates);
+    float depth = czm_readDepth(depthTexture, v_textureCoordinates);
+    vec4 depthcolor = texture2D(depthTexture, v_textureCoordinates);
+    float f = visibility * (depthcolor.r - 0.3) / 0.2;
+    if (f < 0.0) f = 0.0;
+    else if (f > 1.0) f = 1.0;
+    gl_FragColor = mix(origcolor, fogColor, f);
+  }
+  `;
+
+
+/*雨天*/
+function rain(sdk, status = false) {
+  rainStages && sdk.viewer.scene.postProcessStages.remove(rainStages)
+  if (status) {
+    rainStages = new Cesium.PostProcessStage({
+      name: "rain",
+      fragmentShader: FS_Rain,
+      uniforms: {
+        tiltAngle: -0.4, // 倾斜角度
+        rainSize: 0.3, // 雨大小
+        rainWidth: 40, //雨长度
+        rainSpeed: 100, //雨速
+      },
+    });
+    sdk.viewer.scene.postProcessStages.add(rainStages);
+  }
+}
+
+// 雪
+function snow(sdk, status = false) {
+  snowStages && sdk.viewer.scene.postProcessStages.remove(snowStages)
+  if (status) {
+    snowStages = new Cesium.PostProcessStage({
+      name: "snow",
+      fragmentShader: FS_Snow,
+      uniforms: {
+        snowSize: 2, // 大小
+        snowSpeed: 60, //速度
+      },
+    });
+    sdk.viewer.scene.postProcessStages.add(snowStages);
+  }
+}
+
+// 雾天
+function fog(sdk, status = false) {
+  fogStages && sdk.viewer.scene.postProcessStages.remove(fogStages)
+  if (status) {
+    fogStages = new Cesium.PostProcessStage({
+      name: "fog",
+      fragmentShader: FS_Fog,
+      uniforms: {
+        visibility: 0.2, //
+        fogColor: Cesium.Color.WHITE,
+      },
+    });
+    sdk.viewer.scene.postProcessStages.add(fogStages);
+  }
+}
+
+// 夜视
+function nightVision(sdk, status = false) {
+  nightVisionStages && sdk.viewer.scene.postProcessStages.remove(nightVisionStages)
+  if (status) {
+    nightVisionStages = Cesium.PostProcessStageLibrary.createNightVisionStage();
+    sdk.viewer.scene.postProcessStages.add(nightVisionStages);
+  }
+}
+
+// 星空
+function skyStarry(sdk, status = false) {
+  sdk.viewer.scene.skyAtmosphere.show = !status
+}
+
+// 光照
+function illumination(sdk, status = false) {
+  sdk.viewer.shadows = status
+  sdk.viewer._shadows = status
+}
+
+
+export { rain, snow, fog, nightVision, skyStarry, illumination }

src/Global/global.js

@@ -0,0 +1,825 @@
+/**
+ * @name: global
+ * @author: Administrator
+ * @date: 2023-12-01 14:15
+ * @description：global
+ * @update: 2023-12-01 14:15
+ */
+
+/*获取当前视角*/
+import MouseEvent from '../Event/index'
+import Tools from "../Tools";
+import { Proj } from "../Tools/proj";
+import { getTheme, setTheme } from "../Obj/Element/theme";
+import { setActiveViewer as setMultiViewportActiveViewer } from './MultiViewportMode'
+import { setActiveViewer as setSplitActiveViewer, getSdk } from './SplitScreen'
+import { updateCluster } from './cluster/cluster'
+
+let coordinateSystem = 'EPSG:4326'
+let _cartesian
+let GroundCover = false
+let bimPickObject = {}
+let containerObject = {}
+let rotateAroundObject = {}
+function getCurrentView(sdk) {
+  let tools = new Tools()
+  let viewer = sdk.viewer
+  return JSON.parse(JSON.stringify({
+    // heading: viewer.camera.heading,
+    // pitch: viewer.camera.pitch,
+    // roll: viewer.camera.roll,
+    position: tools.cartesian3Towgs84(viewer.camera.position, viewer),
+    orientation: {
+      heading: Cesium.Math.toDegrees(viewer.camera.heading),
+      pitch: Cesium.Math.toDegrees(viewer.camera.pitch),
+      roll: Cesium.Math.toDegrees(viewer.camera.roll)
+    }
+  }))
+}
+
+/*设置默认视角*/
+function setDefaultView(sdk, options) {
+  let viewer = sdk.viewer
+  if (options) {
+    viewer.CAMERA_DEFAULT_VIEW_RECTANGLE = {
+      destination: options.destination || {},
+      orientation: options.orientation || {}
+    }
+  }
+  else {
+    viewer.CAMERA_DEFAULT_VIEW_RECTANGLE = undefined
+    //设置cesium的默认视角
+    Cesium.Camera.DEFAULT_VIEW_RECTANGLE = Cesium.Rectangle.fromDegrees(
+      //西边的经度
+      89.5,
+      //南边的纬度
+      10.4,
+      //东边的经度
+      110.4,
+      //北边的维度
+      61.2
+    )
+  }
+}
+
+/*定位到指定视角*/
+async function flyTo(sdk, options, duration = 3) {
+  let tools = new Tools(sdk)
+  let destination
+  let orientation = options.orientation
+  if (options.position) {
+    if (options.position.alt !== 0 && !options.position.alt) {
+      options.position.alt = await tools.getClampToHeight(options.position)
+    }
+    let h = 0
+    if (!orientation) {
+      h = 500
+    }
+    destination = Cesium.Cartesian3.fromDegrees(options.position.lng, options.position.lat, options.position.alt + h)
+  }
+  else {
+    let bbox = tools.cal_envelope(options.positions)
+    destination = new Cesium.Rectangle(
+      Cesium.Math.toRadians(bbox[3][0]),
+      Cesium.Math.toRadians(bbox[3][1]),
+      Cesium.Math.toRadians(bbox[1][0]),
+      Cesium.Math.toRadians(bbox[1][1])
+    )
+  }
+  closeRotateAround(sdk)
+  sdk.viewer.camera.flyTo({ destination, duration, orientation, complete: options.complete, })
+}
+
+/*相机锁定*/
+function CameraController(sdk, status = true) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  let viewer = sdk.viewer
+  viewer.scene.screenSpaceCameraController.enableRotate = status;
+  viewer.scene.screenSpaceCameraController.enableTranslate = status;
+  viewer.scene.screenSpaceCameraController.enableZoom = status;
+  viewer.scene.screenSpaceCameraController.enableTilt = status;
+  viewer.scene.screenSpaceCameraController.enableLook = status;
+}
+
+/*控件显隐*/
+function CesiumContainer(sdk, options) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  containerObject[sdk.viewer._element.className] || (containerObject[sdk.viewer._element.className] = {})
+  containerObject[sdk.viewer._element.className].event && containerObject[sdk.viewer._element.className].event.destroy()
+  let tools = new Tools()
+  let element = sdk.viewer._element
+  let proj = sdk.proj
+  for (let key in options) {
+    switch (key) {
+      case 'compass':
+        let compass = element.getElementsByClassName('compass')[0]
+        let navigation = element.getElementsByClassName('navigation-controls')[0]
+        if (options[key]) {
+          compass && (compass.style.display = 'block')
+          navigation && (navigation.style.display = 'flex')
+        }
+        else {
+          compass && (compass.style.display = 'none')
+          navigation && (navigation.style.display = 'none')
+        }
+        break;
+      case 'legend':
+        let distanceLegend = element.getElementsByClassName('distance-legend')[0]
+        if (options[key]) {
+          distanceLegend && (distanceLegend.parentNode.style.display = 'block')
+        }
+        else {
+          distanceLegend && (distanceLegend.parentNode.style.display = 'none')
+        }
+        break;
+      case 'info':
+        let infoElm = element.getElementsByClassName('cesium-info')[0]
+        if (options[key]) {
+          if (infoElm) {
+            update()
+            infoElm.style.display = 'block'
+          }
+          else {
+            infoElm = document.createElement('div');
+            infoElm.className = "cesium-info"
+            infoElm.style.position = 'absolute';
+            infoElm.style.bottom = '32px';
+            infoElm.style.right = '240px';
+            infoElm.style['font-size'] = '14px';
+            infoElm.style['background-color'] = 'rgba(47,53,60,.8)';
+            infoElm.style.color = '#fff';
+            infoElm.style.padding = '4px 10px';
+            infoElm.style['border-radius'] = '18px';
+
+            if (coordinateSystem === 'EPSG:4326') {
+              infoElm.innerHTML = `
+                <span>经度：</span><span>-</span>
+                <span>纬度：</span><span>-</span>
+                <span>海拔高度：</span><span>-</span>
+              `
+            }
+            else {
+              infoElm.innerHTML = `
+                <span>x：</span><span>-</span>
+                <span>y：</span><span>-</span>
+                <span>z：</span><span>-</span>
+              `
+            }
+            sdk.viewer._element.appendChild(infoElm)
+          }
+          let event = new MouseEvent(sdk)
+          containerObject[sdk.viewer._element.className].event = event
+          event.mouse_move((movement, cartesian) => {
+            _cartesian = cartesian
+            update()
+          })
+          function update() {
+            if (!_cartesian) {
+              return
+            }
+            let position = tools.cartesian3Towgs84(_cartesian, sdk.viewer)
+            if (coordinateSystem === 'EPSG:4326') {
+              infoElm.innerHTML = `
+                  <span>经度：</span><span>${Number(position.lng.toFixed(6))}° </span>
+                  <span>纬度：</span><span>${Number(position.lat.toFixed(6))}° </span>
+                  <span>海拔高度：</span><span>${Number(position.alt.toFixed(2))}米</span>
+                `
+            }
+            else {
+              let result = proj.convert([{ x: position.lng, y: position.lat, z: position.alt }], 'EPSG:4326', coordinateSystem)
+              infoElm.innerHTML = `
+                  <span>x：</span><span>${Number(result.points[0].x.toFixed(6))}</span>
+                  <span style="margin-left: 5px;">y：</span><span>${Number(result.points[0].y.toFixed(6))}</span>
+                  <span style="margin-left: 5px;">z：</span><span>${Number(result.points[0].z.toFixed(6))}</span>
+                `
+            }
+          }
+        }
+        else {
+          infoElm && (infoElm.style.display = 'none')
+        }
+        break;
+      case 'frame':
+        if (options[key]) {
+          sdk.viewer.scene.debugShowFramesPerSecond = true;
+          setTimeout(() => {
+            let cesiumWidgetContainerElm = sdk.viewer._element.getElementsByClassName('cesium-viewer-cesiumWidgetContainer')[0]
+            let defaultContainer = cesiumWidgetContainerElm.getElementsByClassName('cesium-performanceDisplay-defaultContainer')[0]
+            if (defaultContainer) {
+              cesiumWidgetContainerElm.appendChild(defaultContainer)
+            }
+          }, 50);
+        }
+        else {
+          sdk.viewer.scene.debugShowFramesPerSecond = false;
+        }
+        break;
+    }
+  }
+  // let compass = element.getElementsByClassName('compass')[0]
+  // let navigation = element.getElementsByClassName('navigation-controls')[0]
+  // let distanceLegend = element.getElementsByClassName('distance-legend')[0]
+  // if(status) {
+  //   compass && (compass.style.display = 'block')
+  //   navigation && (navigation.style.display = 'block')
+  //   distanceLegend && (distanceLegend.style.display = 'block')
+  // }
+  // else {
+  //   compass && (compass.style.display = 'none')
+  //   navigation && (navigation.style.display = 'none')
+  //   distanceLegend && (distanceLegend.style.display = 'none')
+  //   viewer.cesiumNavigation.distanceLegendViewModel.destroy()
+  // }
+}
+
+/*设置广告牌默认图标*/
+function setBillboardDefaultUrl(url, name) {
+  if (name) {
+    name = 'billboard_default_url_' + name
+  }
+  else {
+    name = 'billboard_default_url'
+  }
+  localStorage.setItem(name, url);
+}
+/*获取广告牌默认图标*/
+function getBillboardDefaultUrl(name) {
+  if (name) {
+    name = 'billboard_default_url_' + name
+  }
+  else {
+    name = 'billboard_default_url'
+  }
+  return localStorage.getItem(name);
+}
+
+/*设置高度参考*/
+function setGroundCover(sdk, status) {
+  GroundCover = status ? true : false
+  updateCluster(sdk.viewer)
+}
+
+/*获取高度参考*/
+function getGroundCover() {
+  return GroundCover
+}
+
+function setBimPickStatus(sdk, status) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  bimPickObject[sdk.viewer._element.className] || (bimPickObject[sdk.viewer._element.className] = {})
+  bimPickObject[sdk.viewer._element.className].status = status
+  if (bimPickObject[sdk.viewer._element.className].MoveHandler) {
+    bimPickObject[sdk.viewer._element.className].MoveHandler.destroy()
+  }
+  if (!status) {
+    return
+  }
+  bimPickObject[sdk.viewer._element.className].MoveHandler = new Cesium.ScreenSpaceEventHandler(sdk.viewer.canvas)
+  bimPickObject[sdk.viewer._element.className].MoveHandler.setInputAction(function (movement) {
+    const pick = sdk.viewer.scene.pick(movement.endPosition);
+    let selectedId = bimPickObject[sdk.viewer._element.className].selectedId
+    let that = sdk.entityMap.get(bimPickObject[sdk.viewer._element.className].id)
+    // if (selectedFeatureId) {
+    //   let color = '#fff'
+    //   let state = selectedFeature.getProperty('state')
+    //   switch (state) {
+    //     case '0':
+    //       color = '#fff'
+    //       break;
+    //     case '1':
+    //       color = '#f00'
+    //       break;
+    //     case '2':
+    //       color = '#0f0'
+    //       break;
+    //     case '3':
+    //       color = '#00f'
+    //       break;
+    //     default:
+    //   }
+    //   selectedFeature.color = Cesium.Color.fromCssColorString(color).withAlpha(selectedFeature.tileset.transparency)
+    // }
+    if (that) {
+      if (that.features.has(selectedId)) {
+        let features = that.features.get(selectedId).features
+        for (let key in features) {
+          if (features[key].content._model) {
+            let color = features[key].customColor || Cesium.Color.fromCssColorString('#fff')
+            features[key].color = Cesium.Color.fromCssColorString(`rgba(${Cesium.Color.floatToByte(color.red)},${Cesium.Color.floatToByte(color.green)},${Cesium.Color.floatToByte(color.blue)},${color.alpha * ((features[key].customAlpha || features[key].customAlpha === 0) ? features[key].customAlpha : 1)})`)
+          }
+        }
+      }
+    }
+    if (pick && pick.content) {
+      let obj = sdk.getIncetance(pick.content.tileset.id)
+      if (obj.type === 'bim') {
+        if (pick.primitive && pick.primitive.id) {
+          let that = sdk.entityMap.get(pick.primitive.id)
+          selectedId = pick.getProperty('id')
+          if (that.features.has(selectedId)) {
+            let features = that.features.get(selectedId).features
+            for (let key in features) {
+              if (features[key].content._model) {
+                features[key].color = Cesium.Color.fromCssColorString('#ffeb3b')
+              }
+            }
+          }
+          bimPickObject[sdk.viewer._element.className].id = pick.primitive.id
+          bimPickObject[sdk.viewer._element.className].selectedId = selectedId
+        }
+      }
+      else {
+        pick.primitive.id = null
+      }
+    }
+  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
+}
+
+function getBimPickStatus(sdk) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  return bimPickObject[sdk.viewer._element.className] ? bimPickObject[sdk.viewer._element.className].status : false
+}
+
+/* 围绕坐标旋转 */
+function rotateAround(sdk, position) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  setActiveViewer(0)
+  sdk.viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
+  // 关闭Controller
+  sdk.entityMap.forEach((item) => {
+    item.editObj && item.editObj.destroy()
+    item.ControllerObject && item.ControllerObject.destroy()
+  })
+  rotateAroundObject[sdk.viewer._element.className] || (rotateAroundObject[sdk.viewer._element.className] = {})
+  rotateAroundObject[sdk.viewer._element.className].animate && TWEEN.remove(rotateAroundObject[sdk.viewer._element.className].animate)
+  rotateAroundObject[sdk.viewer._element.className].event && rotateAroundObject[sdk.viewer._element.className].event.destroy()
+  if (!position) {
+    CameraController(sdk, true)
+    return
+  }
+
+  let point = Cesium.Cartesian3.fromDegrees(position.lng, position.lat, position.alt)
+  let angle = Cesium.Math.toDegrees(sdk.viewer.camera.heading)
+  let range = Cesium.Cartesian3.distance(sdk.viewer.camera.position, point);
+  CameraController(sdk, false)
+  let pitch = sdk.viewer.camera.pitch
+  let degrees = Cesium.Math.toDegrees(pitch)
+  if (degrees < -89.99) {
+    pitch = Cesium.Math.toRadians(-89.99)
+  }
+  rotateAroundObject[sdk.viewer._element.className].animate = new TWEEN.Tween({ angle: angle }).to({ angle: angle - 360 }, 30000).easing(TWEEN.Easing.Linear.None).repeat(Infinity).onUpdate(async (r, a) => {
+    if (!sdk.viewer) {
+      TWEEN.remove(rotateAroundObject[sdk.viewer._element.className].animate)
+      return
+    }
+    sdk.viewer.camera.lookAt(
+      point,
+      new Cesium.HeadingPitchRange(Cesium.Math.toRadians(r.angle), pitch, range)
+    )
+
+    sdk.viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
+  }).start()
+
+  let event = new MouseEvent(sdk)
+  rotateAroundObject[sdk.viewer._element.className].event = event
+  event.mouse_left_down(() => {
+    rotateAroundObject[sdk.viewer._element.className].animate && TWEEN.remove(rotateAroundObject[sdk.viewer._element.className].animate)
+    rotateAroundObject[sdk.viewer._element.className].event && rotateAroundObject[sdk.viewer._element.className].event.destroy()
+    CameraController(sdk, true)
+    sdk.viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
+  })
+}
+
+/* 关闭围绕坐标旋转 */
+function closeRotateAround(sdk) {
+  if (!sdk || !sdk.viewer) {
+    return
+  }
+  if (rotateAroundObject[sdk.viewer._element.className]) {
+    rotateAroundObject[sdk.viewer._element.className].animate && TWEEN.remove(rotateAroundObject[sdk.viewer._element.className].animate)
+    rotateAroundObject[sdk.viewer._element.className].event && rotateAroundObject[sdk.viewer._element.className].event.destroy()
+    CameraController(sdk, true)
+    sdk.viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
+  }
+}
+
+function closeViewFollow(sdk) {
+  if (sdk && sdk.entityMap) {
+    let entityMap = sdk.entityMap
+    for (let [key, value] of entityMap) {
+      if (value.type === 'TrajectoryMotion' && value.viewFollow) {
+        value.viewFollow = false
+      }
+    }
+  }
+}
+
+/* 方里网状态开关 */
+function FlwStatusSwitch(sdk, status) {
+  if(!sdk) {
+    return
+  }
+  let layer
+  let sdkD = getSdk().sdkD
+  if(sdkD && sdk !== sdkD) {
+    FlwStatusSwitch(sdkD, status)
+  }
+  for (let i = 0; i < sdk.viewer.imageryLayers._layers.length; i++) {
+    if (sdk.viewer.imageryLayers._layers[i]._imageryProvider && sdk.viewer.imageryLayers._layers[i]._imageryProvider._type && sdk.viewer.imageryLayers._layers[i]._imageryProvider._type === 'flw') {
+      layer = sdk.viewer.imageryLayers._layers[i]
+      break
+    }
+  }
+  if (layer) {
+    sdk.viewer.imageryLayers.remove(layer)
+  }
+  if (status) {
+    sdk.viewer.imageryLayers.addImageryProvider(new Cesium.TileCoordinatesImageryProviderFlw(
+      {
+        tileWidth: 128,
+        tileHeight: 128,
+      }
+    ));
+  }
+}
+
+function getFlwStatus(sdk) {
+  let status = false
+  for (let i = 0; i < sdk.viewer.imageryLayers._layers.length; i++) {
+    if (sdk.viewer.imageryLayers._layers[i]._imageryProvider && sdk.viewer.imageryLayers._layers[i]._imageryProvider._type && sdk.viewer.imageryLayers._layers[i]._imageryProvider._type === 'flw') {
+      status = true
+      break
+    }
+  }
+  return status
+}
+
+/* 经纬网状态开关 */
+function JwwStatusSwitch(sdk, status) {
+  if(!sdk) {
+    return
+  }
+  let layer
+  let sdkD = getSdk().sdkD
+  if(sdkD && sdk !== sdkD) {
+    JwwStatusSwitch(sdkD, status)
+  }
+  for (let i = 0; i < sdk.viewer.imageryLayers._layers.length; i++) {
+    if (sdk.viewer.imageryLayers._layers[i]._imageryProvider && sdk.viewer.imageryLayers._layers[i]._imageryProvider._type && sdk.viewer.imageryLayers._layers[i]._imageryProvider._type === 'jww') {
+      layer = sdk.viewer.imageryLayers._layers[i]
+      break
+    }
+  }
+  if (layer) {
+    sdk.viewer.imageryLayers.remove(layer)
+  }
+  if (status) {
+    sdk.viewer.imageryLayers.addImageryProvider(new Cesium.TileCoordinatesImageryProviderJww());
+  }
+}
+
+function getJwwStatus(sdk) {
+  let status = false
+  for (let i = 0; i < sdk.viewer.imageryLayers._layers.length; i++) {
+    if (sdk.viewer.imageryLayers._layers[i]._imageryProvider && sdk.viewer.imageryLayers._layers[i]._imageryProvider._type && sdk.viewer.imageryLayers._layers[i]._imageryProvider._type === 'jww') {
+      status = true
+      break
+    }
+  }
+  return status
+}
+
+function splitScreen2(sdk, status) {
+  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)
+  }
+  if (status) {
+    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)'
+    sdk.viewer._element.appendChild(leftElm)
+    sdk.viewer._element.appendChild(rightElm)
+
+    leftElm.checked = true
+    leftElm.addEventListener('change', (e) => {
+      if (!e.target.checked) {
+        if (!rightElm.checked) {
+          rightElm.checked = true
+        }
+      }
+      changeEntitySplitStatus()
+    })
+    rightElm.addEventListener('change', (e) => {
+      if (!e.target.checked) {
+        if (!leftElm.checked) {
+          leftElm.checked = true
+        }
+      }
+      changeEntitySplitStatus()
+    })
+
+    sliderElm.addEventListener('mousedown', () => {
+      document.body.addEventListener('mousemove', mousemove)
+      sliderElm.addEventListener('mouseup', () => {
+        document.body.removeEventListener('mousemove', mousemove)
+      })
+    })
+    function mousemove(a, b) {
+      if (sdk.viewer._element.getElementsByTagName('canvas')[0] === a.target) {
+        sliderElm.style.left = (a.offsetX / sdk.viewer._element.scrollWidth * 100) + '%'
+        sdk.viewer.scene.splitPosition = a.offsetX / sdk.viewer._element.scrollWidth
+      }
+    }
+    sdk.viewer._element.appendChild(sliderElm)
+    sdk.viewer.scene.splitStatus = status
+    sdk.viewer.scene.splitPosition = 0.5
+    changeEntitySplitStatus()
+  }
+  else {
+    sdk.viewer.scene.splitPosition = 0
+    changeEntitySplitStatus(0)
+    sdk.viewer.scene.splitStatus = status
+  }
+
+  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
+    }
+
+    sdk.entityMap.forEach((item, key) => {
+      if (sdk.viewer.scene.splitStatus) {
+        if (item.entity.billboard) {
+          item.entity.billboard.splitDirection = value
+        }
+        else {
+          item.entity && (item.entity.splitDirection = value)
+        }
+      }
+      console.log()
+    })
+  }
+}
+function splitScreen(sdk, status) {
+  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)
+  }
+  if (status) {
+    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)'
+    sdk.viewer._element.appendChild(leftElm)
+    sdk.viewer._element.appendChild(rightElm)
+
+    leftElm.checked = true
+    leftElm.addEventListener('change', (e) => {
+      if (!e.target.checked) {
+        if (!rightElm.checked) {
+          rightElm.checked = true
+        }
+      }
+      changeEntitySplitStatus()
+    })
+    rightElm.addEventListener('change', (e) => {
+      if (!e.target.checked) {
+        if (!leftElm.checked) {
+          leftElm.checked = true
+        }
+      }
+      changeEntitySplitStatus()
+    })
+
+    sliderElm.addEventListener('mousedown', () => {
+      document.body.addEventListener('mousemove', mousemove)
+      sliderElm.addEventListener('mouseup', () => {
+        document.body.removeEventListener('mousemove', mousemove)
+      })
+    })
+    function mousemove(a, b) {
+      if (sdk.viewer._element.getElementsByTagName('canvas')[0] === a.target) {
+        sliderElm.style.left = (a.offsetX / sdk.viewer._element.scrollWidth * 100) + '%'
+        sdk.viewer.scene.splitPosition = a.offsetX / sdk.viewer._element.scrollWidth
+      }
+    }
+    sdk.viewer._element.appendChild(sliderElm)
+    sdk.viewer.scene.splitStatus = status
+    sdk.viewer.scene.splitPosition = 0.5
+    changeEntitySplitStatus()
+  }
+  else {
+    sdk.viewer.scene.splitPosition = 0
+    changeEntitySplitStatus(0)
+    sdk.viewer.scene.splitStatus = status
+  }
+
+  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
+    }
+
+    sdk.entityMap.forEach((item, key) => {
+      if (sdk.viewer.scene.splitStatus) {
+        if (item.entity.billboard) {
+          item.entity.billboard.splitDirection = value
+        }
+        else {
+          item.entity && (item.entity.splitDirection = value)
+        }
+      }
+      console.log()
+    })
+  }
+}
+
+function getCoordinateSystem() {
+  return coordinateSystem
+}
+
+function setCoordinateSystem(sdk, epsg) {
+  coordinateSystem = epsg || 'EPSG:4326'
+  if (!sdk || !sdk.viewer || !sdk.viewer._element) {
+    return
+  }
+  let infoElm = sdk.viewer._element.getElementsByClassName('cesium-info')[0]
+  if (!_cartesian || !infoElm) {
+    return
+  }
+  let tools = new Tools()
+  let proj = sdk.proj
+  let position = tools.cartesian3Towgs84(_cartesian, sdk.viewer)
+  if (coordinateSystem === 'EPSG:4326') {
+    infoElm.innerHTML = `
+                  <span>经度：</span><span>${Number(position.lng.toFixed(6))}° </span>
+                  <span>纬度：</span><span>${Number(position.lat.toFixed(6))}° </span>
+                  <span>海拔高度：</span><span>${Number(position.alt.toFixed(2))}米</span>
+                `
+  }
+  else {
+    let result = proj.convert([{ x: position.lng, y: position.lat, z: position.alt }], 'EPSG:4326', coordinateSystem)
+    infoElm.innerHTML = `
+                  <span>x：</span><span>${Number(result.points[0].x.toFixed(6))}</span>
+                  <span style="margin-left: 5px;">y：</span><span>${Number(result.points[0].y.toFixed(6))}</span>
+                  <span style="margin-left: 5px;">z：</span><span>${Number(result.points[0].z.toFixed(6))}</span>
+                `
+  }
+}
+
+function cameraChanged(sdk, cb) {
+  let tools = new Tools()
+  //设置相机变化的监听事件
+  let removeChanged = sdk.viewer.camera.changed.addEventListener(percentage => {
+    cb({
+      position: tools.cartesian3Towgs84(sdk.viewer.camera.position, sdk.viewer),
+      orientation: {
+        heading: sdk.viewer.camera.heading,
+        pitch: sdk.viewer.camera.pitch,
+        roll: sdk.viewer.camera.roll
+      }
+    })
+  })
+  return removeChanged
+}
+
+function setMaximumRequestsPerServer(v) {
+  if (typeof v == 'number')
+    Cesium.RequestScheduler.maximumRequestsPerServer = v
+}
+
+/* 键盘事件 */
+function setKeyboardEventActive(sdk, status) {
+  if (!sdk) {
+    return
+  }
+  if (status) {
+    sdk.viewer._disableKeyboardEvent = false
+  }
+  else {
+    sdk.viewer._disableKeyboardEvent = true
+  }
+}
+
+function getCesiumIndexedDBMaxSize() {
+  const baseUnit = 1024 * 1024 * 1024
+  let size = Number(Number(localStorage.getItem('IndexedDBMaxSize')).toFixed(0))
+  if (isNaN(size) || size < baseUnit) {
+    size = baseUnit
+  }
+  return size
+}
+function setCesiumIndexedDBMaxSize(v) {
+  const baseUnit = 1024 * 1024 * 1024
+  let maxSize = Number(Number(v).toFixed(0))
+  if (isNaN(maxSize) || maxSize < baseUnit) {
+    maxSize = baseUnit
+  }
+  Cesium.ManageIndexedDB && Cesium.ManageIndexedDB.SetIndexedDBMaxSize(maxSize)
+  localStorage.setItem('IndexedDBMaxSize', maxSize)
+}
+
+function getCesiumManageIndexexDBState() {
+  let state = localStorage.getItem('ManageIndexexDBState')
+  if (state === 'false') {
+    return false
+  }
+  return Boolean(state)
+}
+function setCesiumManageIndexexDBState(v) {
+  if (typeof v === "boolean") {
+    Cesium.ManageIndexedDB && Cesium.ManageIndexedDB.SetManageIndexexDBState(v)
+    localStorage.setItem('ManageIndexexDBState', v)
+  } else {
+    console.error("参数必须为boolean")
+  }
+}
+
+function getCesiumIndexedDBCurrentSize() {
+  return Cesium.ManageIndexedDB && Cesium.ManageIndexedDB.GetIndexedDBCurrentSize()
+}
+
+function setActiveViewer(v) {
+  setMultiViewportActiveViewer(v)
+  setSplitActiveViewer(v)
+}
+
+// 设置地球透明度
+function enablePerspective(sdk, alpha = 1) {
+  if (!alpha && alpha != 0) {
+    alpha = 1
+  }
+  sdk.viewer.scene.globe.translucency.frontFaceAlpha = alpha
+}
+
+export { getCurrentView, setDefaultView, flyTo, CameraController, CesiumContainer, setBillboardDefaultUrl, getBillboardDefaultUrl, setGroundCover, getGroundCover, getBimPickStatus, setBimPickStatus, rotateAround, closeRotateAround, closeViewFollow, FlwStatusSwitch, JwwStatusSwitch, getFlwStatus, getJwwStatus, getCoordinateSystem, setCoordinateSystem, cameraChanged, setMaximumRequestsPerServer, setKeyboardEventActive, getTheme, setTheme, getCesiumIndexedDBMaxSize, setCesiumIndexedDBMaxSize, getCesiumManageIndexexDBState, setCesiumManageIndexexDBState, getCesiumIndexedDBCurrentSize, setActiveViewer, enablePerspective }

src/Global/mouseRightMenu/index.js

@@ -0,0 +1,218 @@
+/* 右键点击菜单 */
+import MouseEvent from '../../Event/index'
+import Tools from '../../Tools'
+import { rotateAround } from '../../Global/global'
+import { getSdk } from '../SplitScreen'
+
+let eventListener = {}
+
+function MouseRightMenu(sdk, status, callBack) {
+  if (!sdk || !sdk.div_id) {
+    return
+  }
+  let sdkD = getSdk().sdkD
+  let _element = document.getElementById(sdk.div_id).getElementsByClassName('cesium-viewer')[0]
+  let tools = new Tools()
+  if (!eventListener[sdk.div_id]) {
+    eventListener[sdk.div_id] = {}
+  }
+  if (eventListener[sdk.div_id].mousedown) {
+    document.removeEventListener(
+      'mousedown',
+      eventListener[sdk.div_id].mousedown
+    )
+  }
+  if (eventListener[sdk.div_id].click) {
+    document.removeEventListener('click', eventListener[sdk.div_id].click)
+  }
+  if(!eventListener[sdk.div_id].callBack) {
+    eventListener[sdk.div_id].callBack = callBack
+  }
+  
+  if(sdk !== sdkD) {
+    eventListener[sdk.div_id].mouseRightMenuEvent &&
+    eventListener[sdk.div_id].mouseRightMenuEvent.destroy()
+  }
+  
+  let menuElm = document.getElementById('custom-menu')
+  if (menuElm) {
+    _element.removeChild(menuElm)
+  }
+  eventListener[sdk.div_id].status = status
+  if (status) {
+    eventListener[sdk.div_id].mousedown = e => {
+      if (
+        (e.target.parentNode && e.target.parentNode.id == 'custom-menu') ||
+        (e.target.parentNode &&
+          e.target.parentNode.parentNode &&
+          e.target.parentNode.parentNode.id == 'custom-menu')
+      ) {
+        return
+      }
+      let menuElm = document.getElementById('custom-menu')
+      if (menuElm) {
+        _element.removeChild(menuElm)
+      }
+    }
+    document.addEventListener('mousedown', eventListener[sdk.div_id].mousedown)
+    eventListener[sdk.div_id].click = e => {
+      if (
+        (e.target.parentNode && e.target.parentNode.id == 'custom-menu') ||
+        (e.target.parentNode &&
+          e.target.parentNode.parentNode &&
+          e.target.parentNode.parentNode.id == 'custom-menu')
+      ) {
+        return
+      }
+      let menuElm = document.getElementById('custom-menu')
+      if (menuElm) {
+        _element.removeChild(menuElm)
+      }
+    }
+    document.addEventListener('click', eventListener[sdk.div_id].click)
+
+    eventListener[sdk.div_id].mouseRightMenuEvent = new MouseEvent(sdk)
+    eventListener[sdk.div_id].mouseRightMenuEvent.mouse_right(
+      (movement, cartesian) => {
+        if (YJ.Measure.GetMeasureStatus() || sdk.viewer.trackedEntity) {
+          return
+        }
+        let entity = sdk.viewer.entities.getById('svg-control-points_0')
+        if (entity && entity.show) {
+          return
+        }
+        let menuElm = document.getElementById('custom-menu')
+        if (menuElm) {
+          _element.removeChild(menuElm)
+        }
+        let entityId = getEntityId(movement)
+        let targetId
+        if(Object.prototype.toString.call(entityId) === '[object Object]') {
+          targetId = entityId.id
+          entityId = entityId.parentId
+        }
+        let addedMenu = ''
+        let that = sdk.entityMap.get(entityId)
+        if (!that && entityId) {
+          let array = entityId.split('-')
+          array.splice(array.length - 1, 1)
+          entityId = array.join('-')
+          that = sdk.entityMap.get(entityId)
+        }
+
+        if (that && that.picking) {
+          addedMenu = `
+        <span class="divider" style="display: block;border-top: 1px solid #ddd;margin: 5px;"></span>
+        <ul class="added" style="list-style: none;padding: 0;margin: 0;font-size: 12px;">
+          <li style="padding: 3px 10px;cursor: pointer;">属性</li>
+        </ul>
+        `
+        }
+        let position = tools.cartesian3Towgs84(cartesian, sdk.viewer)
+        menuElm = document.createElement('div')
+        menuElm.id = 'custom-menu'
+        menuElm.style.position = 'absolute'
+        menuElm.style.width = '110px'
+        menuElm.style.backgroundColor = '#00000085'
+        menuElm.style.color = '#ffffff'
+        menuElm.style.padding = '6px 0'
+        menuElm.style.boxShadow = '4px 4px 4px 0px rgba(0, 0, 0, 0.8)'
+        menuElm.innerHTML = `
+        <ul class="base" style="list-style: none;padding: 0;margin: 0;font-size: 12px;">
+          <li style="padding: 3px 10px;cursor: pointer;">绕鼠标点旋转</li>
+        </ul>
+        ${addedMenu}
+      `
+      _element.appendChild(menuElm)
+        let left = movement.position.x
+        let top = movement.position.y
+        if (
+          movement.position.x + menuElm.offsetWidth >
+          _element.offsetWidth
+        ) {
+          left = movement.position.x - menuElm.offsetWidth
+        }
+        if (
+          movement.position.y + menuElm.offsetHeight >
+          _element.offsetHeight
+        ) {
+          top = movement.position.y - menuElm.offsetHeight
+        }
+        menuElm.style.left = left + 'px'
+        menuElm.style.top = top + 'px'
+
+        menuElm.addEventListener('contextmenu', function(event) {
+          event.preventDefault()
+        })
+        let liElms = menuElm.getElementsByTagName('li')
+        let object = {}
+        for (let i = 0; i < liElms.length; i++) {
+          liElms[i].addEventListener('mouseover', () => {
+            liElms[i].style.backgroundColor = '#5e5e5e'
+          })
+          liElms[i].addEventListener('mouseout', () => {
+            liElms[i].style.backgroundColor = 'unset'
+          })
+          liElms[i].addEventListener('click', () => {
+            let key = ''
+            switch (liElms[i].innerHTML) {
+              case '绕鼠标点旋转':
+                object.position = position
+                key = 'rotateAround'
+                // this.rotateAround(position)
+                break
+              case '属性':
+                if(targetId) {
+                  object.id = targetId
+                  object.parentId = that.options.id
+                }
+                else {
+                  object.id = that.options.id
+                }
+                key = 'attribute'
+                // that.edit(true)
+                // this.attribute(entityId)
+                break
+            }
+            eventListener[sdk.div_id].callBack(key, object)
+            _element.removeChild(menuElm)
+          })
+        }
+      }
+    )
+  }
+
+  function getEntityId(movement) {
+    let pick = sdk.viewer.scene.pick(movement.position)
+    if (pick) {
+      if (pick.id) {
+        if (pick.id.type && pick.id.type === 'vector' && pick.id.parentId) {
+          return {
+            parentId: pick.id.parentId,
+            id: pick.id.id
+          }
+        }
+        else if (pick.id.id) {
+          return pick.id.id
+        } else if (typeof pick.id == 'string') {
+          return pick.id
+        }
+      } else {
+        if (pick.primitive && pick.primitive.id) {
+          return pick.primitive.id
+        }
+      }
+    }
+  }
+}
+
+function getMouseRightMenuStatus(sdk) {
+  if (!sdk || !sdk.div_id || !eventListener[sdk.div_id]) {
+    return
+  }
+  else {
+    return eventListener[sdk.div_id].status
+  }
+}
+
+export { MouseRightMenu, getMouseRightMenuStatus }

src/Global/mouseRightMenu/index2.js

@@ -0,0 +1,156 @@
+/* 右键点击菜单 */
+import MouseEvent from '../../Event/index'
+import Tools from '../../Tools';
+import { rotateAround } from '../../Global/global'
+
+
+class mouseRightMenu {
+  constructor(sdk, cd) {
+    this.sdk = sdk
+    this.callBack = cd
+    this.mouseRightMenuEvent
+    this.tools = new Tools()
+    document.addEventListener('mousedown', (e)=>{
+      if((e.target.parentNode && e.target.parentNode.id == "custom-menu") || (e.target.parentNode && e.target.parentNode.parentNode && e.target.parentNode.parentNode.id == "custom-menu")) {
+        return
+      }
+      let menuElm = document.getElementById('custom-menu')
+      if (menuElm) {
+        this.sdk.viewer._element.removeChild(menuElm)
+      }
+    })
+    document.addEventListener('click', (e)=>{
+      if((e.target.parentNode && e.target.parentNode.id == "custom-menu") || (e.target.parentNode && e.target.parentNode.parentNode && e.target.parentNode.parentNode.id == "custom-menu")) {
+        return
+      }
+      let menuElm = document.getElementById('custom-menu')
+      if (menuElm) {
+        this.sdk.viewer._element.removeChild(menuElm)
+      }
+    })
+  }
+
+  open() {
+    this.mouseRightMenuEvent && this.mouseRightMenuEvent.destroy()
+    this.mouseRightMenuEvent = new MouseEvent(this.sdk)
+    this.mouseRightMenuEvent.mouse_right((movement, cartesian) => {
+      if (YJ.Measure.GetMeasureStatus()) {
+        return
+      }
+      let menuElm = document.getElementById('custom-menu')
+      if (menuElm) {
+        this.sdk.viewer._element.removeChild(menuElm)
+      }
+      let entityId = this.getEntityId(movement)
+      let addedMenu = ''
+      let that = this.sdk.entityMap.get(entityId)
+      if(!that && entityId) {
+        let array = entityId.split("-");
+        array.splice(array.length - 1, 1)
+        entityId = array.join('-')
+        that = this.sdk.entityMap.get(entityId)
+      }
+      if (that && that.picking) {
+        addedMenu = `
+        <span class="divider" style="display: block;border-top: 1px solid #ddd;margin: 5px;"></span>
+        <ul class="added" style="list-style: none;padding: 0;margin: 0;font-size: 12px;">
+          <li style="padding: 3px 10px;cursor: pointer;">属性</li>
+        </ul>
+        `
+      }
+      let position = this.tools.cartesian3Towgs84(cartesian, this.sdk.viewer)
+      menuElm = document.createElement('div');
+      menuElm.id = 'custom-menu'
+      menuElm.style.position = 'absolute'
+      menuElm.style.width = '110px'
+      menuElm.style.backgroundColor = '#00000085'
+      menuElm.style.color = '#ffffff'
+      menuElm.style.padding = '6px 0'
+      menuElm.style.boxShadow = '4px 4px 4px 0px rgba(0, 0, 0, 0.8)'
+      menuElm.innerHTML = `
+        <ul class="base" style="list-style: none;padding: 0;margin: 0;font-size: 12px;">
+          <li style="padding: 3px 10px;cursor: pointer;">绕鼠标点旋转</li>
+        </ul>
+        ${addedMenu}
+      `
+      this.sdk.viewer._element.appendChild(menuElm)
+      let left = movement.position.x
+      let top = movement.position.y
+      if ((movement.position.x + menuElm.offsetWidth) > this.sdk.viewer._element.offsetWidth) {
+        left = movement.position.x - menuElm.offsetWidth
+      }
+      if ((movement.position.y + menuElm.offsetHeight) > this.sdk.viewer._element.offsetHeight) {
+        top = movement.position.y - menuElm.offsetHeight
+      }
+      menuElm.style.left = left + 'px'
+      menuElm.style.top = top + 'px'
+
+      menuElm.addEventListener('contextmenu', function (event) {
+        event.preventDefault();
+      })
+      let liElms = menuElm.getElementsByTagName('li')
+      let object = {}
+      for (let i = 0; i < liElms.length; i++) {
+        liElms[i].addEventListener('mouseover', () => {
+          liElms[i].style.backgroundColor = '#5e5e5e'
+        })
+        liElms[i].addEventListener('mouseout', () => {
+          liElms[i].style.backgroundColor = 'unset'
+        })
+        liElms[i].addEventListener('click', () => {
+          switch (liElms[i].innerHTML) {
+            case '绕中心点旋转':
+              object.position = position
+              // this.rotateAround(position)
+              break
+            case '属性':
+              object.id = that.options.id
+              // that.edit(true)
+              // this.attribute(entityId)
+              break
+          }
+
+          this.callBack(liElms[i].innerHTML, object)
+          this.sdk.viewer._element.removeChild(menuElm)
+        })
+      }
+    })
+  }
+
+  getEntityId(movement) {
+    let pick = this.sdk.viewer.scene.pick(movement.position)
+    if (pick) {
+      if (pick.id) {
+        if (pick.id.id) {
+          return pick.id.id
+        }
+        else if (typeof pick.id == 'string') {
+          return pick.id
+        }
+      }
+      else {
+        if (pick.primitive && pick.primitive.id) {
+          return pick.primitive.id
+        }
+      }
+    }
+  }
+
+  rotateAround(position) {
+    rotateAround(this.sdk, position)
+  }
+
+  attribute(entityId) {
+    if(entityId.endsWith('-label')) {
+      entityId = entityId.replace('-label', '')
+    }
+    let that = this.sdk.entityMap.get(entityId)
+    that && that.edit(true)
+  }
+
+  close() {
+    this.mouseRightMenuEvent && this.mouseRightMenuEvent.destroy()
+  }
+}
+
+export default mouseRightMenu