@aibee/crc-bmap 0.0.9 → 0.0.12

package/lib/bmap.esm.js

@@ -41,7 +41,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/bmap.ts
-import { EventDispatcher as EventDispatcher4 } from "three";
+import { EventDispatcher as EventDispatcher6 } from "three";
 
 // src/utils/timer.ts
 var Timer = class {
@@ -115,7 +115,9 @@ import {
   Group,
   Color,
   DirectionalLight,
-  AmbientLight
+  AmbientLight,
+  Path,
+  Vector2
 } from "three";
 import { MapControls } from "three/examples/jsm/controls/MapControls";
 function initScene() {
@@ -157,15 +159,17 @@ function initControl(camera, domElement) {
   control.minPolarAngle = 0;
   control.maxAzimuthAngle = 0;
   control.minAzimuthAngle = 0;
+  control.minZoom = 1;
+  control.maxZoom = 100;
   return control;
 }
-function initShape(path) {
-  const shape = new Shape();
-  if (Array.isArray(path[0])) {
-    shape.moveTo(...path[0]);
-    for (let i = 1; i < path.length; i++) {
-      shape.lineTo(...path[i]);
-    }
+function initShape(path, holePath = []) {
+  const shape = new Shape(path.map((item) => new Vector2(...item)));
+  if (holePath.length) {
+    holePath.forEach((cur) => {
+      var hole = new Path(cur.map((item) => new Vector2(...item)));
+      shape.holes.push(hole);
+    });
   }
   return shape;
 }
@@ -288,6 +292,9 @@ function getCenter(coordinates) {
   const cent = center(features);
   return cent.geometry.coordinates;
 }
+function isContain(point3, start, end) {
+  return point3.x >= start.x && point3.x <= end.x && point3.y >= start.y && point3.y <= end.y;
+}
 
 // src/utils/proxy.ts
 function proxyOptions(target, master) {
@@ -335,6 +342,12 @@ function createLine(stroke) {
   line.setAttribute("stroke", stroke);
   return line;
 }
+function createRect(stroke, fill) {
+  const rect = createSvgElement("rect");
+  rect.setAttribute("stroke", stroke);
+  rect.setAttribute("fill", fill);
+  return rect;
+}
 function setCirclePosition(circle, x, y) {
   circle.setAttribute("cx", `${x}`);
   circle.setAttribute("cy", `${y}`);
@@ -349,512 +362,203 @@ function setLineStartEnd(line, start, end) {
     line.setAttribute("y2", `${end.y}`);
   }
 }
+function setRectPosition(rect, x, y, w, h) {
+  rect.setAttribute("x", `${x}`);
+  rect.setAttribute("y", `${y}`);
+  rect.setAttribute("width", `${w}`);
+  rect.setAttribute("height", `${h}`);
+}
 
 // src/context.ts
 import {
-  EventDispatcher,
+  EventDispatcher as EventDispatcher5,
   Box2,
-  Vector3,
-  Vector2,
-  Raycaster,
-  Box3,
-  Color as Color2,
+  Vector3 as Vector37,
+  Vector2 as Vector23,
+  Raycaster as Raycaster3,
+  Box3 as Box34,
+  Color as Color4,
   AmbientLight as AmbientLight2
 } from "three";
 import { Group as TweenGroup, Tween } from "@tweenjs/tween.js";
-var Context = class extends EventDispatcher {
-  // zoom=1的时候，100M对应的像素个数
-  constructor(container, config) {
+
+// src/operations/selection/selection.ts
+import { EventDispatcher as EventDispatcher3 } from "three";
+
+// src/elements/graphic.ts
+import {
+  Object3D,
+  ExtrudeGeometry,
+  MeshStandardMaterial,
+  Mesh,
+  Color as Color2,
+  Box3,
+  LineSegments,
+  EdgesGeometry,
+  LineBasicMaterial,
+  Vector3
+} from "three";
+import { merge } from "lodash";
+var defaultOptions = {
+  id: "",
+  // 图形id
+  height: 0.1,
+  // 图形高度
+  airHeight: 0,
+  // 悬空高度
+  area: 0,
+  // 面积
+  group: "",
+  // 分组
+  fillColor: "#EFF4FB",
+  // 颜色
+  strokeColor: "#ffffff",
+  // 边框
+  fillOpacity: 1,
+  // 透明度
+  strokeOpacity: 1,
+  // 描边透明度
+  doors: [],
+  // 门配置
+  locked: false,
+  visible: true,
+  geometry: {
+    type: "polygon",
+    cds: [],
+    curveCpt: [],
+    curveIndex: []
+  },
+  layerType: "",
+  zIndex: 0
+};
+var Graphic = class extends Object3D {
+  constructor(context, options) {
     super();
-    this.container = container;
-    this.config = config;
-    __publicField(this, "scene", initScene());
-    __publicField(this, "renderer", initRenderer());
-    __publicField(this, "camera");
-    __publicField(this, "control");
-    __publicField(this, "lights", initLight());
-    // 管理任务，防止内存泄漏
-    __publicField(this, "timer", new Timer());
-    __publicField(this, "tweenGroup", new TweenGroup());
-    __publicField(this, "currentFloor");
-    __publicField(this, "basicRatio");
-    __publicField(this, "onWindowResize", () => {
-      const { container, camera, renderer } = this;
-      const { clientWidth: w, clientHeight: h } = container;
-      camera.left = -w / 2;
-      camera.right = w / 2;
-      camera.top = h / 2;
-      camera.bottom = -h / 2;
-      camera.updateProjectionMatrix();
-      renderer.setSize(window.innerWidth, window.innerHeight);
+    this.context = context;
+    __publicField(this, "geometry");
+    __publicField(this, "material");
+    __publicField(this, "mesh");
+    __publicField(this, "line");
+    __publicField(this, "options");
+    this.options = proxyOptions(merge({}, defaultOptions, options), this);
+    this.init();
+    this.visible = this.options.visible;
+    this.addEventListener("change-fillColor", ({ value }) => {
+      this.material.color = new Color2(value);
     });
-    __publicField(this, "onClick", (e) => {
-      const { graphics, position } = this.getGraphicsByDeviceXy(e.offsetX, e.offsetY);
-      if (graphics.length) {
-        this.dispatchEvent({
-          type: "graphic-click",
-          graphics,
-          position
-        });
-      }
-      const pois = this.getPoisByDeviceXy(e.clientX, e.clientY);
-      if (pois.length) {
-        this.dispatchEvent({ type: "poi-click", pois });
-      }
+    this.addEventListener("change-fillOpacity", ({ value }) => {
+      this.material.opacity = value;
     });
-    __publicField(this, "onPointerover", (e) => {
-      const { graphics, position } = this.getGraphicsByDeviceXy(e.offsetX, e.offsetY);
-      const pois = this.getPoisByDeviceXy(e.clientX, e.clientY);
-      this.dispatchEvent({ type: "pointer-over", graphics, pois, position });
+    this.addEventListener("change-height", ({ value }) => {
+      this.dispose();
+      this.init();
     });
-    __publicField(this, "onPointermove", (e) => {
-      const { graphics, position } = this.getGraphicsByDeviceXy(e.offsetX, e.offsetY);
-      const pois = this.getPoisByDeviceXy(e.clientX, e.clientY);
-      this.dispatchEvent({ type: "pointer-move", graphics, pois, position });
+    this.addEventListener("change-strokeColor", ({ value }) => {
+      this.line.material.color = new Color2(value);
     });
-    __publicField(this, "onPointerleave", () => {
-      this.dispatchEvent({ type: "pointer-level" });
+    this.addEventListener("change-strokeOpacity", ({ value }) => {
+      this.line.material.opacity = value;
     });
-    this.container.style.position = "relative";
-    this.container.style.overflow = "hidden";
-    this.init();
-    this.registryEvent();
+    this.addEventListener("change-airHeight", ({ value }) => {
+      this.position.z = value;
+    });
+    this.addEventListener("change-visible", ({ value }) => {
+      this.visible = value;
+    });
+  }
+  getCenter() {
+    const center2 = new Vector3();
+    const box = new Box3();
+    box.setFromObject(this);
+    box.getCenter(center2);
+    return center2;
+  }
+  getSize() {
+    const box = new Box3();
+    const size = new Vector3();
+    box.setFromObject(this);
+    box.getSize(size);
+    return size;
+  }
+  getPosition() {
+    return this.getCenter();
   }
   init() {
-    const { clientWidth: w, clientHeight: h } = this.container;
-    this.camera = initCamera(w, h);
-    this.renderer.setSize(w, h);
-    this.control = initControl(this.camera, this.renderer.domElement);
-    this.container.appendChild(this.renderer.domElement);
-    this.scene.add(this.lights);
-    this.basicRatio = this.getRatio();
-    this.control.addEventListener("change", () => {
-      var _a;
-      const polarAngle = this.control.getPolarAngle();
-      (_a = this.currentFloor) == null ? void 0 : _a.setShadowOpacity(polarAngle / this.config.control.maxPolar);
-      this.dispatchEvent({ type: "change-ratio", px: (this.basicRatio || 0) * this.camera.zoom });
+    this.geometry = this.initGeometry();
+    this.material = this.initMaterial();
+    this.mesh = this.initMesh();
+    this.mesh.position.z = this.options.airHeight + this.options.height / 2;
+    this.mesh.castShadow = true;
+    this.add(this.mesh);
+    this.line = this.createBorder();
+    this.add(this.line);
+  }
+  initGeometry() {
+    const shape = initShape(this.options.geometry.cds[0], this.options.geometry.cds.slice(1));
+    const geometry = new ExtrudeGeometry(shape, {
+      steps: 1,
+      bevelEnabled: false,
+      depth: this.options.height,
+      curveSegments: 4
     });
+    return geometry;
   }
-  /**
-   * 获取两个点之间的像素数
-   */
-  getRatio(point1 = new Vector3(0, 0, 0), point22 = new Vector3(100, 0, 0)) {
-    const { clientWidth, clientHeight } = this.container;
-    const device1 = vector3ToDevice(point1, this.camera, clientWidth, clientHeight);
-    const device2 = vector3ToDevice(point22, this.camera, clientWidth, clientHeight);
-    return Math.ceil(Math.sqrt(__pow(device2.x - device1.x, 2) + __pow(device2.y - device1.y, 2)));
+  initMaterial() {
+    const material = new MeshStandardMaterial({
+      color: this.options.fillColor,
+      roughness: 1,
+      transparent: true,
+      opacity: this.options.fillOpacity,
+      depthWrite: true
+    });
+    return material;
   }
-  changeAmbientLightColor(color) {
-    this.lights.children.forEach((item) => {
-      if (item instanceof AmbientLight2) {
-        item.color = new Color2(color);
-      }
+  initLineMaterial() {
+    const lineMaterial = new LineBasicMaterial({
+      color: this.options.strokeColor,
+      opacity: this.options.strokeOpacity,
+      transparent: true,
+      depthWrite: true
     });
+    return lineMaterial;
   }
-  switchFloor(floor) {
-    var _a;
-    if (this.currentFloor) {
-      this.scene.remove(floor);
-      floor.dispose();
-    }
-    this.currentFloor = floor;
-    this.scene.add(floor);
-    const position = (_a = floor.ground) == null ? void 0 : _a.getCenter();
-    if (position) {
-      this.lights.position.x = position.x;
-      this.lights.position.y = position.y;
-    }
+  initMesh() {
+    return new Mesh(this.geometry, this.material);
   }
-  /**
-   * 获取屏幕坐标对应的graphic
-   * @param x
-   * @param y
-   * @returns
-   */
-  getGraphicsByDeviceXy(x, y) {
-    var _a;
-    const point3 = new Vector2();
-    point3.x = x / this.container.clientWidth * 2 - 1;
-    point3.y = y / this.container.clientHeight * -2 + 1;
-    const raycaster = new Raycaster();
-    raycaster.setFromCamera(point3, this.camera);
-    const res = (_a = this.currentFloor) == null ? void 0 : _a.graphicLayer.getGraphicByRaycaster(raycaster);
-    return res || { graphics: [], position: null };
+  createBorder() {
+    const material = this.initLineMaterial();
+    const geometry = new EdgesGeometry(this.geometry);
+    const line = new LineSegments(geometry, material);
+    line.position.z = this.options.airHeight + this.options.height / 2;
+    return line;
   }
-  /**
-   * 获取屏幕坐标对应的poi
-   * @param x
-   * @param y
-   * @returns
-   */
-  getPoisByDeviceXy(x, y) {
-    var _a;
-    const pois = (_a = this.currentFloor) == null ? void 0 : _a.poiLayer.getPoiByDeviceXy(x, y);
-    return pois || [];
+  raycast(raycaster) {
+    if (!this.visible) {
+      return false;
+    }
+    const intersects = raycaster.intersectObject(this.mesh);
+    if (intersects[0]) {
+      const position = intersects[0].point;
+      return position;
+    }
+    return false;
   }
-  registryEvent() {
-    window.addEventListener("resize", this.onWindowResize);
-    this.container.addEventListener("click", this.onClick);
-    this.container.addEventListener("pointerover", this.onPointerover);
-    this.container.addEventListener("pointermove", this.onPointermove);
-    this.container.addEventListener("pointerleave", this.onPointerleave);
-  }
-  unRegistryEvent() {
-    window.removeEventListener("resize", this.onWindowResize);
-    this.container.removeEventListener("click", this.onClick);
-    this.container.removeEventListener("pointerover", this.onPointerover);
-    this.container.removeEventListener("pointermove", this.onPointermove);
-    this.container.removeEventListener("pointerleave", this.onPointerleave);
-  }
-  /**
-   * 设置纵向旋转角度
-   * @param polar 弧度
-   */
-  setPolarAngle(polar, duration = 500) {
-    return timeoutPromise(
-      new Promise((resolve) => {
-        const start = { polar: this.control.getPolarAngle() };
-        const end = { polar };
-        const tween = new Tween(start, this.tweenGroup).to(end, duration).onUpdate(() => {
-          this.control.maxPolarAngle = start.polar;
-          this.control.minPolarAngle = start.polar;
-          this.control.update();
-        }).onComplete(() => {
-          this.control.enabled = true;
-          this.tweenGroup.remove(tween);
-          resolve(true);
-        }).onStart(() => {
-          this.control.enabled = false;
-        }).start();
-      }),
-      duration + 500
-    );
-  }
-  getCameraLookAt() {
-    return new Vector3().subVectors(this.control.target, this.camera.position);
-  }
-  /**
-   * 按照一个中心点设置相机的放大缩小
-   * @param zoom
-   * @param center
-   * @returns
-   */
-  setZoom(zoom, center2, duration = 500) {
-    return timeoutPromise(
-      new Promise((resolve) => {
-        const start = {
-          zoom: this.camera.zoom,
-          target: this.control.target.clone()
-        };
-        const lookAtVector = this.getCameraLookAt();
-        const tween = new Tween(start, this.tweenGroup).to(
-          {
-            zoom,
-            target: center2
-          },
-          duration
-        ).onUpdate(() => {
-          this.camera.position.copy(start.target.clone().sub(lookAtVector));
-          this.control.target.copy(start.target);
-          this.camera.zoom = start.zoom;
-          this.control.update();
-        }).onComplete(() => {
-          this.tweenGroup.remove(tween);
-          this.control.enabled = true;
-          resolve(true);
-        }).onStart(() => {
-          this.control.enabled = false;
-        }).start();
-      }),
-      duration + 500
-    );
-  }
-  /**
-   * 放大相机到物体占全屏
-   * @param object
-   * @param padding
-   * @param duration
-   * @returns
-   */
-  fitCameraToObject(object, padding = [20, 20, 20, 20], duration = 500) {
-    const [top, right, bottom, left] = padding;
-    const { clientWidth, clientHeight } = this.container;
-    const boundingBox = new Box3().setFromObject(object);
-    const { max, min } = boundingBox;
-    const max2d = vector3ToDevice(max, this.camera, clientWidth, clientHeight);
-    const min2d = vector3ToDevice(min, this.camera, clientWidth, clientHeight);
-    const boundingBox2d = new Box2().setFromPoints([
-      new Vector2(max2d.x, max2d.y),
-      new Vector2(min2d.x, min2d.y)
-    ]);
-    const size = boundingBox2d.getSize(new Vector2());
-    const xScale = (clientWidth - right - left) / size.x;
-    const yScale = (clientHeight - top - bottom) / size.y;
-    const scale = Math.min(xScale, yScale);
-    const center2 = new Vector3((max.x + min.x) / 2, (max.y + min.y) / 2, max.z);
-    return this.setZoom(scale * this.camera.zoom, center2, duration);
-  }
-  fitCameraToGround(padding = [20, 20, 20, 20], duration = 500) {
-    var _a;
-    const ground = (_a = this.currentFloor) == null ? void 0 : _a.ground;
-    if (ground) {
-      return this.fitCameraToObject(ground, padding, duration);
-    } else {
-      return Promise.resolve(false);
-    }
-  }
-  /**
-   * 修改相机位置
-   * @param position 修改后的相机的位置
-   * @param duration 动画持续时间
-   */
-  setCameraPosition(position, duration) {
-    return timeoutPromise(
-      new Promise((resolve) => {
-        const start = this.camera.position.clone();
-        const lookAtVector = this.getCameraLookAt();
-        const tween = new Tween(start, this.tweenGroup).to(position, duration).onUpdate(() => {
-          this.camera.position.copy(start);
-          this.control.target.copy(position.clone().add(lookAtVector));
-        }).onComplete(() => {
-          this.tweenGroup.remove(tween);
-          this.control.update();
-          this.control.enabled = true;
-          resolve(true);
-        }).onStart(() => {
-          this.control.enabled = false;
-        }).start();
-      }),
-      duration + 500
-    );
-  }
-  render() {
-    this.renderer.render(this.scene, this.camera);
-    this.dispatchEvent({ type: "update" });
-    this.timer.requestAnimationFrame(() => {
-      this.render();
-    });
-    this.tweenGroup.update();
-  }
-  dispose() {
-    this.tweenGroup.getAll().forEach((item) => item.stop());
-    this.tweenGroup.removeAll();
-    this.unRegistryEvent();
-    this.container.removeChild(this.renderer.domElement);
-    this.timer.dispose();
-    this.renderer.dispose();
-    this.lights.children.forEach(
-      (light) => light.dispose()
-    );
-    dispose(this.scene);
-  }
-};
-
-// src/config.ts
-import { merge } from "lodash";
-var defaultConfig = {
-  apiDomain: "",
-  apiInfo: {},
-  apiPath: {
-    floorGraphic: "/api/inception-map/floor/get",
-    floorRange: "/api/inception-map/range/get"
-  },
-  heatMap: {
-    radius: 50,
-    gradient: {
-      0: "#8F9FCD",
-      0.5: "#6284FF",
-      1: "#F95D5D"
-    }
-  },
-  useFloorCache: true,
-  control: {
-    maxPolar: 1.2
-  },
-  svg: {
-    circle: {
-      radius: "2",
-      fill: "#EFF4FB"
-    },
-    line: {
-      stroke: "#EFF4FB"
-    }
-  }
-};
-function getConfig(config) {
-  return merge({}, defaultConfig, config);
-}
-
-// src/elements/graphic.ts
-import {
-  Object3D as Object3D2,
-  ExtrudeGeometry,
-  MeshStandardMaterial,
-  Mesh,
-  Color as Color3,
-  Box3 as Box32,
-  LineSegments,
-  EdgesGeometry,
-  LineBasicMaterial,
-  Vector3 as Vector32
-} from "three";
-import { merge as merge2 } from "lodash";
-var defaultOptions = {
-  id: "",
-  // 图形id
-  height: 0.1,
-  // 图形高度
-  airHeight: 0,
-  // 悬空高度
-  area: 0,
-  // 面积
-  group: "",
-  // 分组
-  fillColor: "#EFF4FB",
-  // 颜色
-  strokeColor: "#ffffff",
-  // 边框
-  fillOpacity: 1,
-  // 透明度
-  strokeOpacity: 1,
-  // 描边透明度
-  doors: [],
-  // 门配置
-  locked: false,
-  visible: true,
-  geometry: {
-    type: "polygon",
-    cds: [],
-    curveCpt: [],
-    curveIndex: []
-  },
-  layerType: "",
-  zIndex: 0
-};
-var Graphic = class extends Object3D2 {
-  constructor(context, options) {
-    super();
-    this.context = context;
-    __publicField(this, "geometry");
-    __publicField(this, "material");
-    __publicField(this, "mesh");
-    __publicField(this, "line");
-    __publicField(this, "options");
-    this.options = proxyOptions(merge2({}, defaultOptions, options), this);
-    this.init();
-    this.visible = this.options.visible;
-    this.addEventListener("change-fillColor", ({ value }) => {
-      this.material.color = new Color3(value);
-    });
-    this.addEventListener("change-fillOpacity", ({ value }) => {
-      this.material.opacity = value;
-    });
-    this.addEventListener("change-height", ({ value }) => {
-      this.dispose();
-      this.init();
-    });
-    this.addEventListener("change-strokeColor", ({ value }) => {
-      this.line.material.color = new Color3(value);
-    });
-    this.addEventListener("change-strokeOpacity", ({ value }) => {
-      this.line.material.opacity = value;
-    });
-    this.addEventListener("change-airHeight", ({ value }) => {
-      this.position.z = value;
-    });
-    this.addEventListener("change-visible", ({ value }) => {
-      this.visible = value;
-    });
-  }
-  getCenter() {
-    const center2 = new Vector32();
-    const box = new Box32();
-    box.setFromObject(this);
-    box.getCenter(center2);
-    return center2;
-  }
-  getSize() {
-    const box = new Box32();
-    const size = new Vector32();
-    box.setFromObject(this);
-    box.getSize(size);
-    return size;
-  }
-  init() {
-    this.geometry = this.initGeometry();
-    this.material = this.initMaterial();
-    this.mesh = this.initMesh();
-    this.mesh.position.z = this.options.airHeight + this.options.height / 2;
-    this.mesh.castShadow = true;
-    this.add(this.mesh);
-    this.line = this.createBorder();
-    this.add(this.line);
-  }
-  initGeometry() {
-    const shape = initShape(this.options.geometry.cds[0]);
-    const geometry = new ExtrudeGeometry(shape, {
-      steps: 1,
-      bevelEnabled: false,
-      depth: this.options.height,
-      curveSegments: 4
-    });
-    return geometry;
-  }
-  initMaterial() {
-    const material = new MeshStandardMaterial({
-      color: this.options.fillColor,
-      roughness: 1,
-      transparent: true,
-      opacity: this.options.fillOpacity,
-      depthWrite: true
-    });
-    return material;
-  }
-  initLineMaterial() {
-    const lineMaterial = new LineBasicMaterial({
-      color: this.options.strokeColor,
-      opacity: this.options.strokeOpacity,
-      transparent: true,
-      depthWrite: true
-    });
-    return lineMaterial;
-  }
-  initMesh() {
-    return new Mesh(this.geometry, this.material);
-  }
-  createBorder() {
-    const material = this.initLineMaterial();
-    const geometry = new EdgesGeometry(this.geometry);
-    const line = new LineSegments(geometry, material);
-    return line;
-  }
-  raycast(raycaster) {
-    if (!this.visible) {
-      return false;
-    }
-    const intersects = raycaster.intersectObject(this.mesh);
-    if (intersects[0]) {
-      const position = intersects[0].point;
-      return position;
-    }
-    return false;
-  }
-  dispose() {
-    dispose(this);
-    this.clear();
+  dispose() {
+    dispose(this);
+    this.clear();
   }
 };
 
 // src/elements/shadow.ts
 import {
-  Object3D as Object3D3,
+  Object3D as Object3D2,
   PlaneGeometry,
   Mesh as Mesh2,
   ShadowMaterial,
-  Color as Color4,
+  Color as Color3,
   DoubleSide
 } from "three";
-var Shadow = class extends Object3D3 {
+var Shadow = class extends Object3D2 {
   constructor() {
     super();
     __publicField(this, "directionalLight");
@@ -881,7 +585,7 @@ var Shadow = class extends Object3D3 {
     this.directionalLight.shadow.camera.far = Math.max(x, y);
   }
   changeLightColor(color) {
-    this.directionalLight.color = new Color4(color);
+    this.directionalLight.color = new Color3(color);
   }
   // 创建平面白色
   initPlane(width = 1e4, height = 1e4) {
@@ -893,7 +597,7 @@ var Shadow = class extends Object3D3 {
     });
     const mesh = new Mesh2(geometry, material);
     mesh.receiveShadow = true;
-    mesh.position.z = -20;
+    mesh.position.z = -5;
     this.add(mesh);
     this.plane = mesh;
     return mesh;
@@ -913,18 +617,18 @@ var Shadow = class extends Object3D3 {
 };
 
 // src/elements/poi.ts
-import { Object3D as Object3D5 } from "three";
-import { merge as merge3 } from "lodash";
+import { Object3D as Object3D4 } from "three";
+import { merge as merge2 } from "lodash";
 
 // src/elements/overlay.ts
-import { EventDispatcher as EventDispatcher2, Vector3 as Vector34 } from "three";
-var Overlay = class extends EventDispatcher2 {
+import { Box3 as Box32, EventDispatcher, Vector3 as Vector33 } from "three";
+var Overlay = class extends EventDispatcher {
   constructor(context) {
     super();
     this.context = context;
     __publicField(this, "div");
     __publicField(this, "element");
-    __publicField(this, "position", new Vector34());
+    __publicField(this, "position", new Vector33());
     __publicField(this, "onUpdate", () => {
       const vector = this.getPosition();
       const { clientWidth, clientHeight } = this.context.container;
@@ -951,7 +655,16 @@ var Overlay = class extends EventDispatcher2 {
     this.div.style.display = visible ? display : "none";
   }
   getPosition() {
-    return this.element ? this.element.position.clone().setFromMatrixPosition(this.element.matrixWorld) : this.position;
+    if (this.element) {
+      if (typeof this.element.getPosition === "function") {
+        return this.element.getPosition();
+      }
+      const box = new Box32().setFromObject(this.element);
+      const center2 = box.getCenter(new Vector33());
+      return center2;
+    } else {
+      return this.position;
+    }
   }
   registryEvent() {
     this.context.addEventListener("update", this.onUpdate);
@@ -973,7 +686,7 @@ var defaultOptions2 = {
   level: 1,
   collision_enable: true
 };
-var Poi = class extends Object3D5 {
+var Poi = class extends Object3D4 {
   constructor(context, options) {
     super();
     this.context = context;
@@ -984,7 +697,7 @@ var Poi = class extends Object3D5 {
     __publicField(this, "_changePosition", () => {
       this.overlay.div.style.transform = `translate3d(-50%, ${this.options.icon ? "-100%" : "-50%"}, 0)`;
     });
-    this.options = proxyOptions(merge3({}, defaultOptions2, options), this);
+    this.options = proxyOptions(merge2({}, defaultOptions2, options), this);
     this.overlay = new Overlay(this.context);
     this.overlay.bindElement(this);
     this._changePosition();
@@ -1020,6 +733,9 @@ var Poi = class extends Object3D5 {
     div.style.pointerEvents = `none`;
     return div;
   }
+  getPosition() {
+    return this.position;
+  }
   initText() {
     const span = document.createElement("span");
     span.style.whiteSpace = "nowrap";
@@ -1061,11 +777,14 @@ var Poi = class extends Object3D5 {
 };
 
 // src/elements/floor.ts
-import { Object3D as Object3D8 } from "three";
+import { Object3D as Object3D7 } from "three";
+
+// src/layer/graphic-layer.ts
+import { Box3 as Box33, Vector3 as Vector34 } from "three";
 
 // src/layer/layer.ts
-import { Object3D as Object3D6 } from "three";
-var Layer = class extends Object3D6 {
+import { Object3D as Object3D5 } from "three";
+var Layer = class extends Object3D5 {
   constructor(context) {
     super();
     this.context = context;
@@ -1081,6 +800,10 @@ var GraphicLayer = class extends Layer {
   constructor(context) {
     super(context);
   }
+  getCenter() {
+    const box = new Box33().setFromObject(this);
+    return box.getCenter(new Vector34());
+  }
   createGraphic(options) {
     const graphic = new Graphic(this.context, options);
     this.add(graphic);
@@ -1214,7 +937,7 @@ var PoiLayer = class extends Layer {
 // src/elements/heatmap.ts
 import {
   MeshBasicMaterial,
-  Object3D as Object3D7,
+  Object3D as Object3D6,
   PlaneGeometry as PlaneGeometry2,
   Texture,
   DoubleSide as DoubleSide2,
@@ -1224,7 +947,7 @@ import {
 } from "three";
 import { create } from "@mars3d/heatmap.js";
 import { featureCollection as featureCollection2, point as point2, bbox, center as getCenter2 } from "@turf/turf";
-var HeatmapElement = class extends Object3D7 {
+var HeatmapElement = class extends Object3D6 {
   constructor(context) {
     super();
     this.context = context;
@@ -1308,7 +1031,7 @@ var HeatmapElement = class extends Object3D7 {
 };
 
 // src/elements/floor.ts
-var Floor = class extends Object3D8 {
+var Floor = class extends Object3D7 {
   constructor(context) {
     super();
     this.context = context;
@@ -1376,8 +1099,8 @@ var Floor = class extends Object3D8 {
 };
 
 // src/elements/base-svg.ts
-import { EventDispatcher as EventDispatcher3, Raycaster as Raycaster3, Vector2 as Vector23 } from "three";
-var BaseSvg = class extends EventDispatcher3 {
+import { EventDispatcher as EventDispatcher2, Vector3 as Vector35 } from "three";
+var BaseSvg = class extends EventDispatcher2 {
   constructor(context) {
     super();
     this.context = context;
@@ -1396,18 +1119,13 @@ var BaseSvg = class extends EventDispatcher3 {
     }
   }
   getIntersectByPointerEvent(e) {
-    var _a;
-    if (!((_a = this.context.currentFloor) == null ? void 0 : _a.ground)) {
-      return;
-    }
+    const { camera, renderer } = this.context;
     const { offsetX: x, offsetY: y } = e;
-    const point3 = new Vector23();
-    point3.x = x / this.context.container.clientWidth * 2 - 1;
-    point3.y = y / this.context.container.clientHeight * -2 + 1;
-    const raycaster = new Raycaster3();
-    raycaster.setFromCamera(point3, this.context.camera);
-    const intersects = raycaster.intersectObjects(this.context.currentFloor.ground.children, true);
-    return intersects[0];
+    const { clientWidth, clientHeight } = renderer.domElement;
+    const nx = x / clientWidth * 2 - 1;
+    const ny = 1 - y / clientHeight * 2;
+    const v = new Vector35(nx, ny, 0);
+    return v.unproject(camera);
   }
   getSvgCoordinate(vector) {
     const { camera, container } = this.context;
@@ -1443,223 +1161,823 @@ var SvgLine = class extends BaseSvg {
       if (this.points.length !== 1) {
         return;
       }
-      this.line.style.display = "block";
-      setLineStartEnd(this.line, void 0, { x: e.offsetX, y: e.offsetY });
+      this.line.style.display = "block";
+      setLineStartEnd(this.line, void 0, { x: e.offsetX, y: e.offsetY });
+    });
+    __publicField(this, "onPointerleave", () => {
+      if (this.points[1]) {
+        return;
+      }
+      this.line.style.display = "none";
+    });
+    __publicField(this, "onPointerdown", (e) => {
+      if (this.points[1]) {
+        return;
+      }
+      const point3 = this.getIntersectByPointerEvent(e);
+      if (point3) {
+        const { offsetX: x, offsetY: y } = e;
+        const circle = this.circles[this.points.length];
+        setCirclePosition(circle, x, y);
+        if (!this.points.length) {
+          setLineStartEnd(this.line, { x, y }, { x, y });
+        }
+        this.addPoint(point3);
+      }
+    });
+    const { config: { svg: { circle, line } } } = context;
+    this.circles = [createCircle(circle.radius, circle.fill), createCircle(circle.radius, circle.fill)];
+    this.line = createLine(line.stroke);
+    this.svg.appendChild(this.circles[0]);
+    this.svg.appendChild(this.circles[1]);
+    this.svg.appendChild(this.line);
+    this.registryEvent();
+  }
+  setEnable(enable) {
+    super.setEnable(enable);
+    if (enable) {
+      this.registryEvent();
+    } else {
+      this.unRegistryEvent();
+    }
+  }
+  registryEvent() {
+    this.context.container.addEventListener("pointerenter", this.onPointermove);
+    this.context.container.addEventListener("pointermove", this.onPointermove);
+    this.context.container.addEventListener("pointerleave", this.onPointerleave);
+    this.context.container.addEventListener("pointerdown", this.onPointerdown);
+    this.context.addEventListener("update", this.onUpdate);
+  }
+  unRegistryEvent() {
+    this.context.container.removeEventListener("pointerenter", this.onPointermove);
+    this.context.container.removeEventListener("pointermove", this.onPointermove);
+    this.context.container.removeEventListener("pointerleave", this.onPointerleave);
+    this.context.container.removeEventListener("pointerdown", this.onPointerdown);
+    this.context.removeEventListener("update", this.onUpdate);
+  }
+  addPoint(vector) {
+    this.points.push(vector);
+    if (this.points.length >= 2) {
+      const distance = this.calculatedDistance();
+      this.dispatchEvent({ type: "distance", distance });
+    }
+  }
+  /**
+   * 计算两个点之间的距离
+   */
+  calculatedDistance() {
+    const [{ x: x1, y: y1 }, { x: x2, y: y2 }] = this.points;
+    return Math.sqrt(__pow(x2 - x1, 2) + __pow(y2 - y1, 2));
+  }
+  dispose() {
+    super.dispose();
+    this.unRegistryEvent();
+    this.line = null;
+    this.circles = [];
+  }
+};
+
+// src/elements/svg-polygon.ts
+var SvgPolygon = class extends BaseSvg {
+  constructor(context) {
+    super(context);
+    __publicField(this, "circles", []);
+    __publicField(this, "lines", []);
+    __publicField(this, "isClose", false);
+    __publicField(this, "onUpdate", () => {
+      if (this.points.length) {
+        this.points.forEach((point3, index) => {
+          const devicePoint = this.getSvgCoordinate(point3);
+          if (this.circles[index]) {
+            setCirclePosition(this.circles[index], devicePoint.x, devicePoint.y);
+          }
+          if (index !== 0) {
+            setLineStartEnd(this.lines[index - 1], void 0, devicePoint);
+          }
+          if (this.lines[index]) {
+            setLineStartEnd(this.lines[index], devicePoint);
+          }
+        });
+      }
+    });
+    __publicField(this, "onPointermove", (e) => {
+      if (!this.lastLine || this.isClose) {
+        return;
+      }
+      this.lastLine.style.display = "block";
+      setLineStartEnd(this.lastLine, void 0, { x: e.offsetX, y: e.offsetY });
+    });
+    __publicField(this, "onPointerleave", () => {
+      if (this.isClose) {
+        return;
+      }
+      this.lastLine.style.display = "none";
+    });
+    __publicField(this, "onPointerdown", (e) => {
+      if (this.isClose) {
+        return;
+      }
+      const point3 = this.getIntersectByPointerEvent(e);
+      if (point3) {
+        const { offsetX: x, offsetY: y } = e;
+        if (this.checkAdsorb(x, y)) {
+          this.isClose = true;
+          this.addPoint(this.points[0]);
+        } else {
+          this.addPoint(point3);
+        }
+        const { circle: { fill, radius }, line: { stroke } } = this.context.config.svg;
+        if (!this.isClose) {
+          const circle = createCircle(radius, fill);
+          setCirclePosition(circle, x, y);
+          this.addCircle(circle);
+        }
+        if (this.lines.length) {
+          setLineStartEnd(this.lastLine, void 0, { x, y });
+        }
+        if (!this.isClose) {
+          const line = createLine(stroke);
+          setLineStartEnd(line, { x, y }, { x, y });
+          this.addLine(line);
+        }
+      }
+    });
+    this.registryEvent();
+  }
+  setEnable(enable) {
+    super.setEnable(enable);
+    if (enable) {
+      this.registryEvent();
+    } else {
+      this.unRegistryEvent();
+    }
+  }
+  get lastLine() {
+    return this.lines.slice(-1)[0];
+  }
+  addCircle(circle) {
+    this.circles.push(circle);
+    this.svg.appendChild(circle);
+  }
+  addLine(line) {
+    this.lines.push(line);
+    this.svg.appendChild(line);
+  }
+  registryEvent() {
+    this.context.container.addEventListener("pointerenter", this.onPointermove);
+    this.context.container.addEventListener("pointermove", this.onPointermove);
+    this.context.container.addEventListener("pointerleave", this.onPointerleave);
+    this.context.container.addEventListener("pointerdown", this.onPointerdown);
+    this.context.addEventListener("update", this.onUpdate);
+  }
+  unRegistryEvent() {
+    this.context.container.removeEventListener("pointerenter", this.onPointermove);
+    this.context.container.removeEventListener("pointermove", this.onPointermove);
+    this.context.container.removeEventListener("pointerleave", this.onPointerleave);
+    this.context.container.removeEventListener("pointerdown", this.onPointerdown);
+    this.context.removeEventListener("update", this.onUpdate);
+  }
+  /**
+   * 检测是否可以吸附
+   * 坐标点最少3个  传入的坐标点和第一个坐标的像素相差不超过5个像素
+   */
+  checkAdsorb(x, y) {
+    if (this.points.length < 3) {
+      return false;
+    }
+    const circle = this.circles[0];
+    const cx = +circle.getAttribute("cx");
+    const cy = +circle.getAttribute("cy");
+    return Math.sqrt(__pow(x - cx, 2) + __pow(y - cy, 2)) <= 5;
+  }
+  addPoint(vector) {
+    this.points.push(vector);
+    if (this.isClose) {
+      const area = this.calculatedArea();
+      this.dispatchEvent({ type: "area", area });
+    }
+  }
+  // 计算面积
+  calculatedArea() {
+    const cds = this.points.map((item) => [item.x, item.y]);
+    let area = 0;
+    const numPoints = cds.length;
+    for (let i = 0; i < numPoints; i++) {
+      const j = (i + 1) % numPoints;
+      area += cds[i][0] * cds[j][1] - cds[j][0] * cds[i][1];
+    }
+    return Math.abs(area / 2);
+  }
+  dispose() {
+    super.dispose();
+    this.unRegistryEvent();
+    this.lines = [];
+    this.circles = [];
+  }
+};
+
+// src/operations/selection/box-selection.ts
+import { Frustum } from "three";
+var BoxSelection = class extends BaseSvg {
+  constructor(context) {
+    super(context);
+    __publicField(this, "startPoint");
+    __publicField(this, "endPoint");
+    __publicField(this, "rect");
+    __publicField(this, "frustum", new Frustum());
+    __publicField(this, "onPointerDown", (e) => {
+      if (!this.enable) {
+        return;
+      }
+      const point3 = this.getIntersectByPointerEvent(e);
+      if (point3) {
+        this.startPoint = point3;
+      }
+      this.endPoint = void 0;
     });
-    __publicField(this, "onPointerleave", () => {
-      if (this.points[1]) {
+    __publicField(this, "onPointerMove", (e) => {
+      if (!this.enable || !this.startPoint) {
         return;
       }
-      this.line.style.display = "none";
+      const point3 = this.getIntersectByPointerEvent(e);
+      if (point3) {
+        this.endPoint = point3;
+      }
     });
-    __publicField(this, "onPointerdown", (e) => {
-      if (this.points[1]) {
+    __publicField(this, "onPointerUp", (e) => {
+      if (!this.enable) {
         return;
       }
-      const intersect = this.getIntersectByPointerEvent(e);
-      if (intersect == null ? void 0 : intersect.point) {
-        const { offsetX: x, offsetY: y } = e;
-        const circle = this.circles[this.points.length];
-        setCirclePosition(circle, x, y);
-        if (!this.points.length) {
-          setLineStartEnd(this.line, { x, y }, { x, y });
+      const point3 = this.getIntersectByPointerEvent(e);
+      if (point3) {
+        this.endPoint = point3;
+      }
+      this.doSelect();
+      this.startPoint = void 0;
+    });
+    __publicField(this, "onUpdate", () => {
+      if (this.startPoint) {
+        const startPoint = this.getSvgCoordinate(this.startPoint);
+        let endPoint = __spreadValues({}, startPoint);
+        if (this.endPoint) {
+          endPoint = this.getSvgCoordinate(this.endPoint);
         }
-        this.addPoint(intersect.point);
+        const leftTop = { x: Math.min(startPoint.x, endPoint.x), y: Math.min(startPoint.y, endPoint.y) };
+        const width = Math.abs(endPoint.x - startPoint.x);
+        const height = Math.abs(endPoint.y - startPoint.y);
+        setRectPosition(this.rect, leftTop.x, leftTop.y, width, height);
       }
     });
-    const { config: { svg: { circle, line } } } = context;
-    this.circles = [createCircle(circle.radius, circle.fill), createCircle(circle.radius, circle.fill)];
-    this.line = createLine(line.stroke);
-    this.svg.appendChild(this.circles[0]);
-    this.svg.appendChild(this.circles[1]);
-    this.svg.appendChild(this.line);
+    const { config: { selectBox: { fill, stroke } } } = context;
+    this.rect = createRect(stroke, fill);
+    this.svg.appendChild(this.rect);
     this.registryEvent();
   }
   setEnable(enable) {
     super.setEnable(enable);
-    if (enable) {
-      this.registryEvent();
-    } else {
-      this.unRegistryEvent();
-    }
+    setRectPosition(this.rect, 0, 0, 0, 0);
   }
   registryEvent() {
-    this.context.container.addEventListener("pointerenter", this.onPointermove);
-    this.context.container.addEventListener("pointermove", this.onPointermove);
-    this.context.container.addEventListener("pointerleave", this.onPointerleave);
-    this.context.container.addEventListener("pointerdown", this.onPointerdown);
+    this.context.container.addEventListener("pointerdown", this.onPointerDown);
+    this.context.container.addEventListener("pointermove", this.onPointerMove);
+    this.context.container.addEventListener("pointerup", this.onPointerUp);
     this.context.addEventListener("update", this.onUpdate);
   }
   unRegistryEvent() {
-    this.context.container.removeEventListener("pointerenter", this.onPointermove);
-    this.context.container.removeEventListener("pointermove", this.onPointermove);
-    this.context.container.removeEventListener("pointerleave", this.onPointerleave);
-    this.context.container.removeEventListener("pointerdown", this.onPointerdown);
+    this.context.container.removeEventListener("pointerdown", this.onPointerDown);
+    this.context.container.removeEventListener("pointermove", this.onPointerMove);
+    this.context.container.removeEventListener("pointerup", this.onPointerUp);
     this.context.removeEventListener("update", this.onUpdate);
   }
-  addPoint(vector) {
-    this.points.push(vector);
-    if (this.points.length >= 2) {
-      const distance = this.calculatedDistance();
-      this.dispatchEvent({ type: "distance", distance });
+  doSelect() {
+    if (this.startPoint && this.endPoint) {
+      const dis = this.startPoint.distanceTo(this.endPoint);
+      if (dis < 0.1) {
+        return;
+      }
+      const { context: { camera, container: { clientWidth: w, clientHeight: h } } } = this;
+      const startDevice = vector3ToDevice(this.startPoint, camera, w, h);
+      const endDevice = vector3ToDevice(this.endPoint, camera, w, h);
+      const leftTop = { x: Math.min(startDevice.x, endDevice.x), y: Math.min(startDevice.y, endDevice.y) };
+      const rightBottom = { x: Math.max(startDevice.x, endDevice.x), y: Math.max(startDevice.y, endDevice.y) };
+      const list = this.searchMapInFrustum(leftTop, rightBottom);
+      this.dispatchEvent({ type: "selected", list });
     }
   }
-  /**
-   * 计算两个点之间的距离
-   */
-  calculatedDistance() {
-    const [{ x: x1, y: y1 }, { x: x2, y: y2 }] = this.points;
-    return Math.sqrt(__pow(x2 - x1, 2) + __pow(y2 - y1, 2));
+  searchMapInFrustum(leftTop, rightBottom) {
+    var _a;
+    const { context } = this;
+    return ((_a = context.currentFloor) == null ? void 0 : _a.graphicLayer.children.filter((item) => {
+      return item instanceof Graphic && this.searchChildInFrustum(item, leftTop, rightBottom);
+    })) || [];
+  }
+  searchChildInFrustum(object, leftTop, rightBottom) {
+    const { context: { camera, container: { clientWidth: w, clientHeight: h } } } = this;
+    if (!object)
+      return false;
+    if (!object.mesh.geometry.boundingBox) {
+      object.mesh.geometry.computeBoundingBox();
+    }
+    const box = object.mesh.geometry.boundingBox;
+    if (!box) {
+      return false;
+    }
+    const { min, max } = box;
+    const minDevice = vector3ToDevice(min, camera, w, h);
+    const maxDevice = vector3ToDevice(max, camera, w, h);
+    if (!isContain(minDevice, leftTop, rightBottom)) {
+      return false;
+    }
+    if (!isContain(maxDevice, leftTop, rightBottom)) {
+      return false;
+    }
+    return true;
   }
   dispose() {
-    super.dispose();
     this.unRegistryEvent();
-    this.line = null;
-    this.circles = [];
   }
 };
 
-// src/elements/svg-polygon.ts
-var SvgPolygon = class extends BaseSvg {
+// src/operations/selection/selection.ts
+var Selection = class extends EventDispatcher3 {
   constructor(context) {
-    super(context);
-    __publicField(this, "circles", []);
-    __publicField(this, "lines", []);
-    __publicField(this, "isClose", false);
-    __publicField(this, "onUpdate", () => {
-      if (this.points.length) {
-        this.points.forEach((point3, index) => {
-          const devicePoint = this.getSvgCoordinate(point3);
-          if (this.circles[index]) {
-            setCirclePosition(this.circles[index], devicePoint.x, devicePoint.y);
-          }
-          if (index !== 0) {
-            setLineStartEnd(this.lines[index - 1], void 0, devicePoint);
-          }
-          if (this.lines[index]) {
-            setLineStartEnd(this.lines[index], devicePoint);
-          }
-        });
+    super();
+    this.context = context;
+    __publicField(this, "_list", /* @__PURE__ */ new Set());
+    __publicField(this, "boxSelection");
+    __publicField(this, "prevPanStatus");
+    __publicField(this, "onPointerDown", (e) => {
+      const { graphics } = this.context.getGraphicsByDeviceXy(e.offsetX, e.offsetY);
+      if (!e.ctrlKey) {
+        this._list.clear();
       }
+      graphics.forEach((item) => this._list.add(item));
+      this.selectEnd();
     });
-    __publicField(this, "onPointermove", (e) => {
-      if (!this.lastLine || this.isClose) {
-        return;
+    __publicField(this, "onKeyDown", (e) => {
+      if (e.key === "Control") {
+        this.boxSelection.setEnable(true);
+        this.prevPanStatus = this.context.control.enablePan;
+        this.context.control.enablePan = false;
       }
-      this.lastLine.style.display = "block";
-      setLineStartEnd(this.lastLine, void 0, { x: e.offsetX, y: e.offsetY });
     });
-    __publicField(this, "onPointerleave", () => {
-      if (this.isClose) {
-        return;
+    __publicField(this, "onKeyUp", (e) => {
+      if (e.key === "Control") {
+        this.boxSelection.setEnable(false);
+        this.context.control.enablePan = !!this.prevPanStatus;
       }
-      this.lastLine.style.display = "none";
     });
-    __publicField(this, "onPointerdown", (e) => {
-      if (this.isClose) {
+    __publicField(this, "onBoxSelected", ({ list }) => {
+      this._list.clear();
+      list.forEach((item) => {
+        this._list.add(item);
+      });
+      this.selectEnd();
+    });
+    this.boxSelection = new BoxSelection(context);
+    this.boxSelection.setEnable(false);
+    this.registryEvent();
+  }
+  get list() {
+    return this._list;
+  }
+  selectEnd() {
+    this.dispatchEvent({ type: "select", graphics: [...this._list] });
+  }
+  registryEvent() {
+    this.context.container.addEventListener("pointerdown", this.onPointerDown);
+    window.addEventListener("keydown", this.onKeyDown);
+    window.addEventListener("keyup", this.onKeyUp);
+    this.boxSelection.addEventListener("selected", this.onBoxSelected);
+  }
+  unRegistryEvent() {
+    this.context.container.removeEventListener("pointerdown", this.onPointerDown);
+    window.removeEventListener("keydown", this.onKeyDown);
+    window.removeEventListener("keyup", this.onKeyUp);
+    this.boxSelection.removeEventListener("selected", this.onBoxSelected);
+  }
+  dispose() {
+    this.unRegistryEvent();
+  }
+};
+
+// src/operations/hover/hover-helper.ts
+import { EventDispatcher as EventDispatcher4 } from "three";
+var HoverHelper = class extends EventDispatcher4 {
+  constructor(context) {
+    super();
+    this.context = context;
+    __publicField(this, "curGraphics", /* @__PURE__ */ new Set());
+    __publicField(this, "timer", new Timer());
+    __publicField(this, "graphicTimerMap", /* @__PURE__ */ new Map());
+    __publicField(this, "onPointerMove", ({ graphics }) => {
+      if (!graphics.length && this.curGraphics.size) {
+        this.curGraphics.clear();
+        this.handleHoverGraphicsChange();
         return;
       }
-      const intersect = this.getIntersectByPointerEvent(e);
-      if (intersect == null ? void 0 : intersect.point) {
-        const { offsetX: x, offsetY: y } = e;
-        if (this.checkAdsorb(x, y)) {
-          this.isClose = true;
-          this.addPoint(this.points[0]);
-        } else {
-          this.addPoint(intersect.point);
+      const { time } = this.context.config.hover;
+      graphics.forEach((graphic) => {
+        if (this.graphicTimerMap.get(graphic)) {
+          return;
         }
-        const { circle: { fill, radius }, line: { stroke } } = this.context.config.svg;
-        if (!this.isClose) {
-          const circle = createCircle(radius, fill);
-          setCirclePosition(circle, x, y);
-          this.addCircle(circle);
+        if (this.curGraphics.has(graphic)) {
+          return;
         }
-        if (this.lines.length) {
-          setLineStartEnd(this.lastLine, void 0, { x, y });
+        const timer = this.timer.setTimeout(() => {
+          this.curGraphics.add(graphic);
+          this.handleHoverGraphicsChange();
+        }, time);
+        this.graphicTimerMap.set(graphic, timer);
+      });
+      this.graphicTimerMap.forEach((timer, graphic) => {
+        if (!graphics.includes(graphic)) {
+          this.timer.clearTimeout(timer);
+          this.graphicTimerMap.delete(graphic);
         }
-        if (!this.isClose) {
-          const line = createLine(stroke);
-          setLineStartEnd(line, { x, y }, { x, y });
-          this.addLine(line);
+      });
+      const size = this.curGraphics.size;
+      this.curGraphics.forEach((graphic) => {
+        if (!graphics.includes(graphic)) {
+          this.curGraphics.delete(graphic);
         }
+      });
+      if (size !== this.curGraphics.size) {
+        this.handleHoverGraphicsChange();
       }
     });
+    __publicField(this, "onPointerLevel", () => {
+      this.curGraphics.clear();
+      this.handleHoverGraphicsChange();
+    });
     this.registryEvent();
   }
-  setEnable(enable) {
-    super.setEnable(enable);
-    if (enable) {
-      this.registryEvent();
-    } else {
-      this.unRegistryEvent();
+  handleHoverGraphicsChange(graphics = this.curGraphics) {
+    this.dispatchEvent({ type: "hover-change", graphics: Array.from(this.curGraphics) });
+  }
+  registryEvent() {
+    this.context.addEventListener("pointer-over", this.onPointerMove);
+    this.context.addEventListener("pointer-move", this.onPointerMove);
+    this.context.addEventListener("pointer-level", this.onPointerLevel);
+  }
+  unRegistryEvent() {
+    this.context.removeEventListener("pointer-over", this.onPointerMove);
+    this.context.removeEventListener("pointer-move", this.onPointerMove);
+    this.context.removeEventListener("pointer-level", this.onPointerLevel);
+  }
+  dispose() {
+    this.unRegistryEvent();
+    this.timer.dispose();
+  }
+};
+
+// src/context.ts
+var Context = class extends EventDispatcher5 {
+  // zoom=1的时候，100M对应的像素个数
+  constructor(container, config) {
+    super();
+    this.container = container;
+    this.config = config;
+    __publicField(this, "scene", initScene());
+    __publicField(this, "renderer", initRenderer());
+    __publicField(this, "camera");
+    __publicField(this, "control");
+    __publicField(this, "lights", initLight());
+    // 管理任务，防止内存泄漏
+    __publicField(this, "timer", new Timer());
+    __publicField(this, "tweenGroup", new TweenGroup());
+    __publicField(this, "currentFloor");
+    __publicField(this, "selection");
+    __publicField(this, "hoverHelper");
+    __publicField(this, "basicRatio");
+    __publicField(this, "onWindowResize", () => {
+      const { container, camera, renderer } = this;
+      const { clientWidth: w, clientHeight: h } = container;
+      camera.left = -w / 2;
+      camera.right = w / 2;
+      camera.top = h / 2;
+      camera.bottom = -h / 2;
+      camera.updateProjectionMatrix();
+      renderer.setSize(window.innerWidth, window.innerHeight);
+    });
+    __publicField(this, "onClick", (e) => {
+      const { graphics, position } = this.getGraphicsByDeviceXy(e.offsetX, e.offsetY);
+      if (graphics.length) {
+        this.dispatchEvent({
+          type: "graphic-click",
+          graphics,
+          position
+        });
+      }
+      const pois = this.getPoisByDeviceXy(e.clientX, e.clientY);
+      if (pois.length) {
+        this.dispatchEvent({ type: "poi-click", pois });
+      }
+    });
+    __publicField(this, "onPointerover", (e) => {
+      const { graphics, position } = this.getGraphicsByDeviceXy(e.offsetX, e.offsetY);
+      const pois = this.getPoisByDeviceXy(e.clientX, e.clientY);
+      this.dispatchEvent({ type: "pointer-over", graphics, pois, position });
+    });
+    __publicField(this, "onPointermove", (e) => {
+      const { graphics, position } = this.getGraphicsByDeviceXy(e.offsetX, e.offsetY);
+      const pois = this.getPoisByDeviceXy(e.clientX, e.clientY);
+      this.dispatchEvent({ type: "pointer-move", graphics, pois, position });
+    });
+    __publicField(this, "onPointerleave", () => {
+      this.dispatchEvent({ type: "pointer-level" });
+    });
+    __publicField(this, "onSelectionSelect", ({ graphics }) => {
+      this.dispatchEvent({ type: "select-graphic", graphics });
+    });
+    __publicField(this, "onHoverChange", ({ graphics }) => {
+      this.dispatchEvent({ type: "hover", graphics });
+    });
+    this.container.style.position = "relative";
+    this.container.style.overflow = "hidden";
+    this.init();
+    this.selection = new Selection(this);
+    this.hoverHelper = new HoverHelper(this);
+    this.registryEvent();
+  }
+  init() {
+    const { clientWidth: w, clientHeight: h } = this.container;
+    this.camera = initCamera(w, h);
+    this.renderer.setSize(w, h);
+    this.control = initControl(this.camera, this.renderer.domElement);
+    this.container.appendChild(this.renderer.domElement);
+    this.scene.add(this.lights);
+    this.basicRatio = this.getRatio();
+    this.control.addEventListener("change", () => {
+      var _a;
+      const polarAngle = this.control.getPolarAngle();
+      (_a = this.currentFloor) == null ? void 0 : _a.setShadowOpacity(polarAngle / this.config.control.maxPolar);
+      this.dispatchEvent({ type: "change-ratio", px: (this.basicRatio || 0) * this.camera.zoom });
+    });
+  }
+  /**
+   * 获取两个点之间的像素数
+   */
+  getRatio(point1 = new Vector37(0, 0, 0), point22 = new Vector37(100, 0, 0)) {
+    const { clientWidth, clientHeight } = this.container;
+    const device1 = vector3ToDevice(point1, this.camera, clientWidth, clientHeight);
+    const device2 = vector3ToDevice(point22, this.camera, clientWidth, clientHeight);
+    return Math.ceil(Math.sqrt(__pow(device2.x - device1.x, 2) + __pow(device2.y - device1.y, 2)));
+  }
+  changeAmbientLightColor(color) {
+    this.lights.children.forEach((item) => {
+      if (item instanceof AmbientLight2) {
+        item.color = new Color4(color);
+      }
+    });
+  }
+  switchFloor(floor) {
+    var _a;
+    if (this.currentFloor) {
+      this.scene.remove(this.currentFloor);
+      this.currentFloor.dispose();
+    }
+    this.currentFloor = floor;
+    this.scene.add(floor);
+    const position = (_a = floor.graphicLayer) == null ? void 0 : _a.getCenter();
+    if (position) {
+      this.lights.position.x = position.x;
+      this.lights.position.y = position.y;
     }
   }
-  get lastLine() {
-    return this.lines.slice(-1)[0];
-  }
-  addCircle(circle) {
-    this.circles.push(circle);
-    this.svg.appendChild(circle);
+  /**
+   * 获取屏幕坐标对应的graphic
+   * @param x
+   * @param y
+   * @returns
+   */
+  getGraphicsByDeviceXy(x, y) {
+    var _a;
+    const point3 = new Vector23();
+    point3.x = x / this.container.clientWidth * 2 - 1;
+    point3.y = y / this.container.clientHeight * -2 + 1;
+    const raycaster = new Raycaster3();
+    raycaster.setFromCamera(point3, this.camera);
+    const res = (_a = this.currentFloor) == null ? void 0 : _a.graphicLayer.getGraphicByRaycaster(raycaster);
+    return res || { graphics: [], position: null };
   }
-  addLine(line) {
-    this.lines.push(line);
-    this.svg.appendChild(line);
+  /**
+   * 获取屏幕坐标对应的poi
+   * @param x
+   * @param y
+   * @returns
+   */
+  getPoisByDeviceXy(x, y) {
+    var _a;
+    const pois = (_a = this.currentFloor) == null ? void 0 : _a.poiLayer.getPoiByDeviceXy(x, y);
+    return pois || [];
   }
   registryEvent() {
-    this.context.container.addEventListener("pointerenter", this.onPointermove);
-    this.context.container.addEventListener("pointermove", this.onPointermove);
-    this.context.container.addEventListener("pointerleave", this.onPointerleave);
-    this.context.container.addEventListener("pointerdown", this.onPointerdown);
-    this.context.addEventListener("update", this.onUpdate);
+    window.addEventListener("resize", this.onWindowResize);
+    this.container.addEventListener("click", this.onClick);
+    this.container.addEventListener("pointerover", this.onPointerover);
+    this.container.addEventListener("pointermove", this.onPointermove);
+    this.container.addEventListener("pointerleave", this.onPointerleave);
+    this.selection.addEventListener("select", this.onSelectionSelect);
+    this.hoverHelper.addEventListener("hover-change", this.onHoverChange);
   }
   unRegistryEvent() {
-    this.context.container.removeEventListener("pointerenter", this.onPointermove);
-    this.context.container.removeEventListener("pointermove", this.onPointermove);
-    this.context.container.removeEventListener("pointerleave", this.onPointerleave);
-    this.context.container.removeEventListener("pointerdown", this.onPointerdown);
-    this.context.removeEventListener("update", this.onUpdate);
+    window.removeEventListener("resize", this.onWindowResize);
+    this.container.removeEventListener("click", this.onClick);
+    this.container.removeEventListener("pointerover", this.onPointerover);
+    this.container.removeEventListener("pointermove", this.onPointermove);
+    this.container.removeEventListener("pointerleave", this.onPointerleave);
+    this.selection.removeEventListener("select", this.onSelectionSelect);
+    this.hoverHelper.removeEventListener("hover-change", this.onHoverChange);
   }
   /**
-   * 检测是否可以吸附
-   * 坐标点最少3个  传入的坐标点和第一个坐标的像素相差不超过5个像素
+   * 设置纵向旋转角度
+   * @param polar 弧度
    */
-  checkAdsorb(x, y) {
-    if (this.points.length < 3) {
-      return false;
-    }
-    const circle = this.circles[0];
-    const cx = +circle.getAttribute("cx");
-    const cy = +circle.getAttribute("cy");
-    return Math.sqrt(__pow(x - cx, 2) + __pow(y - cy, 2)) <= 5;
+  setPolarAngle(polar, duration = 500) {
+    return timeoutPromise(
+      new Promise((resolve) => {
+        const start = { polar: this.control.getPolarAngle() };
+        const end = { polar };
+        const tween = new Tween(start, this.tweenGroup).to(end, duration).onUpdate(() => {
+          this.control.maxPolarAngle = start.polar;
+          this.control.minPolarAngle = start.polar;
+          this.control.update();
+        }).onComplete(() => {
+          this.control.enabled = true;
+          this.tweenGroup.remove(tween);
+          resolve(true);
+        }).onStart(() => {
+          this.control.enabled = false;
+        }).start();
+      }),
+      duration + 500
+    );
   }
-  addPoint(vector) {
-    this.points.push(vector);
-    if (this.isClose) {
-      const area = this.calculatedArea();
-      this.dispatchEvent({ type: "area", area });
-    }
+  getCameraLookAt() {
+    return new Vector37().subVectors(this.control.target, this.camera.position);
   }
-  // 计算面积
-  calculatedArea() {
-    const cds = this.points.map((item) => [item.x, item.y]);
-    let area = 0;
-    const numPoints = cds.length;
-    for (let i = 0; i < numPoints; i++) {
-      const j = (i + 1) % numPoints;
-      area += cds[i][0] * cds[j][1] - cds[j][0] * cds[i][1];
+  /**
+   * 按照一个中心点设置相机的放大缩小
+   * @param zoom
+   * @param center
+   * @returns
+   */
+  setZoom(zoom, center2, duration = 500) {
+    return timeoutPromise(
+      new Promise((resolve) => {
+        const start = {
+          zoom: this.camera.zoom,
+          target: this.control.target.clone()
+        };
+        const lookAtVector = this.getCameraLookAt();
+        const tween = new Tween(start, this.tweenGroup).to(
+          {
+            zoom,
+            target: center2
+          },
+          duration
+        ).onUpdate(() => {
+          this.camera.position.copy(start.target.clone().sub(lookAtVector));
+          this.control.target.copy(start.target);
+          this.camera.zoom = start.zoom;
+          this.control.update();
+        }).onComplete(() => {
+          this.tweenGroup.remove(tween);
+          this.control.enabled = true;
+          resolve(true);
+        }).onStart(() => {
+          this.control.enabled = false;
+        }).start();
+      }),
+      duration + 500
+    );
+  }
+  /**
+   * 放大相机到物体占全屏
+   * @param object
+   * @param padding
+   * @param duration
+   * @returns
+   */
+  fitCameraToObject(object, padding = [20, 20, 20, 20], duration = 500) {
+    const [top, right, bottom, left] = padding;
+    const { clientWidth, clientHeight } = this.container;
+    const boundingBox = new Box34().setFromObject(object);
+    const { max, min } = boundingBox;
+    const max2d = vector3ToDevice(max, this.camera, clientWidth, clientHeight);
+    const min2d = vector3ToDevice(min, this.camera, clientWidth, clientHeight);
+    const boundingBox2d = new Box2().setFromPoints([
+      new Vector23(max2d.x, max2d.y),
+      new Vector23(min2d.x, min2d.y)
+    ]);
+    const size = boundingBox2d.getSize(new Vector23());
+    const xScale = (clientWidth - right - left) / size.x;
+    const yScale = (clientHeight - top - bottom) / size.y;
+    const scale = Math.min(xScale, yScale);
+    const center2 = new Vector37((max.x + min.x) / 2, (max.y + min.y) / 2, max.z);
+    return this.setZoom(scale * this.camera.zoom, center2, duration);
+  }
+  fitCameraToGround(padding = [20, 20, 20, 20], duration = 500) {
+    if (this.currentFloor) {
+      return this.fitCameraToObject(this.currentFloor.graphicLayer, padding, duration);
+    } else {
+      return Promise.resolve(false);
     }
-    return Math.abs(area / 2);
+  }
+  /**
+   * 修改相机位置
+   * @param position 修改后的相机的位置
+   * @param duration 动画持续时间
+   */
+  setCameraPosition(position, duration) {
+    return timeoutPromise(
+      new Promise((resolve) => {
+        const start = this.camera.position.clone();
+        const lookAtVector = this.getCameraLookAt();
+        const tween = new Tween(start, this.tweenGroup).to(position, duration).onUpdate(() => {
+          this.camera.position.copy(start);
+          this.control.target.copy(position.clone().add(lookAtVector));
+        }).onComplete(() => {
+          this.tweenGroup.remove(tween);
+          this.control.update();
+          this.control.enabled = true;
+          resolve(true);
+        }).onStart(() => {
+          this.control.enabled = false;
+        }).start();
+      }),
+      duration + 500
+    );
+  }
+  render() {
+    this.renderer.render(this.scene, this.camera);
+    this.dispatchEvent({ type: "update" });
+    this.timer.requestAnimationFrame(() => {
+      this.render();
+    });
+    this.tweenGroup.update();
   }
   dispose() {
-    super.dispose();
+    this.selection.dispose();
+    this.hoverHelper.dispose();
+    this.tweenGroup.getAll().forEach((item) => item.stop());
+    this.tweenGroup.removeAll();
     this.unRegistryEvent();
-    this.lines = [];
-    this.circles = [];
+    this.container.removeChild(this.renderer.domElement);
+    this.timer.dispose();
+    this.renderer.dispose();
+    this.lights.children.forEach(
+      (light) => light.dispose()
+    );
+    dispose(this.scene);
+  }
+};
+
+// src/config.ts
+import { merge as merge3 } from "lodash";
+var defaultConfig = {
+  apiDomain: "",
+  apiInfo: {},
+  apiPath: {
+    floorGraphic: "/api/inception-map/floor/get",
+    floorRange: "/api/inception-map/range/get"
+  },
+  heatMap: {
+    radius: 50,
+    gradient: {
+      0: "#8F9FCD",
+      0.5: "#6284FF",
+      1: "#F95D5D"
+    }
+  },
+  useFloorCache: true,
+  control: {
+    maxPolar: 1.2
+  },
+  svg: {
+    circle: {
+      radius: "2",
+      fill: "#1CADFF"
+    },
+    line: {
+      stroke: "#1CADFF"
+    }
+  },
+  selectBox: {
+    stroke: "#1CADFF",
+    fill: "rgba(28, 173, 255, 0.3)"
+  },
+  hover: {
+    time: 500
   }
 };
+function getConfig(config) {
+  return merge3({}, defaultConfig, config);
+}
 
 // src/bmap.ts
-var BMap = class extends EventDispatcher4 {
+var BMap = class extends EventDispatcher6 {
   constructor(container, config = {}) {
     super();
     this.container = container;
@@ -1669,6 +1987,7 @@ var BMap = class extends EventDispatcher4 {
     __publicField(this, "azimuthalKeys", []);
     __publicField(this, "svgLine");
     __publicField(this, "svgPolygon");
+    __publicField(this, "basicZoom", 1);
     __publicField(this, "floorDataMap", /* @__PURE__ */ new Map());
     __publicField(this, "onKeydown", (e) => {
       if (this.polarKeys.includes(e.code)) {
@@ -1703,7 +2022,7 @@ var BMap = class extends EventDispatcher4 {
       const url = `${apiDomain}${floorGraphic}?brand=${brand}&project=${project}&phase=${phase}&building=${building}&floor=${floor}&ts=${ts}&resource_type_list=`;
       const data = yield fetch(url, apiInfo).then((res) => res.json()).then((res) => res.data).then((res) => {
         (res || []).map((item) => item.info = JSON.parse(item.info));
-        return res;
+        return res || [];
       });
       return data;
     });
@@ -1713,10 +2032,13 @@ var BMap = class extends EventDispatcher4 {
       const { apiDomain, apiPath: { floorRange }, apiInfo } = this.config;
       const url = `${apiDomain}${floorRange}?brand=${brand}&project=${project}&phase=${phase}&building=${building}`;
       const data = yield fetch(url, apiInfo).then((res) => res.json()).then((res) => res.data).then((res) => {
-        (res || []).map((item) => item.info = JSON.parse(item.info));
-        return res;
+        const data2 = (res || [])[0];
+        if (data2) {
+          data2.info = JSON.parse(data2.info);
+        }
+        return data2;
       });
-      return data[0];
+      return data;
     });
   }
   load(_0) {
@@ -1728,17 +2050,19 @@ var BMap = class extends EventDispatcher4 {
         this.loadGraphics({ brand, project, phase, building, floor, ts }),
         this.loadBuildingGround({ brand, project, phase, building })
       ]);
-      const center2 = getCenter(buildGround.info.geometry.cds[0]);
-      data.forEach((item) => {
-        item.info.geometry.cds.map((cds) => {
-          if (Array.isArray(cds)) {
-            cds.forEach((coord) => {
-              coord[0] -= center2[0];
-              coord[1] -= center2[1];
-            });
-          }
+      if (buildGround) {
+        const center2 = getCenter(buildGround.info.geometry.cds[0]);
+        data.forEach((item) => {
+          item.info.geometry.cds.map((cds) => {
+            if (Array.isArray(cds)) {
+              cds.forEach((coord) => {
+                coord[0] -= center2[0];
+                coord[1] -= center2[1];
+              });
+            }
+          });
         });
-      });
+      }
       if (!this.config.useFloorCache) {
         this.floorDataMap.clear();
       }
@@ -1748,16 +2072,17 @@ var BMap = class extends EventDispatcher4 {
   }
   createFloor(data) {
     const curFloor = new Floor(this.context);
-    let groundIndex = data.findIndex((item) => item.info.group === "floor");
-    if (groundIndex === -1) {
-      groundIndex = 0;
+    if (!data.length) {
+      return { curFloor, graphics: [] };
     }
-    const ground = data[groundIndex];
-    console.log(ground.info.height, ground.info.airHeight);
     const list = [...data];
-    list.splice(groundIndex, 1);
-    const groundGraphic = new Graphic(this.context, ground.info);
-    curFloor.addGround(groundGraphic);
+    let groundIndex = data.findIndex((item) => item.info.group === "ground");
+    if (groundIndex !== -1) {
+      const ground = data[groundIndex];
+      const groundGraphic = new Graphic(this.context, ground.info);
+      curFloor.addGround(groundGraphic);
+      list.splice(groundIndex, 1);
+    }
     const legacyToGraphicMap = /* @__PURE__ */ new Map();
     const graphics = list.map((item) => {
       const graphic = curFloor.addGraphic(item.info);
@@ -1766,14 +2091,19 @@ var BMap = class extends EventDispatcher4 {
       return graphic;
     });
     curFloor.userData.legacyToGraphicMap = legacyToGraphicMap;
-    return { curFloor, ground: groundGraphic, graphics };
+    return { curFloor, graphics };
   }
   switchFloor(floor) {
     const curFloorData = this.floorDataMap.get(floor);
     if (curFloorData) {
-      const { curFloor } = this.createFloor(curFloorData);
-      this.context.switchFloor(curFloor);
-      this.context.fitCameraToGround(void 0, 0);
+      const createdFloor = this.createFloor(curFloorData);
+      if (createdFloor) {
+        this.context.switchFloor(createdFloor.curFloor);
+        this.context.fitCameraToGround(void 0, 0);
+        this.basicZoom = this.context.camera.zoom;
+      } else {
+        console.warn("[switchFloor error] [" + floor + "] \u697C\u5C42\u6CA1\u6709\u6570\u636E");
+      }
     } else {
       console.warn("[switchFloor error] \u6CA1\u6709\u8FD9\u4E2A\u697C\u5C42\uFF0C\u8BF7\u5148\u8C03\u7528load\u65B9\u6CD5\u52A0\u8F7D\u697C\u5C42");
     }
@@ -1786,6 +2116,14 @@ var BMap = class extends EventDispatcher4 {
     var _a;
     return ((_a = this.context.currentFloor) == null ? void 0 : _a.userData.legacyToGraphicMap) || /* @__PURE__ */ new Map();
   }
+  /**
+   * 获取当前楼层全部的graphic
+   * @returns 
+   */
+  getFloorAllGraphics() {
+    var _a;
+    return ((_a = this.context.currentFloor) == null ? void 0 : _a.graphicLayer.children.filter((item) => item instanceof Graphic)) || [];
+  }
   createGraphicPoi(graphic, options) {
     if (this.context.currentFloor) {
       const poi = this.context.currentFloor.addPoi(options);
@@ -1954,15 +2292,18 @@ var BMap = class extends EventDispatcher4 {
 };
 export {
   BMap,
+  BaseSvg,
   Context,
   Floor,
   Graphic,
   GraphicLayer,
   HeatmapElement,
+  HoverHelper,
   Layer,
   Overlay,
   Poi,
   PoiLayer,
+  Selection,
   Shadow,
   SvgLine,
   SvgPolygon,
@@ -1972,6 +2313,7 @@ export {
   createCanvas,
   createCircle,
   createLine,
+  createRect,
   createSvg,
   createSvgElement,
   defaultConfig,
@@ -1988,9 +2330,11 @@ export {
   initRenderer,
   initScene,
   initShape,
+  isContain,
   proxyOptions,
   setCirclePosition,
   setLineStartEnd,
+  setRectPosition,
   timeoutPromise,
   vector3ToDevice
 };