@aibee/crc-bmap 0.0.3-gamma

package/lib/bmap.esm.js

@@ -0,0 +1,1957 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/bmap.ts
+import { EventDispatcher as EventDispatcher4 } from "three";
+
+// src/utils/timer.ts
+var Timer = class {
+  constructor() {
+    __publicField(this, "tasks", {
+      requestAnimation: /* @__PURE__ */ new Set(),
+      timeout: /* @__PURE__ */ new Set(),
+      interval: /* @__PURE__ */ new Set()
+    });
+  }
+  requestAnimationFrame(fn) {
+    const timer = window.requestAnimationFrame(() => {
+      this.tasks.requestAnimation.delete(timer);
+      fn();
+    });
+    this.tasks.requestAnimation.add(timer);
+    return timer;
+  }
+  cancelAnimationFrame(timer) {
+    this.tasks.requestAnimation.delete(timer);
+    window.cancelAnimationFrame(timer);
+  }
+  setTimeout(fn, wait) {
+    const timer = window.setTimeout(() => {
+      this.tasks.timeout.delete(timer);
+      fn();
+    }, wait);
+    this.tasks.timeout.add(timer);
+    return timer;
+  }
+  clearTimeout(timer) {
+    this.tasks.timeout.delete(timer);
+    window.clearTimeout(timer);
+  }
+  setInterval(fn, wait) {
+    const timer = window.setInterval(() => {
+      this.tasks.interval.delete(timer);
+      fn();
+    }, wait);
+    this.tasks.interval.add(timer);
+    return timer;
+  }
+  clearInterval(timer) {
+    this.tasks.interval.delete(timer);
+    window.clearInterval(timer);
+  }
+  dispose() {
+    this.tasks.requestAnimation.forEach((timer) => {
+      window.cancelAnimationFrame(timer);
+    });
+    this.tasks.requestAnimation.clear();
+    this.tasks.timeout.forEach((timer) => {
+      window.clearTimeout(timer);
+    });
+    this.tasks.timeout.clear();
+    this.tasks.interval.forEach((timer) => {
+      window.clearInterval(timer);
+    });
+    this.tasks.interval.clear();
+  }
+};
+
+// src/utils/init-helper.ts
+import {
+  Scene,
+  WebGLRenderer,
+  OrthographicCamera,
+  HemisphereLight,
+  Shape,
+  PCFSoftShadowMap,
+  Group,
+  Color,
+  DirectionalLight,
+  AmbientLight
+} from "three";
+import { MapControls } from "three/examples/jsm/controls/MapControls";
+function initScene() {
+  const scene = new Scene();
+  scene.background = new Color(16777215);
+  return scene;
+}
+function initRenderer() {
+  const renderer = new WebGLRenderer({ antialias: true });
+  renderer.setClearColor(16777215);
+  renderer.setPixelRatio(window.devicePixelRatio);
+  renderer.shadowMap.enabled = true;
+  renderer.shadowMap.autoUpdate = true;
+  renderer.shadowMap.type = PCFSoftShadowMap;
+  return renderer;
+}
+function initCamera(width, height) {
+  const camera = new OrthographicCamera(-width / 2, width / 2, height / 2, -height / 2, -1e3, 5e3);
+  camera.up.set(0, 0, 1);
+  camera.position.set(0, 0, 100);
+  camera.lookAt(0, 0, 0);
+  return camera;
+}
+function initLight() {
+  const lights = new Group();
+  const hemisphereLight = new HemisphereLight(16777215, 15658734, 1);
+  hemisphereLight.intensity = 1;
+  hemisphereLight.position.set(0, 0, 10);
+  hemisphereLight.up.set(0, 0, 1);
+  lights.add(hemisphereLight);
+  const ambientLight = new AmbientLight(16777215);
+  lights.add(ambientLight);
+  return lights;
+}
+function initControl(camera, domElement) {
+  const control = new MapControls(camera, domElement);
+  control.enableDamping = false;
+  control.maxPolarAngle = 0;
+  control.minPolarAngle = 0;
+  control.maxAzimuthAngle = 0;
+  control.minAzimuthAngle = 0;
+  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]);
+    }
+  }
+  return shape;
+}
+function initDirectionalLight(color = 16777215, intensity = 1) {
+  const directionalLight = new DirectionalLight(color, intensity);
+  directionalLight.castShadow = true;
+  directionalLight.shadow.radius = 8;
+  directionalLight.shadow.mapSize.set(64, 64);
+  directionalLight.shadow.camera.left = -200;
+  directionalLight.shadow.camera.right = 200;
+  directionalLight.shadow.camera.top = 200;
+  directionalLight.shadow.camera.bottom = -200;
+  return directionalLight;
+}
+
+// src/utils/dispose.ts
+function dispose(o, recursive) {
+  var _a;
+  if (recursive && o.children && o.children.length) {
+    o.children.forEach((child) => {
+      dispose(child, recursive);
+    });
+  }
+  if (o.isMesh) {
+    const m = o;
+    if (m.geometry)
+      m.geometry.dispose();
+    if (m.material) {
+      if (Array.isArray(m.material)) {
+        m.material.forEach((mat) => {
+          mat.dispose();
+        });
+      } else {
+        m.material.dispose();
+      }
+    }
+  }
+  if (o.isLight) {
+    (_a = o.dispose) == null ? void 0 : _a.call(o);
+  }
+}
+
+// src/utils/rules.ts
+function hasChinese(str) {
+  return /[\u4E00-\u9FA5]+/g.test(str);
+}
+
+// src/utils/texture.ts
+import { DataTexture, RGBAFormat, LinearFilter } from "three";
+var textTextureMap = /* @__PURE__ */ new Map();
+function initCanvas() {
+  const canvas2 = document.createElement("canvas");
+  canvas2.width = 1024;
+  canvas2.height = 64;
+  const ctx2 = canvas2.getContext("2d", {
+    willReadFrequently: true
+  });
+  ctx2.font = "54px sans-serif";
+  ctx2.textBaseline = "hanging";
+  ctx2.lineWidth = 12;
+  ctx2.fillStyle = "rgba(0,0,0,1)";
+  ctx2.strokeStyle = "white";
+  return { canvas: canvas2, ctx: ctx2 };
+}
+var canvas;
+var ctx;
+function createCanvas() {
+  if (!canvas) {
+    const { canvas: c, ctx: t } = initCanvas();
+    canvas = c;
+    ctx = t;
+  }
+}
+function getTextureByText(text) {
+  if (textTextureMap.has(text)) {
+    return textTextureMap.get(text);
+  }
+  createCanvas();
+  ctx.clearRect(0, 0, 1024, 64);
+  const y = hasChinese(text) ? 4 : 8;
+  ctx.strokeText(text, 2, y);
+  ctx.fillText(text, 2, y);
+  let width = Math.ceil(ctx.measureText(text).width);
+  width = width % 2 === 0 ? width : width + 1;
+  width += 2;
+  const imageData = ctx.getImageData(0, 0, width, 64);
+  const texture = new DataTexture(
+    Uint8Array.from(imageData.data),
+    width,
+    64,
+    RGBAFormat
+  );
+  texture.flipY = true;
+  texture.minFilter = LinearFilter;
+  texture.magFilter = LinearFilter;
+  textTextureMap.set(text, texture);
+  return texture;
+}
+function clearTextTexture() {
+  textTextureMap.clear();
+}
+function clearCanvas() {
+  ctx = null;
+  canvas = null;
+}
+
+// src/utils/coordinate.ts
+import { point, featureCollection, center } from "@turf/turf";
+function vector3ToDevice(vector, camera, w, h) {
+  const _vector = vector.clone().project(camera);
+  const _w = w / 2;
+  const _h = h / 2;
+  const x = Math.round(_vector.x * _w + _w);
+  const y = Math.round(-_vector.y * _h + _h);
+  return { x, y };
+}
+function getCenter(coordinates) {
+  const features = featureCollection(coordinates.map((item) => point(item)));
+  const cent = center(features);
+  return cent.geometry.coordinates;
+}
+
+// src/utils/proxy.ts
+function proxyOptions(target, master) {
+  return new Proxy(target, {
+    get: (target2, p, receiver) => {
+      return Reflect.get(target2, p, receiver);
+    },
+    set: (target2, p, newValue, receiver) => {
+      const res = Reflect.set(target2, p, newValue, receiver);
+      master.dispatchEvent({ type: `change-${p}`, value: newValue });
+      return res;
+    }
+  });
+}
+
+// src/utils/promise.ts
+function timeoutPromise(promise, timeout) {
+  return Promise.race([
+    promise,
+    new Promise((resolve, reject) => {
+      setTimeout(() => reject(new Error("Promise timeout")), timeout);
+    })
+  ]);
+}
+
+// src/utils/svg.ts
+function createSvgElement(tag) {
+  return document.createElementNS("http://www.w3.org/2000/svg", tag);
+}
+function createSvg(w, h) {
+  const svg = createSvgElement("svg");
+  svg.setAttribute("width", w);
+  svg.setAttribute("height", h);
+  svg.style.cssText = "position: absolute; left: 0; top: 0; pointer-events: none;";
+  return svg;
+}
+function createCircle(radius = "2", fill) {
+  const circle = createSvgElement("circle");
+  circle.setAttribute("r", radius);
+  circle.setAttribute("fill", fill);
+  return circle;
+}
+function createLine(stroke) {
+  const line = createSvgElement("line");
+  line.setAttribute("stroke", stroke);
+  return line;
+}
+function setCirclePosition(circle, x, y) {
+  circle.setAttribute("cx", `${x}`);
+  circle.setAttribute("cy", `${y}`);
+}
+function setLineStartEnd(line, start, end) {
+  if (start) {
+    line.setAttribute("x1", `${start.x}`);
+    line.setAttribute("y1", `${start.y}`);
+  }
+  if (end) {
+    line.setAttribute("x2", `${end.x}`);
+    line.setAttribute("y2", `${end.y}`);
+  }
+}
+
+// src/context.ts
+import {
+  EventDispatcher,
+  Box2,
+  Vector3,
+  Vector2,
+  Raycaster,
+  Box3,
+  Color as Color2,
+  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) {
+    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);
+    });
+    __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" });
+    });
+    this.container.style.position = "relative";
+    this.container.style.overflow = "hidden";
+    this.init();
+    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 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)));
+  }
+  changeAmbientLightColor(color) {
+    this.lights.children.forEach((item) => {
+      if (item instanceof AmbientLight2) {
+        item.color = new Color2(color);
+      }
+    });
+  }
+  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;
+    }
+  }
+  /**
+   * 获取屏幕坐标对应的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 };
+  }
+  /**
+   * 获取屏幕坐标对应的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() {
+    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: {},
+  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;
+  }
+  init() {
+    this.geometry = this.initGeometry();
+    this.material = this.initMaterial();
+    this.mesh = this.initMesh();
+    this.mesh.position.z = this.options.airHeight;
+    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();
+  }
+};
+
+// src/elements/shadow.ts
+import {
+  Object3D as Object3D3,
+  PlaneGeometry,
+  Mesh as Mesh2,
+  ShadowMaterial,
+  Color as Color4,
+  DirectionalLightHelper,
+  BoxGeometry,
+  MeshBasicMaterial
+} from "three";
+var Shadow = class extends Object3D3 {
+  constructor() {
+    super();
+    __publicField(this, "directionalLight");
+    __publicField(this, "plane");
+    __publicField(this, "basicOpacity", 0.39);
+    this.directionalLight = this.initLight();
+    this.plane = this.initPlane();
+  }
+  // 创建光源
+  initLight() {
+    const directionalLight = initDirectionalLight(16777215, 0.23);
+    directionalLight.position.set(0, 0, 100);
+    const helper = new DirectionalLightHelper(directionalLight, 100);
+    const geometry = new BoxGeometry(10, 10, 10);
+    const material = new MeshBasicMaterial({ color: 16773120 });
+    const mesh = new Mesh2(geometry, material);
+    mesh.position.set(0, 0, 100);
+    this.add(directionalLight);
+    this.add(helper);
+    this.add(mesh);
+    return directionalLight;
+  }
+  changeLightColor(color) {
+    this.directionalLight.color = new Color4(color);
+  }
+  // 创建平面白色
+  initPlane() {
+    const geometry = new PlaneGeometry(2e3, 2e3);
+    const material = new ShadowMaterial({
+      transparent: true,
+      opacity: 0,
+      color: 16773120
+    });
+    const mesh = new Mesh2(geometry, material);
+    mesh.receiveShadow = true;
+    mesh.position.z = -1;
+    this.add(mesh);
+    return mesh;
+  }
+  setTarget(target) {
+    this.directionalLight.target = target;
+  }
+  transformOpacity(opacity) {
+    return opacity * this.basicOpacity;
+  }
+  setOpacity(opacity) {
+    this.plane.material.opacity = 1;
+  }
+  dispose() {
+    dispose(this, true);
+  }
+};
+
+// src/elements/poi.ts
+import { Object3D as Object3D5 } from "three";
+import { merge as merge3 } from "lodash";
+
+// src/elements/overlay.ts
+import { EventDispatcher as EventDispatcher2, Vector3 as Vector33 } from "three";
+var Overlay = class extends EventDispatcher2 {
+  constructor(context) {
+    super();
+    this.context = context;
+    __publicField(this, "div");
+    __publicField(this, "element");
+    __publicField(this, "position", new Vector33());
+    __publicField(this, "onUpdate", () => {
+      const vector = this.getPosition();
+      const { clientWidth, clientHeight } = this.context.container;
+      const { x, y } = vector3ToDevice(vector, this.context.camera, clientWidth, clientHeight);
+      this.div.style.left = `${x}px`;
+      this.div.style.top = `${y}px`;
+    });
+    this.registryEvent();
+    this.div = this.initDiv();
+    this.context.container.appendChild(this.div);
+  }
+  initDiv() {
+    const div = document.createElement("div");
+    div.style.position = "absolute";
+    return div;
+  }
+  bindElement(element) {
+    this.element = element;
+  }
+  unBindElement() {
+    this.element = void 0;
+  }
+  setVisible(visible, display = "block") {
+    this.div.style.display = visible ? display : "none";
+  }
+  getPosition() {
+    return this.element ? this.element.position.clone().setFromMatrixPosition(this.element.matrixWorld) : this.position;
+  }
+  registryEvent() {
+    this.context.addEventListener("update", this.onUpdate);
+  }
+  unRegistryEvent() {
+    this.context.removeEventListener("update", this.onUpdate);
+  }
+  dispose() {
+    this.unRegistryEvent();
+    this.unBindElement();
+    this.context.container.removeChild(this.div);
+    this.div = null;
+  }
+};
+
+// src/elements/poi.ts
+var defaultOptions2 = {
+  text: "",
+  level: 1,
+  collision_enable: true
+};
+var Poi = class extends Object3D5 {
+  constructor(context, options) {
+    super();
+    this.context = context;
+    __publicField(this, "span");
+    __publicField(this, "img");
+    __publicField(this, "overlay");
+    __publicField(this, "options");
+    __publicField(this, "_changePosition", () => {
+      this.overlay.div.style.transform = `translate3d(-50%, ${this.options.icon ? "-100%" : "-50%"}, 0)`;
+    });
+    this.options = proxyOptions(merge3({}, defaultOptions2, options), this);
+    this.overlay = new Overlay(this.context);
+    this.overlay.bindElement(this);
+    this._changePosition();
+    this.registryEvent();
+    this.initDiv();
+    this.addEventListener("change-icon", ({ value }) => {
+      if (value) {
+        if (!this.img) {
+          this.overlay.div.appendChild(this.initIcon());
+        } else {
+          this.img.setAttribute("src", value);
+        }
+      } else {
+        this.img && this.overlay.div.removeChild(this.img);
+        this.img = void 0;
+      }
+    });
+    this.addEventListener("change-text", ({ value }) => {
+      this.span.textContent = value;
+    });
+  }
+  initDiv() {
+    const div = this.overlay.div;
+    div.appendChild(this.initText());
+    if (this.options.icon) {
+      div.appendChild(this.initIcon());
+    }
+    div.style.fontSize = `12px`;
+    div.style.display = `flex`;
+    div.style.flexDirection = `column`;
+    div.style.justifyContent = `center`;
+    div.style.alignItems = `center`;
+    div.style.pointerEvents = `none`;
+    return div;
+  }
+  initText() {
+    const span = document.createElement("span");
+    span.style.whiteSpace = "nowrap";
+    span.textContent = this.options.text;
+    this.span = span;
+    return span;
+  }
+  initIcon() {
+    var _a, _b;
+    const img = document.createElement("img");
+    img.setAttribute("src", this.options.icon);
+    img.style.width = `${((_a = this.options.icon_size) == null ? void 0 : _a[0]) || 32}px`;
+    img.style.height = `${((_b = this.options.icon_size) == null ? void 0 : _b[1]) || 32}px`;
+    this.img = img;
+    return img;
+  }
+  registryEvent() {
+    this.context.addEventListener("update", this._changePosition);
+  }
+  unRegistryEvent() {
+    this.context.removeEventListener("update", this._changePosition);
+  }
+  setVisible(visible) {
+    this.overlay.setVisible(visible, "flex");
+  }
+  getBox() {
+    return this.overlay.div.getBoundingClientRect();
+  }
+  isContain(x, y) {
+    const box = this.getBox();
+    return x >= box.left && x <= box.right && y >= box.top && y <= box.bottom;
+  }
+  dispose() {
+    this.unRegistryEvent();
+    this.overlay.dispose();
+    this.span = null;
+    this.img = void 0;
+  }
+};
+
+// src/elements/floor.ts
+import { Object3D as Object3D8 } from "three";
+
+// src/layer/layer.ts
+import { Object3D as Object3D6 } from "three";
+var Layer = class extends Object3D6 {
+  constructor(context) {
+    super();
+    this.context = context;
+  }
+  dispose() {
+    dispose(this);
+    this.clear();
+  }
+};
+
+// src/layer/graphic-layer.ts
+var GraphicLayer = class extends Layer {
+  constructor(context) {
+    super(context);
+  }
+  createGraphic(options) {
+    const graphic = new Graphic(this.context, options);
+    this.add(graphic);
+    return graphic;
+  }
+  /**
+   * 获取射线相交的元素
+   * @param raycaster 
+   */
+  getGraphicByRaycaster(raycaster) {
+    let position = null;
+    const graphics = this.children.filter((item) => {
+      if (item instanceof Graphic) {
+        const pos = item.raycast(raycaster);
+        if (pos) {
+          if (position) {
+            if (pos.z > position.z) {
+              position = pos;
+            }
+          } else {
+            position = pos;
+          }
+        }
+        return !!pos;
+      }
+    });
+    return { graphics, position };
+  }
+};
+
+// src/layer/poi-layer.ts
+var PoiLayer = class extends Layer {
+  constructor(context) {
+    super(context);
+    __publicField(this, "pois", []);
+    __publicField(this, "onUpdate", () => {
+      this.collisionDetection();
+    });
+    this.registryEvent();
+  }
+  createPoi(options) {
+    const poi = new Poi(this.context, options);
+    this.add(poi);
+    this.pushPoi(poi);
+    poi.addEventListener("change-level", () => this.changePoiLevelOrCollisionEnable(poi));
+    poi.addEventListener("change-collision_enable", () => this.changePoiLevelOrCollisionEnable(poi));
+    return poi;
+  }
+  changePoiLevelOrCollisionEnable(poi) {
+    const index = this.pois.findIndex((item) => item === poi);
+    if (index === -1) {
+      return;
+    }
+    this.pois.splice(index, 1);
+    this.pushPoi(poi);
+  }
+  removePoi(poi) {
+    const index = this.pois.findIndex((item) => item === poi);
+    if (index === -1) {
+      return;
+    }
+    this.pois.splice(index, 1);
+    this.remove(poi);
+    poi.dispose();
+  }
+  /**
+   * 保存poi按照level排序
+   * @param poi 
+   */
+  pushPoi(poi) {
+    if (!poi.options.collision_enable) {
+      this.pois.unshift(poi);
+      return;
+    }
+    if (poi.options.level === 1) {
+      this.pois.push(poi);
+      return;
+    }
+    for (let i = 0; i < this.pois.length; i++) {
+      const item = this.pois[i];
+      if (!item.options.collision_enable) {
+        continue;
+      }
+      if (item.options.level <= poi.options.level) {
+        this.pois.splice(i, 0, poi);
+        return;
+      }
+    }
+    this.pois.push(poi);
+  }
+  getPoiByDeviceXy(x, y) {
+    const pois = this.children.filter((item) => {
+      return item instanceof Poi && item.isContain(x, y);
+    });
+    return pois;
+  }
+  /**
+   * 碰撞检测
+   */
+  collisionDetection() {
+    const range = [];
+    this.pois.forEach((item, index) => {
+      item.setVisible(true);
+      const { left, right, top, bottom } = item.getBox();
+      if (index === 0) {
+        range.push({ left, right, top, bottom });
+        return;
+      }
+      const valid = range.some((box) => {
+        const xIntersect = right < box.left || left > box.right;
+        const yIntersect = top > box.bottom || bottom < box.top;
+        return xIntersect || yIntersect;
+      });
+      item.setVisible(valid);
+    });
+  }
+  registryEvent() {
+    this.context.addEventListener("update", this.onUpdate);
+  }
+  unRegistryEvent() {
+    this.context.removeEventListener("update", this.onUpdate);
+  }
+  dispose() {
+    super.dispose();
+    this.unRegistryEvent();
+    this.pois.forEach((item) => item.dispose());
+    this.pois.length = 0;
+  }
+};
+
+// src/elements/heatmap.ts
+import {
+  MeshBasicMaterial as MeshBasicMaterial2,
+  Object3D as Object3D7,
+  PlaneGeometry as PlaneGeometry2,
+  Texture,
+  DoubleSide,
+  Mesh as Mesh3,
+  Matrix3,
+  Vector2 as Vector22
+} 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 {
+  constructor(context) {
+    super();
+    this.context = context;
+    __publicField(this, "heatmap");
+    __publicField(this, "div");
+    __publicField(this, "plane");
+    this.div = document.createElement("div");
+  }
+  clearHeatmap() {
+    if (this.div.firstChild) {
+      this.div.removeChild(this.div.firstChild);
+    }
+    this.heatmap = void 0;
+  }
+  loadData(data) {
+    this.clearHeatmap();
+    const { width, height, leftTop, center: center2 } = this.getBox(data);
+    this.heatmap = create(__spreadValues({
+      width,
+      height,
+      container: this.div
+    }, this.context.config.heatMap));
+    this.heatmap.setData(this.transformData(data, leftTop));
+    this.initPlane(width, height);
+    this.position.set(center2[0], center2[1], this.position.z);
+  }
+  initPlane(width, height) {
+    if (this.plane) {
+      this.remove(this.plane);
+    }
+    const geometry = new PlaneGeometry2(width, height);
+    const texture = new Texture(this.div.firstChild);
+    texture.needsUpdate = true;
+    const material = new MeshBasicMaterial2({
+      transparent: true,
+      side: DoubleSide,
+      map: texture
+    });
+    material.needsUpdate = true;
+    this.plane = new Mesh3(geometry, material);
+    this.add(this.plane);
+  }
+  getTransMatrix({ x, y }) {
+    return new Matrix3().makeScale(1, -1).multiply(new Matrix3().makeTranslation(0 - x, 0 - y));
+  }
+  /**
+   * 所有点的坐标减去左上角从00点开始画canvas
+   * @param data 
+   * @param leftTop 
+   * @returns 
+   */
+  transformData(data, leftTop) {
+    const matrix = this.getTransMatrix(leftTop);
+    const $data = data.data.map((item) => {
+      const vector = new Vector22(item.x, item.y).applyMatrix3(matrix);
+      return {
+        x: vector.x,
+        y: vector.y,
+        value: item.value
+      };
+    });
+    return {
+      data: $data,
+      max: data.max,
+      min: data.min
+    };
+  }
+  getBox(data) {
+    const features = featureCollection2(data.data.map((item) => point2([item.x, item.y])));
+    const box = bbox(features);
+    const width = box[2] - box[0];
+    const height = box[3] - box[1];
+    const leftTop = { x: box[0], y: box[3] };
+    const center2 = getCenter2(features);
+    return { width, height, leftTop, center: center2.geometry.coordinates };
+  }
+  dispose() {
+    this.div = null;
+    this.heatmap = void 0;
+  }
+};
+
+// src/elements/floor.ts
+var Floor = class extends Object3D8 {
+  constructor(context) {
+    super();
+    this.context = context;
+    __publicField(this, "graphicLayer");
+    __publicField(this, "poiLayer");
+    __publicField(this, "ground");
+    __publicField(this, "shadow", new Shadow());
+    __publicField(this, "heatmap");
+    this.graphicLayer = new GraphicLayer(this.context);
+    this.poiLayer = new PoiLayer(this.context);
+    this.add(this.graphicLayer);
+    this.add(this.poiLayer);
+    this.add(this.shadow);
+  }
+  addGround(ground) {
+    this.ground = ground;
+    this.add(ground);
+    const center2 = ground.getCenter();
+    this.shadow.position.x = center2.x;
+    this.shadow.position.y = center2.y;
+    this.shadow.setTarget(ground);
+  }
+  addGraphic(graphicOptions) {
+    return this.graphicLayer.createGraphic(graphicOptions);
+  }
+  addPoi(poiOptions) {
+    return this.poiLayer.createPoi(poiOptions);
+  }
+  addHeatmap(data) {
+    var _a, _b;
+    if (!this.heatmap) {
+      this.heatmap = new HeatmapElement(this.context);
+      this.add(this.heatmap);
+    }
+    this.heatmap.loadData(data);
+    if (this.ground) {
+      this.heatmap.position.setZ(((_a = this.ground) == null ? void 0 : _a.options.airHeight) + ((_b = this.ground) == null ? void 0 : _b.options.height));
+    }
+    return this.heatmap;
+  }
+  removeHeatMap() {
+    if (this.heatmap) {
+      this.remove(this.heatmap);
+      this.heatmap.dispose();
+      this.heatmap = void 0;
+    }
+  }
+  setShadowOpacity(opacity) {
+    this.shadow.setOpacity(opacity);
+  }
+  setShadowVisible(visible) {
+    this.shadow.visible = visible;
+  }
+  dispose() {
+    var _a, _b;
+    this.shadow.dispose();
+    this.graphicLayer.dispose();
+    this.poiLayer.dispose();
+    (_a = this.ground) == null ? void 0 : _a.dispose();
+    (_b = this.heatmap) == null ? void 0 : _b.dispose();
+    this.clear();
+  }
+};
+
+// src/elements/base-svg.ts
+import { EventDispatcher as EventDispatcher3, Raycaster as Raycaster3, Vector2 as Vector23 } from "three";
+var BaseSvg = class extends EventDispatcher3 {
+  constructor(context) {
+    super();
+    this.context = context;
+    __publicField(this, "points", []);
+    __publicField(this, "svg");
+    __publicField(this, "enable", true);
+    this.svg = createSvg(`${context.container.clientWidth}`, `${context.container.clientHeight}`);
+    context.container.appendChild(this.svg);
+  }
+  setEnable(enable) {
+    this.enable = enable;
+    if (enable) {
+      this.svg.style.display = "block";
+    } else {
+      this.svg.style.display = "none";
+    }
+  }
+  getIntersectByPointerEvent(e) {
+    var _a;
+    if (!((_a = this.context.currentFloor) == null ? void 0 : _a.ground)) {
+      return;
+    }
+    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];
+  }
+  getSvgCoordinate(vector) {
+    const { camera, container } = this.context;
+    const coord = vector3ToDevice(vector, camera, container.clientWidth, container.clientHeight);
+    return coord;
+  }
+  dispose() {
+    this.context.container.removeChild(this.svg);
+    this.svg = null;
+  }
+};
+
+// src/elements/svg-line.ts
+var SvgLine = class extends BaseSvg {
+  constructor(context) {
+    super(context);
+    this.context = context;
+    __publicField(this, "circles");
+    __publicField(this, "line");
+    __publicField(this, "onUpdate", () => {
+      if (this.points[0]) {
+        const point1 = this.getSvgCoordinate(this.points[0]);
+        setCirclePosition(this.circles[0], point1.x, point1.y);
+        setLineStartEnd(this.line, point1);
+      }
+      if (this.points[1]) {
+        const point22 = this.getSvgCoordinate(this.points[1]);
+        setCirclePosition(this.circles[1], point22.x, point22.y);
+        setLineStartEnd(this.line, void 0, point22);
+      }
+    });
+    __publicField(this, "onPointermove", (e) => {
+      if (this.points.length !== 1) {
+        return;
+      }
+      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 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 });
+        }
+        this.addPoint(intersect.point);
+      }
+    });
+    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 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 { 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/bmap.ts
+var BMap = class extends EventDispatcher4 {
+  constructor(container, config = {}) {
+    super();
+    this.container = container;
+    __publicField(this, "config");
+    __publicField(this, "context");
+    __publicField(this, "polarKeys", []);
+    __publicField(this, "azimuthalKeys", []);
+    __publicField(this, "svgLine");
+    __publicField(this, "svgPolygon");
+    __publicField(this, "floorDataMap", /* @__PURE__ */ new Map());
+    __publicField(this, "onKeydown", (e) => {
+      if (this.polarKeys.includes(e.code)) {
+        this.context.control.maxPolarAngle = 1.2;
+        this.context.control.minPolarAngle = 0;
+      }
+      if (this.azimuthalKeys.includes(e.code)) {
+        this.context.control.maxAzimuthAngle = Infinity;
+        this.context.control.minAzimuthAngle = Infinity;
+      }
+    });
+    __publicField(this, "onKeyUp", (e) => {
+      if (this.polarKeys.includes(e.code)) {
+        const polar = this.context.control.getPolarAngle();
+        this.context.control.maxPolarAngle = polar;
+        this.context.control.minPolarAngle = polar;
+      }
+      if (this.azimuthalKeys.includes(e.code)) {
+        const azimuthal = this.context.control.getAzimuthalAngle();
+        this.context.control.maxAzimuthAngle = azimuthal;
+        this.context.control.minAzimuthAngle = azimuthal;
+      }
+    });
+    this.config = getConfig(config);
+    this.context = new Context(container, this.config);
+    this.registryEvent();
+    this.context.render();
+  }
+  loadGraphics(_0) {
+    return __async(this, arguments, function* ({ brand, project, phase, building, floor, ts }) {
+      const { apiDomain } = this.config;
+      const url = `${apiDomain}/api/floor/get?brand=${brand}&project=${project}&phase=${phase}&building=${building}&floor=${floor}&ts=${ts}&resource_type_list=`;
+      const data = yield fetch(url).then((res) => res.json()).then((res) => res.data).then((res) => {
+        res.map((item) => item.info = JSON.parse(item.info));
+        return res;
+      });
+      return data;
+    });
+  }
+  loadBuildingGround(_0) {
+    return __async(this, arguments, function* ({ brand, project, phase, building }) {
+      const { apiDomain } = this.config;
+      const url = `${apiDomain}/api/range/get?brand=${brand}&project=${project}&phase=${phase}&building=${building}`;
+      const data = yield fetch(url).then((res) => res.json()).then((res) => res.data).then((res) => {
+        res.map((item) => item.info = JSON.parse(item.info));
+        return res;
+      });
+      return data[0];
+    });
+  }
+  load(_0) {
+    return __async(this, arguments, function* ({ brand, project, phase, building, floor, ts }) {
+      if (this.floorDataMap.get(floor)) {
+        return;
+      }
+      const [data, buildGround] = yield Promise.all([
+        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 (!this.config.useFloorCache) {
+        this.floorDataMap.clear();
+      }
+      this.floorDataMap.set(floor, data);
+      return data;
+    });
+  }
+  createFloor(data) {
+    const curFloor = new Floor(this.context);
+    let groundIndex = data.findIndex((item) => item.info.group === "floor");
+    if (groundIndex === -1) {
+      groundIndex = 0;
+    }
+    const ground = data[groundIndex];
+    const list = [...data];
+    list.splice(groundIndex, 1);
+    const groundGraphic = new Graphic(this.context, ground.info);
+    curFloor.addGround(groundGraphic);
+    const graphics = [];
+    return { curFloor, ground: groundGraphic, 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);
+    } else {
+      console.warn("[switchFloor error] \u6CA1\u6709\u8FD9\u4E2A\u697C\u5C42\uFF0C\u8BF7\u5148\u8C03\u7528load\u65B9\u6CD5\u52A0\u8F7D\u697C\u5C42");
+    }
+  }
+  addHeatmap(data) {
+    var _a;
+    return (_a = this.context.currentFloor) == null ? void 0 : _a.addHeatmap(data);
+  }
+  removeHeatMap() {
+    var _a;
+    (_a = this.context.currentFloor) == null ? void 0 : _a.removeHeatMap();
+  }
+  /**
+   * 移动相机位置让选中的元素居中显示
+   * @param ele { Graphic | Poi }
+   * @param duration
+   */
+  translateElementToCenter(ele, duration = 500) {
+    const position = ele.position.clone().setFromMatrixPosition(ele.matrixWorld);
+    return this.context.setCameraPosition(position, duration);
+  }
+  /**
+   * 获取物体的屏幕坐标
+   */
+  getElementDeviceCoordinate(ele) {
+    const vector = ele.position.clone();
+    const { clientWidth, clientHeight } = this.container;
+    return vector3ToDevice(
+      vector,
+      this.context.camera,
+      clientWidth,
+      clientHeight
+    );
+  }
+  /**
+   * 切换2d、3d视角
+   * @param type
+   * @param duration
+   */
+  changeMapType(type, duration = 500) {
+    if (type === "2d") {
+      this.context.setPolarAngle(0);
+    } else {
+      this.context.setPolarAngle(1.2);
+    }
+  }
+  /**
+   * 缩小地图
+   * @param zoom
+   * @param duration
+   * @returns
+   */
+  reduceMap(zoom = 0.5, duration = 500) {
+    const cameraZoom = this.context.camera.zoom;
+    return this.context.setZoom(
+      cameraZoom - zoom,
+      this.context.control.target,
+      duration
+    );
+  }
+  /**
+   * 放大地图
+   * @param zoom
+   * @param duration
+   * @returns
+   */
+  enlargeMap(zoom = 0.5, duration = 500) {
+    const cameraZoom = this.context.camera.zoom;
+    return this.context.setZoom(
+      cameraZoom + zoom,
+      this.context.control.target,
+      duration
+    );
+  }
+  registryEvent() {
+    window.addEventListener("keydown", this.onKeydown);
+    window.addEventListener("keyup", this.onKeyUp);
+  }
+  unRegistryEvent() {
+    window.removeEventListener("keydown", this.onKeydown);
+    window.removeEventListener("keyup", this.onKeyUp);
+  }
+  /**
+   * 配置坐标定点 2D/3D线性切换的快捷键
+   * @param key
+   */
+  configurePolarShortcutKeys(keys) {
+    this.polarKeys = keys;
+  }
+  configureAzimuthalShortcutKeys(keys) {
+    this.azimuthalKeys = keys;
+  }
+  rotateMap(radius = 0.1) {
+    const azimuthal = this.context.control.getAzimuthalAngle();
+    this.context.control.maxAzimuthAngle = azimuthal + radius;
+    this.context.control.minAzimuthAngle = azimuthal + radius;
+    this.context.control.update();
+  }
+  /**
+   * 测量距离
+   * @returns 
+   */
+  measureDistance() {
+    return __async(this, null, function* () {
+      this.cancelDistance();
+      return new Promise((resolve, reject) => {
+        this.changeMapType("2d", 0);
+        this.context.control.enableRotate = false;
+        this.svgLine = new SvgLine(this.context);
+        const dispose2 = this.svgLine.dispose.bind(this.svgLine);
+        this.svgLine.dispose = function() {
+          dispose2();
+          reject("cancel");
+        };
+        this.svgLine.addEventListener("distance", ({ distance }) => {
+          resolve(distance);
+        });
+      });
+    });
+  }
+  /**
+   * 取消测量长度
+   */
+  cancelDistance() {
+    if (this.svgLine) {
+      this.svgLine.dispose();
+      this.svgLine = void 0;
+      this.context.control.enableRotate = true;
+    }
+  }
+  /**
+   * 测量面积
+   */
+  measureArea() {
+    this.cancelArea();
+    return new Promise((resolve, reject) => {
+      this.changeMapType("2d", 0);
+      this.context.control.enableRotate = false;
+      this.svgPolygon = new SvgPolygon(this.context);
+      const dispose2 = this.svgPolygon.dispose.bind(this.svgPolygon);
+      this.svgPolygon.dispose = function() {
+        dispose2();
+        reject("cancel");
+      };
+      this.svgPolygon.addEventListener("area", ({ area }) => {
+        resolve(area);
+      });
+    });
+  }
+  /**
+   * 取消测量面积
+   */
+  cancelArea() {
+    if (this.svgPolygon) {
+      this.svgPolygon.dispose();
+      this.svgPolygon = void 0;
+      this.context.control.enableRotate = true;
+    }
+  }
+  dispose() {
+    this.context.dispose();
+    clearTextTexture();
+    clearCanvas();
+    this.unRegistryEvent();
+  }
+};
+export {
+  BMap,
+  Floor,
+  Graphic,
+  HeatmapElement,
+  Overlay,
+  Poi,
+  Shadow,
+  SvgLine,
+  SvgPolygon,
+  Timer,
+  clearCanvas,
+  clearTextTexture,
+  createCanvas,
+  createCircle,
+  createLine,
+  createSvg,
+  createSvgElement,
+  defaultConfig,
+  dispose,
+  getCenter,
+  getConfig,
+  getTextureByText,
+  hasChinese,
+  initCamera,
+  initCanvas,
+  initControl,
+  initDirectionalLight,
+  initLight,
+  initRenderer,
+  initScene,
+  initShape,
+  proxyOptions,
+  setCirclePosition,
+  setLineStartEnd,
+  timeoutPromise,
+  vector3ToDevice
+};
+//# sourceMappingURL=bmap.esm.js.map