build-dxf 0.0.16 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-dxf",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "description": "线段构建双线墙壁的dxf版本",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/build.js

@@ -592,6 +592,18 @@ class Box2 {
 }
 class Rectangle {
   points;
+  get p0() {
+    return this.points[0];
+  }
+  get p1() {
+    return this.points[1];
+  }
+  get p2() {
+    return this.points[2];
+  }
+  get p3() {
+    return this.points[3];
+  }
   get path() {
     return this.points.flatMap((p, i) => {
       const np = this.points[(i + 1) % this.points.length];
@@ -683,6 +695,40 @@ class Rectangle {
     };
     return isPointInRectangle(line.points[0]) && isPointInRectangle(line.points[1]);
   }
+  /**
+   * 判断矩形是否与矩形相交
+   * @description 使用分离轴定理
+   * @param rectangle 矩形
+   * @returns 是否与矩形相交
+   */
+  intersectRectangle(rectangle) {
+    const axes = [];
+    for (let i = 0; i < 4; i++) {
+      const p1 = this.points[i];
+      const p2 = this.points[(i + 1) % 4];
+      axes.push(p1.normal(p2));
+    }
+    for (let i = 0; i < 4; i++) {
+      const p1 = rectangle.points[i];
+      const p2 = rectangle.points[(i + 1) % 4];
+      axes.push(p1.normal(p2));
+    }
+    function projectRectangle(rect, axis) {
+      const projections = rect.points.map((point) => point.dot(axis));
+      return [Math.min(...projections), Math.max(...projections)];
+    }
+    function isProjectionOverlap(proj1, proj2) {
+      return proj1[0] < proj2[1] && proj2[0] < proj1[1];
+    }
+    for (const axis of axes) {
+      const proj1 = projectRectangle(this, axis);
+      const proj2 = projectRectangle(rectangle, axis);
+      if (!isProjectionOverlap(proj1, proj2)) {
+        return false;
+      }
+    }
+    return true;
+  }
   /**
    * 判断点是否完全位于矩形内部
    * @param point 
@@ -734,7 +780,7 @@ class Rectangle {
 }
 class LineSegment {
   points = [new Point(), new Point()];
-  userData;
+  userData = {};
   get center() {
     return new Point(
       this.points[0].x + (this.points[1].x - this.points[0].x) * 0.5,
@@ -796,11 +842,11 @@ class LineSegment {
    * @param width 
    * @returns {Rectangle}
    */
-  expandToRectangle(width = 0.1) {
+  expandToRectangle(width = 0.1, direct = "all") {
     const p1 = this.start, p2 = this.end;
     const normal = p2.normal(p1);
-    const pDirect = p2.direction(p1).mutiplyScalar(width * 0.5);
-    const nDirect = p1.direction(p2).mutiplyScalar(width * 0.5);
+    const pDirect = direct === "bothSides" ? Point.zero() : p2.direction(p1).mutiplyScalar(width * 0.5);
+    const nDirect = direct === "bothSides" ? Point.zero() : p1.direction(p2).mutiplyScalar(width * 0.5);
     const offsetX = normal.x * width * 0.5;
     const offsetY = normal.y * width * 0.5;
     const point = [
@@ -1153,13 +1199,13 @@ class Dxf extends Component {
     this.originalData = data;
     this.lineSegments.length = 0;
     const zList = [];
-    this.data = data.map(({ start, end, insetionArr, isDoor = false }, index2) => {
+    this.data = data.map(({ start, end, insetionArr, isDoor = false, isWindow }, index2) => {
       zList.push(start.z ?? 0, end.z ?? 0);
       const lineSegment = new LineSegment(
         Point.from(start).mutiplyScalar(scale),
         Point.from(end).mutiplyScalar(scale)
       );
-      lineSegment.userData = { isDoor };
+      lineSegment.userData = { isDoor, isWindow };
       this.lineSegments.push(lineSegment);
       return [
         lineSegment.points[0],
@@ -1481,27 +1527,41 @@ class Dxf extends Component {
       }
     });
     const doorThickness = this.width * 0.2;
-    d.addLayer("l_yellow", Drawing.ACI.CYAN, "DOTTED");
+    const list = [];
+    d.addLayer("l_cyan", Drawing.ACI.CYAN, "DOTTED");
     this.doorLineSegment.forEach((lineSegment) => {
       if (lineSegment.length() < 0.4) return;
       const line = lineSegment.clone().expansion(-this.width * 0.5);
-      d.setActiveLayer("l_yellow");
+      d.setActiveLayer("l_cyan");
       if (line.length() < 1.2) {
         line.expansion(-doorThickness * 0.5);
         const normal = lineSegment.normal();
-        const door = new LineSegment(
+        let door = new LineSegment(
           line.start.clone(),
           line.start.clone().add(normal.clone().multiplyScalar(line.length()))
         );
-        door.expansion(-doorThickness * 0.5).expandToRectangle(this.width * 0.2).path2D((p1, p2) => drawLine(p1, p2));
+        const box = door.clone().directionMove(door.normal(), line.length() * -0.5).expandToRectangle(line.length(), "bothSides");
+        for (let j = 0; j < list.length; j++) {
+          if (list[j].intersectRectangle(box)) {
+            door = new LineSegment(
+              line.start.clone(),
+              line.start.clone().add(normal.clone().multiplyScalar(-line.length()))
+            );
+            break;
+          }
+        }
+        door.expansion(-doorThickness * 0.5).expandToRectangle(this.width * 0.2, "bothSides").path2D((p1, p2) => drawLine(p1, p2));
         const a = line.length(), b = door.length(), r = (a ** 2 + b ** 2) / (2 * b), center = door.end.clone().add(door.direction().multiplyScalar(-r)), [startAngle, endAngle] = this.getArcAngleRange(center, line.end, door.end);
         d.drawArc(center.x * s, center.y * s, r * s, Math.min(startAngle, endAngle), Math.max(startAngle, endAngle));
+        list.push(box);
       } else {
         line.clone().expansion(-this.width * 0.5).expandToRectangle(this.width).path2D((p1, p2) => drawLine(p1, p2));
-        line.clone().directionMove(line.normal(), doorThickness * 0.5).expansion(-line.length() * 0.4, "end").forward(doorThickness * 0.5).expandToRectangle(doorThickness).path2D((p1, p2) => drawLine(p1, p2));
-        line.clone().directionMove(line.normal(), -doorThickness * 0.5).expansion(-line.length() * 0.4, "start").forward(-doorThickness * 0.5).expandToRectangle(doorThickness).path2D((p1, p2) => drawLine(p1, p2));
+        line.clone().directionMove(line.normal(), doorThickness * 0.5).directionMove(line.direction(), doorThickness * 0.5).expansion(-line.length() * 0.45, "end").forward(doorThickness * 0.5).expandToRectangle(doorThickness).path2D((p1, p2) => drawLine(p1, p2));
+        line.clone().directionMove(line.normal(), -doorThickness * 0.5).directionMove(line.direction(), -doorThickness * 0.5).expansion(-line.length() * 0.45, "start").forward(-doorThickness * 0.5).expandToRectangle(doorThickness).path2D((p1, p2) => drawLine(p1, p2));
       }
     });
+    d.addLayer("l_yellow", Drawing.ACI.YELLOW, "DOTTED");
+    d.setActiveLayer("l_yellow");
     return d.toDxfString();
   }
   /**
@@ -2138,7 +2198,6 @@ class LineAnalysis extends Component {
    * 门的位置判断
    */
   doorsAnalysis() {
-    this.parent?.findComponentByName("Renderer");
     const dxf = this.Dxf, doorPoints = [], pointVirtualGrid = this.pointVirtualGrid, quadtree = this.quadtree, doorSearchNearAngle = this.doorSearchNearAngle, doorSearchDistance = this.doorSearchDistance, doors = [];
     const excludePoints = dxf.doors.flatMap((item) => {
       const index2 = item[4];
@@ -2357,7 +2416,7 @@ class LineAnalysis extends Component {
       };
     }).filter((i) => !!i && i.start.distance(i.end) < doorSearchDistance);
     doors.push(...doors_);
-    searchNearRasult.forEach((item, i) => {
+    searchNearRasult.forEach((item) => {
       const start = doorPoints[item.doorIndex].point.clone();
       const end = doorPoints[item.findDoorIndex].point.clone();
       const startLine = this.findLongLineSegment(doorPoints[item.doorIndex].line);
@@ -2392,18 +2451,26 @@ class LineAnalysis extends Component {
     doors.forEach((p) => {
       const line = new LineSegment(p?.start, p?.end);
       const len = line.length();
-      if (len < 0.4) return;
-      const center = line.center, normal = line.normal();
-      const rLine = new LineSegment(
-        center.clone(),
-        center.clone().add(normal.clone().multiplyScalar(1))
-      );
-      rLine.directionMove(normal, -0.5);
-      const res = this.quadtree?.queryLineSegment(rLine);
-      if (res?.length) return;
+      if (len < 0.6) return;
+      const normal = line.normal(), direction = line.direction(), step = (len - dxf.width * 2) / 2;
+      for (let i = 0; i < 3; i++) {
+        const point = line.start.clone().add(direction.clone().multiplyScalar(dxf.width + step * i));
+        const rLine = new LineSegment(
+          point,
+          point.clone().add(normal.clone().multiplyScalar(1))
+        );
+        rLine.directionMove(normal, -0.5);
+        const res = this.quadtree?.queryLineSegment(rLine);
+        if (res?.length) return;
+      }
       dxf.doorLineSegment.push(line);
     });
   }
+  /**
+   * 
+   * @param line 
+   * @returns 
+   */
   findLongLineSegment(line) {
     const resLine = line.clone();
     const res1 = this.pointVirtualGrid.queryPoint(line.start);
@@ -2430,6 +2497,128 @@ class LineAnalysis extends Component {
     }
     return resLine;
   }
+  doorsAnalysis2() {
+    const renderer = this.parent?.findComponentByName("Renderer");
+    const dxf = this.Dxf, pointVirtualGrid = this.pointVirtualGrid, quadtree = this.quadtree;
+    this.doorSearchNearAngle;
+    this.doorSearchDistance;
+    const doorsAnalysis = new DoorsAnalysis(dxf, pointVirtualGrid, quadtree, this.resultList, this.lineSegmentList);
+    const possiblePoints = doorsAnalysis.searchPossiblePoints();
+    possiblePoints.forEach((l) => {
+      renderer.createPointMesh(l.point).position.z = dxf.originalZAverage;
+    });
+  }
+}
+class DoorsAnalysis {
+  // 所有可查找的点位
+  possibleDoorPoints = [];
+  doorPoint = [];
+  dxf;
+  pointVirtualGrid;
+  quadtree;
+  resultList;
+  // 已过滤门的线段
+  lineSegments;
+  constructor(dxf, pointVirtualGrid, quadtree, resultList = [], lineSegments = []) {
+    this.dxf = dxf;
+    this.pointVirtualGrid = pointVirtualGrid;
+    this.quadtree = quadtree;
+    this.resultList = resultList;
+    this.lineSegments = lineSegments;
+    this.addPointsExcludeRule((line) => line.userData.isDoor);
+    const excludeIndexMap = this.searchDoubleLinePoint();
+    this.addPointsExcludeRule((_1, _2, index2, pointIndex) => {
+      const excludeMode = excludeIndexMap.get(index2);
+      if (typeof excludeMode === "number") {
+        return excludeMode === -1 || excludeMode === pointIndex;
+      }
+      return false;
+    });
+    this.doorPoint = this.searchDoorPoint();
+    this.addPointsExcludeRule((_1, point) => {
+      return !!this.doorPoint.find((p1) => p1.point.equal(point));
+    });
+    this.possibleDoorPoints = this.searchPossiblePoints();
+  }
+  /**
+   * 
+   * @param rule 
+   */
+  addPointsExcludeRule(rule) {
+    this._pointsExcludeRule.push(rule);
+  }
+  _pointsExcludeRule = [];
+  /**
+   * 查找所有可能为门的点位
+   */
+  searchPossiblePoints() {
+    const dxf = this.dxf, doorPoints = [];
+    dxf.lineSegments.forEach((line, i) => {
+      line.points.forEach((p, j) => {
+        for (let i2 = 0; i2 < this._pointsExcludeRule.length; i2++)
+          if (this._pointsExcludeRule[i2](line, p, i2, j)) return;
+        const res = this.pointVirtualGrid.queryPoint(p).filter((d) => d.userData?.index !== i);
+        if (res.length === 0) {
+          doorPoints.push({
+            line,
+            point: p,
+            index: i
+          });
+        }
+      });
+    });
+    return doorPoints;
+  }
+  /**
+   * 查找已知为门的点位
+   */
+  searchDoorPoint() {
+    const doorPoints = [], dxf = this.dxf, pointVirtualGrid = this.pointVirtualGrid;
+    dxf.doors.forEach((item) => {
+      const index2 = item[4];
+      const doorData = dxf.originalData[index2];
+      if (doorData.drawDoorData) {
+        const point = Point.from(doorData.drawDoorData.start);
+        const direct = Point.from(doorData.drawDoorData.n);
+        const resList = pointVirtualGrid.queryPoint(point).filter((res) => {
+          if (res.userData?.index === index2) return false;
+          const line = dxf.lineSegments[res.userData?.index];
+          const direct2 = line.direction();
+          if (line.start.equal(point)) direct2.multiplyScalar(-1);
+          const angle = direct.angleBetween(direct2, "angle");
+          return angle > 80 || angle < 10;
+        });
+        if (resList.length) {
+          const index22 = resList[0].userData?.index;
+          doorPoints.push({
+            line: dxf.lineSegments[index22],
+            point: Point.from(doorData.drawDoorData.start),
+            index: index22,
+            direct,
+            sure: true
+          });
+        }
+      }
+    });
+    return doorPoints;
+  }
+  /**
+   * 查找双线墙的点位
+   * @returns 
+   */
+  searchDoubleLinePoint() {
+    const excludeIndexMap = /* @__PURE__ */ new Map();
+    this.resultList.flatMap((p) => {
+      const line0 = this.lineSegments[p.sourceIndex], line1 = this.lineSegments[p.targetIndex], start0 = line1.projectPoint(line0.start), end0 = line1.projectPoint(line0.end), start1 = line0.projectPoint(line1.start), end1 = line0.projectPoint(line1.end), mode0 = start0 && end0 ? -1 : start0 ? 0 : end0 ? 1 : -1, mode1 = start1 && end1 ? -1 : start1 ? 0 : end1 ? 1 : -1;
+      if (excludeIndexMap.has(p.sourceIndex)) {
+        if (excludeIndexMap.get(p.sourceIndex) != mode0) excludeIndexMap.set(p.sourceIndex, -1);
+      } else excludeIndexMap.set(p.sourceIndex, mode0);
+      if (excludeIndexMap.has(p.targetIndex)) {
+        if (excludeIndexMap.get(p.targetIndex) != mode1) excludeIndexMap.set(p.targetIndex, -1);
+      } else excludeIndexMap.set(p.targetIndex, mode1);
+    });
+    return excludeIndexMap;
+  }
 }
 class DxfSystem extends ComponentManager {
   Dxf;

package/src/index2.js

@@ -3363,6 +3363,7 @@ class Renderer extends Component {
   container = new THREE.Group();
   onUpdate;
   onResize;
+  pointer = new THREE.Vector2();
   tweenTaskList = [];
   constructor(description) {
     super();
@@ -3395,10 +3396,10 @@ class Renderer extends Component {
       Object.assign(this.orbitControls, description.orbitControls);
     }
     if (this.description.resizeObserver) {
-      const dom = this.description.resizeObserver;
+      const dom2 = this.description.resizeObserver;
       this.resizeObserver = new ResizeObserver(() => {
         const camera2 = this.camera;
-        const { width, height } = dom.getBoundingClientRect();
+        const { width, height } = dom2.getBoundingClientRect();
         this.renderer.setSize(width, height);
         if (this.html2DRenderer) this.html2DRenderer.setSize(width, height);
         if (this.html3DRenderer) this.html3DRenderer.setSize(width, height);
@@ -3412,8 +3413,9 @@ class Renderer extends Component {
         }
         camera2.updateProjectionMatrix();
         this.onResize && this.onResize(width, height);
+        this.dispatchEvent({ type: "resize", width, height });
       });
-      this.resizeObserver.observe(dom);
+      this.resizeObserver.observe(dom2);
     }
     this.renderer.setAnimationLoop(() => {
       if (this.html2DRenderer) this.html2DRenderer.render(this.scene, this.camera);
@@ -3430,6 +3432,25 @@ class Renderer extends Component {
     directLight.position.set(100, -100, 100);
     this.scene.add(directLight);
     camera.position.set(10, 10, 10);
+    const dom = description.orbitControls?.domElement ?? this.description.canvas;
+    dom.addEventListener("mousemove", (e) => {
+      this.pointer.set(e.offsetX, e.offsetY);
+      this.dispatchEvent({
+        type: "mousemove",
+        x: e.offsetX,
+        y: e.offsetY,
+        moveX: e.movementX,
+        moveY: e.movementY
+      });
+    });
+    dom.addEventListener("mousedown", (e) => {
+      this.pointer.set(e.offsetX, e.offsetY);
+      this.dispatchEvent({
+        type: "mousedown",
+        x: e.offsetX,
+        y: e.offsetY
+      });
+    });
   }
   /**
    * 世界坐标转屏幕坐标
@@ -7243,6 +7264,8 @@ const SelectLocalFile = Object.assign(selectLocalFileFun, {
     if (text) return JSON.parse(text);
   }
 });
+function Editor(dxfSystem) {
+}
 const _hoisted_1 = { class: "w-full flex justify-between absolute left-0 top-0 p-[10px] z-[1000] gap-[5px]" };
 const _hoisted_2 = { class: "text-[14px] bg-[rgba(255,255,255,1)] rounded-[6px] p-[0px_10px]" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
@@ -7254,20 +7277,25 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   setup(__props) {
     THREE.Object3D.DEFAULT_UP = new THREE.Vector3(0, 0, 1);
     const props = __props;
-    const elRef = ref(), originalLineVisible = ref(true), dxfVisible = ref(true), whiteModelVisible = ref(true), isLook = ref(false), dxfSystem = new DxfSystem().usePlugin(ModelDataPlugin).usePlugin(RenderPlugin), desPoint = dxfSystem.findComponentByType(DetailsPoint), domContainer = dxfSystem.findComponentByType(DomContainer), whiteModel = dxfSystem.findComponentByType(WhiteModel);
+    const elRef = ref(), originalLineVisible = ref(true), dxfVisible = ref(true), whiteModelVisible = ref(true), isLook = ref(false), dxfSystem = new DxfSystem().usePlugin(ModelDataPlugin).usePlugin(RenderPlugin).usePlugin(Editor), desPoint = dxfSystem.findComponentByType(DetailsPoint), domContainer = dxfSystem.findComponentByType(DomContainer), whiteModel = dxfSystem.findComponentByType(WhiteModel);
     watch(() => props.lines, () => props.lines && setLines(props.lines));
     watch(() => props.detailsPoint, () => props.detailsPoint && desPoint?.set(props.detailsPoint));
     function setLines(lines) {
       if (lines) {
-        dxfSystem.Dxf.set(lines);
-        dxfSystem.Dxf.lineOffset();
+        localStorage.setItem("lines", JSON.stringify(lines));
+        try {
+          dxfSystem.Dxf.set(lines);
+          dxfSystem.Dxf.lineOffset();
+        } catch (error) {
+          console.log(error);
+        }
       }
     }
     async function selectLocalFile() {
       const data = await SelectLocalFile.json();
       if (Array.isArray(data)) {
-        dxfSystem.Dxf.set(data);
-        dxfSystem.Dxf.lineOffset();
+        localStorage.removeItem("orbitControls");
+        setLines(data);
       }
     }
     async function selectDetailsPointFile() {
@@ -7281,10 +7309,29 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     dxfSystem.Variable.addEventListener("originalLineVisible", (e) => originalLineVisible.value = e.value);
     dxfSystem.Variable.addEventListener("dxfVisible", (e) => dxfVisible.value = e.value);
     dxfSystem.Variable.addEventListener("whiteModelVisible", (e) => whiteModelVisible.value = e.value);
-    setLines(props.lines);
+    if (localStorage.getItem("lines")) {
+      setLines(JSON.parse(localStorage.getItem("lines") ?? "{}"));
+    } else {
+      setLines(props.lines);
+    }
     props.detailsPoint && desPoint?.set(props.detailsPoint);
     onMounted(() => domContainer && elRef.value?.appendChild(domContainer.domElement));
     onUnmounted(() => dxfSystem.destroy());
+    const renderer = dxfSystem.findComponentByType(Renderer);
+    renderer.orbitControls?.addEventListener("change", () => {
+      localStorage.setItem("orbitControls", JSON.stringify({
+        position: renderer.camera.position.toArray(),
+        target: renderer.orbitControls?.target.toArray()
+      }));
+    });
+    const d = localStorage.getItem("orbitControls");
+    if (d) {
+      const data = JSON.parse(d);
+      setTimeout(() => {
+        renderer.camera.position.set(data.position[0], data.position[1], data.position[2]);
+        renderer.orbitControls?.target.set(data.target[0], data.target[1], data.target[2]);
+      });
+    }
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("div", {
         ref_key: "elRef",

package/src/utils/DxfSystem/components/Dxf.d.ts

@@ -35,6 +35,16 @@ export interface OriginalDataItem {
             z: number;
         };
     };
+    isWindow?: boolean;
+    drawWindow?: {
+        p: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        width: number;
+        full: boolean;
+    };
 }
 /**
  * [开始点, 结束点, 相交点, 是否是门, 索引]
@@ -76,6 +86,7 @@ export declare class Dxf extends Component<{
     doorLineSegment: LineSegment[];
     lineSegments: LineSegment<{
         isDoor: boolean;
+        isWindow: boolean;
     }>[];
     originalZAverage: number;
     static EndType: {
@@ -92,6 +103,7 @@ export declare class Dxf extends Component<{
      */
     get lines(): LineSegment<{
         isDoor: boolean;
+        isWindow: boolean;
     }>[];
     /**初始化
      * @param data 点云数据

package/src/utils/DxfSystem/components/LineAnalysis.d.ts

@@ -84,6 +84,12 @@ export declare class LineAnalysis extends Component {
      * 门的位置判断
      */
     doorsAnalysis(): void;
+    /**
+     *
+     * @param line
+     * @returns
+     */
     findLongLineSegment(line: LineSegment): LineSegment<Record<string, any>>;
+    doorsAnalysis2(): void;
 }
 export {};

package/src/utils/DxfSystem/plugin/Editor/components/Editor.d.ts

@@ -0,0 +1,21 @@
+import { Component, ComponentManager } from '../../../../ComponentManager';
+import { Dxf } from '../../../components/Dxf';
+import { Variable } from '../../../components/Variable';
+import { Renderer } from '../../RenderPlugin/components';
+import * as THREE from "three";
+export declare class Editor extends Component<{
+    pointerPositionChange: {
+        position: THREE.Vector2;
+    };
+}> {
+    static name: string;
+    container: THREE.Group<THREE.Object3DEventMap>;
+    get renderer(): Renderer;
+    get dxf(): Dxf;
+    get variable(): Variable;
+    plane: THREE.Mesh<THREE.PlaneGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    onAddFromParent(parent: ComponentManager): void;
+    private _exitEditCallBack?;
+    openEdit(): void;
+    exitEdit(): void;
+}

package/src/utils/DxfSystem/plugin/Editor/index.d.ts

@@ -0,0 +1,2 @@
+import { DxfSystem } from '../..';
+export declare function Editor(dxfSystem: DxfSystem): void;

package/src/utils/DxfSystem/plugin/RenderPlugin/components/Renderer.d.ts

@@ -19,7 +19,22 @@ export interface RendererDescription {
     scene?: THREE.Scene;
     camera?: THREE.PerspectiveCamera | THREE.OrthographicCamera;
 }
-export declare class Renderer extends Component {
+export declare class Renderer extends Component<{
+    resize: {
+        width: number;
+        height: number;
+    };
+    mousemove: {
+        x: number;
+        y: number;
+        moveX: number;
+        moveY: number;
+    };
+    mousedown: {
+        x: number;
+        y: number;
+    };
+}> {
     static name: string;
     static CSS2DObject: typeof CSS2DObject;
     static CSS3DObject: typeof CSS3DObject;
@@ -35,12 +50,13 @@ export declare class Renderer extends Component {
     renderer: THREE.WebGLRenderer;
     orbitControls?: OrbitControls;
     private resizeObserver?;
-    private description;
+    description: RendererDescription;
     html2DRenderer?: CSS2DRenderer;
     html3DRenderer?: CSS3DRenderer;
     container: THREE.Group<THREE.Object3DEventMap>;
     onUpdate?: () => void;
     onResize?: (width: number, height: number) => void;
+    pointer: THREE.Vector2;
     private tweenTaskList;
     constructor(description: RendererDescription);
     /**

package/src/utils/Quadtree/LineSegment.d.ts

@@ -5,7 +5,7 @@ import { Rectangle } from './Rectangle';
  */
 export declare class LineSegment<T = Record<string, any>> {
     points: Point[];
-    userData?: T;
+    userData: T;
     get center(): Point;
     get start(): Point;
     get end(): Point;
@@ -36,7 +36,7 @@ export declare class LineSegment<T = Record<string, any>> {
      * @param width
      * @returns {Rectangle}
      */
-    expandToRectangle(width?: number): Rectangle;
+    expandToRectangle(width?: number, direct?: "bothSides" | "all"): Rectangle;
     /**
      * 计算线段的长度
      * @returns 线段的长度

package/src/utils/Quadtree/Rectangle.d.ts

@@ -6,6 +6,10 @@ import { Point } from './Point';
  */
 export declare class Rectangle {
     points: Point[];
+    get p0(): Point;
+    get p1(): Point;
+    get p2(): Point;
+    get p3(): Point;
     get path(): number[];
     path2D(callback?: (point1: Point, point2: Point) => void): number[];
     constructor(points: Point[]);
@@ -21,6 +25,13 @@ export declare class Rectangle {
      * @returns 是否完全在矩形内部
      */
     containsLineSegment(line: LineSegment): boolean;
+    /**
+     * 判断矩形是否与矩形相交
+     * @description 使用分离轴定理
+     * @param rectangle 矩形
+     * @returns 是否与矩形相交
+     */
+    intersectRectangle(rectangle: Rectangle): boolean;
     /**
      * 判断点是否完全位于矩形内部
      * @param point