build-dxf 0.1.95 → 0.1.97

package/package.json

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

package/src/build.js

@@ -1926,6 +1926,15 @@ class PointSpatialHash {
       if (list.size === 1) return [...list][0];
     }
   }
+  /** 通过点快速创建
+   * @param lines 
+   * @returns 
+   */
+  static from(points) {
+    const psh = new PointSpatialHash();
+    points.forEach((p2, index2) => psh.insert(p2, index2));
+    return psh;
+  }
   /** 通过线段快速创建
    * @param lines 
    * @returns 
@@ -2989,6 +2998,9 @@ class UnionFindSet {
   }
 }
 class LineSegmentUtils {
+  clone(lines) {
+    return lines.map((line) => line.clone());
+  }
   /** 获取最长线段索引
    * @param lines 
    */
@@ -19178,15 +19190,27 @@ function removeDangline(lines, len = 0.01, consecutive = false) {
   return [...defaultLines, ...doorLines];
 }
 const DELETE_SYMBOL = /* @__PURE__ */ Symbol("DELETE_SYMBOL");
-const INTERSECT_COUNT = /* @__PURE__ */ Symbol("INTERSECT_COUNT");
 function fitting(lines) {
   const index2 = LineSegmentUtils.maxLengthLineIndex(lines);
   if (index2 === -1) throw Error("未找到最长线段");
   const maxLine = lines[index2], center = LineSegmentUtils.getLinesCenter(lines), direct = maxLine.direction(), start = center.clone().add(direct.clone().multiplyScalar(-1)), end = center.clone().add(direct.clone().multiplyScalar(1));
   return new LineSegment(start, end);
 }
-function layoutDesign(lines, axis) {
-  const blocks = lines.map((line, index2) => {
+function sortByAxis(lines, axis) {
+  lines.sort((a2, b4) => {
+    const sa2 = axis.projectPointValue(a2.start);
+    const sb = axis.projectPointValue(b4.start);
+    if (Math.abs(sa2 - sb) < 1e-6) {
+      const aLen = axis.projectPointValue(a2.end) - sa2;
+      const bLen = axis.projectPointValue(b4.end) - sb;
+      return bLen - aLen;
+    }
+    return sa2 - sb;
+  });
+  return lines;
+}
+function layoutDesign(lines, axis, intersectPoints) {
+  let blocks = lines.map((line, index2) => {
     const sv = axis.projectPointValue(line.start), ev = axis.projectPointValue(line.end), range = sv < ev ? [sv, ev] : [ev, sv];
     return { range, index: index2, rangeSize: range[1] - range[0] };
   });
@@ -19199,10 +19223,10 @@ function layoutDesign(lines, axis) {
     const block = blocks[i], line = lines[block.index], ranges = [];
     let start = block.range[0];
     for (let j = i + 1; j < blocks.length; j++) {
-      const nextBlock = blocks[j], nextLine = lines[nextBlock.index];
+      const nextBlock = blocks[j];
       const overlap = Math.min(block.range[1], nextBlock.range[1]) - Math.max(block.range[0], nextBlock.range[0]);
       if (overlap < 0) break;
-      else if (!(overlap >= nextBlock.rangeSize && nextLine?.currentData[INTERSECT_COUNT] === 0) && nextBlock.range[0] > start) {
+      if (nextBlock.range[0] > start) {
         ranges.push([start, nextBlock.range[0]]);
       }
       start = Math.max(start, nextBlock.range[1]);
@@ -19210,8 +19234,10 @@ function layoutDesign(lines, axis) {
     if (start < block.range[1]) ranges.push([start, block.range[1]]);
     for (let j = 0; j < ranges.length; j++) {
       const range = ranges[j], start2 = axis.pointAt(range[0]), end = axis.pointAt(range[1]);
-      if (j === 0) line.set(start2, end);
-      else {
+      if (j === 0) {
+        line.set(start2, end);
+        newLines.push(line);
+      } else {
         let newLine = line.clone();
         newLine.set(start2, end);
         newLines.push(newLine);
@@ -19219,6 +19245,17 @@ function layoutDesign(lines, axis) {
     }
     if (ranges.length === 0) line.currentData[DELETE_SYMBOL] = true;
   }
+  sortByAxis(newLines, axis);
+  const psh = PointSpatialHash.from(intersectPoints);
+  for (let i = 0; i < newLines.length - 1; i++) {
+    const line = newLines[i];
+    if (psh.queryPoint(line.end).length !== 0) continue;
+    const nextLine = newLines[i + 1];
+    nextLine.start.copy(line.start);
+    line.currentData[DELETE_SYMBOL] = true;
+    mergeLineUserData(nextLine, line);
+  }
+  lines.length = 0;
   lines.push(...newLines);
   return lines;
 }
@@ -19258,21 +19295,20 @@ class AlignToParallelSegments {
       const group = groups[i];
       if (group.length <= 1) continue;
       const axisLine = fitting(group);
+      const points = [];
       for (let j = 0; j < group.length; j++) {
         const line = group[j];
-        let intersectCount = 0;
         line.points.forEach((p2) => {
           const intersectPoints = grid.queryCircle(p2, 1e-4).map((result) => result.point);
-          axisLine.pointAt(axisLine.projectPointValue(p2), p2);
+          const pv = axisLine.projectPointValue(p2);
+          axisLine.pointAt(pv, p2);
           intersectPoints.forEach((point2) => point2.copy(p2));
-          intersectCount += intersectPoints.length;
+          points.push(...intersectPoints);
         });
-        line.currentData[INTERSECT_COUNT] = intersectCount;
       }
-      layoutDesign(group, axisLine);
+      layoutDesign(group, axisLine, points);
     }
     return groups.flat().filter((line) => {
-      delete line.currentData[INTERSECT_COUNT];
       if (line.length() < 1e-9) return false;
       if (line.currentData[DELETE_SYMBOL]) {
         delete line.currentData[DELETE_SYMBOL];
@@ -19285,152 +19321,21 @@ class AlignToParallelSegments {
    * @param lines 
    * @returns 
    */
-  static align(lines, esp = 0.05, gap = 0.01) {
-    const axisLine = lines[0], axisLineV = axisLine.clone().rotate(Math.PI * 0.5, axisLine.center);
+  static align(lines, esp = 0.05, gap = 0.05) {
+    const axisLine = lines.find((line) => line.length() > 0.1), axisLineV = axisLine.clone().rotate(Math.PI * 0.5, axisLine.center);
     let [pllLines, verticalLines] = LineSegmentUtils.groupByParallelToAxis(lines, axisLine);
     const groups = this.group(pllLines, axisLine, axisLineV, esp, gap);
     pllLines = this.fittingAlignment(groups, verticalLines);
-    verticalLines = verticalLines.filter((line) => line.length() > 1e-9);
+    verticalLines = verticalLines.filter((line) => line.length() > 1e-6);
     const groups2 = this.group(verticalLines, axisLineV, axisLine, esp, gap);
     verticalLines = this.fittingAlignment(groups2, pllLines);
+    pllLines = pllLines.filter((line) => line.length() > 1e-6);
     return [
       ...pllLines,
       ...verticalLines
     ];
   }
 }
-function getNextPoint(point2, line, next, width) {
-  if (next.length === 0) {
-    const direct = point2.directionFrom(line.getAnotherPoint(point2));
-    return point2.clone().add(direct.multiplyScalar(width));
-  }
-  const p2 = next[0].userData.projectPoint(point2, false);
-  if (!p2) return false;
-  return p2;
-}
-function stepElimination(lineSegments, findMinWidth = 0.1, onMerge) {
-  const grid = createPointSpatialHash(lineSegments);
-  function getIntersInfo(line, point2) {
-    const intersList = grid.queryCircle(point2, 1e-4).filter((item) => item.point !== point2);
-    if (intersList.length == 0) return;
-    let firstLine = null, firstPoint = null;
-    let count = 0;
-    let parallel2 = new PvgList();
-    for (let i = 0; i < intersList.length; i++) {
-      const res = intersList[i];
-      if (line.isPerpendicularTo(res.userData, 10)) {
-        count++;
-        firstLine = res.userData;
-        firstPoint = res.point;
-      } else {
-        parallel2.push(res);
-      }
-    }
-    if (count !== 1) return;
-    if (!firstLine || !firstPoint) return;
-    const firstOtherPoint = firstLine.getAnotherPoint(firstPoint);
-    const nextResult = grid.queryCircle(firstOtherPoint, 1e-4).filter((item) => item.point !== firstOtherPoint);
-    return {
-      length: firstLine.length(),
-      firstLine,
-      firstPoint,
-      firstOtherPoint,
-      direction: firstOtherPoint.directionFrom(firstPoint),
-      nextOnlyVertical: nextResult.every((d2) => d2.userData.isPerpendicularTo(firstLine)),
-      next: nextResult,
-      parallel: parallel2
-    };
-  }
-  const removeLinesSet = /* @__PURE__ */ new Set();
-  for (let i = 0; i < lineSegments.length; i++) {
-    const line = lineSegments[i];
-    if (removeLinesSet.has(line)) continue;
-    const len = line.length();
-    if (len > findMinWidth) continue;
-    const startInfo = getIntersInfo(line, line.start);
-    if (!startInfo) continue;
-    const endInfo = getIntersInfo(line, line.end);
-    if (!endInfo) continue;
-    const angle = startInfo.direction.angle(endInfo.direction, { unit: "degree", range: "180" });
-    if (angle < 170) continue;
-    if (!startInfo.nextOnlyVertical && !endInfo.nextOnlyVertical) continue;
-    let mainInfo = startInfo, secondaryInfo = endInfo;
-    if (startInfo.nextOnlyVertical && endInfo.nextOnlyVertical) {
-      if (startInfo.length < endInfo.length) {
-        mainInfo = endInfo;
-        secondaryInfo = startInfo;
-      }
-    } else if (startInfo.nextOnlyVertical) {
-      mainInfo = endInfo;
-      secondaryInfo = startInfo;
-    }
-    const parallel2 = startInfo.parallel.concat(endInfo.parallel);
-    const newPoint = getNextPoint(mainInfo.firstPoint, mainInfo.firstLine, secondaryInfo.next, secondaryInfo.length);
-    if (!newPoint) continue;
-    removeLinesSet.add(line);
-    line.points.forEach((p2) => grid.remove(p2));
-    if (parallel2.length === 0) {
-      const oldLine = mainInfo.firstLine.clone();
-      mainInfo.firstPoint.copy(newPoint);
-      secondaryInfo.next.forEach((d2) => d2.point.copy(newPoint));
-      removeLinesSet.add(secondaryInfo.firstLine);
-      secondaryInfo.firstLine.points.forEach((p2) => grid.remove(p2));
-      mainInfo.firstLine.points.forEach((p2) => grid.update(p2));
-      if (typeof onMerge === "function") onMerge(mainInfo.firstLine, line, secondaryInfo.firstLine, oldLine);
-    } else {
-      secondaryInfo.firstPoint.copy(mainInfo.firstPoint);
-      secondaryInfo.firstOtherPoint.copy(newPoint);
-      secondaryInfo.next.forEach((d2) => d2.point.copy(newPoint));
-      startInfo.parallel.concat(endInfo.parallel).forEach((item) => item.point.copy(mainInfo.firstPoint));
-      secondaryInfo.firstLine.points.forEach((p2) => grid.update(p2));
-      secondaryInfo.next.forEach((d2) => grid.update(d2.point));
-      startInfo.parallel.concat(endInfo.parallel).forEach((item) => grid.update(item.point));
-    }
-  }
-  lineSegments = lineSegments.filter((line) => !removeLinesSet.has(line));
-  return lineSegments;
-}
-function repetitiveTask(count, callfun) {
-  for (let i = 0; i < count; i++) {
-    callfun(i);
-  }
-}
-function stepEliminationMerge(target, _, source, oldLine) {
-  if (source.userData.isDoor) WallInsertObject.addInsertObject(target, {
-    p: source.center.toJson(),
-    width: source.length(),
-    full: false,
-    type: "door",
-    height: source.userData.drawDoorData.height,
-    groundClearance: source.userData.drawDoorData.groundClearance
-  });
-  if (target.userData.isDoor) {
-    delete target.userData.isDoor;
-    WallInsertObject.addInsertObject(target, {
-      p: oldLine.center.toJson(),
-      width: oldLine.length(),
-      full: false,
-      type: "door",
-      height: target.userData.drawDoorData?.height,
-      groundClearance: target.userData.drawDoorData?.groundClearance ?? 0
-    });
-  }
-  WallInsertObject.copyInsertObject(target, source);
-  WallInsertObject.recomputed([target]);
-}
-function linesSmoothing(lines, _) {
-  const other = [];
-  lines = lines.filter((line) => {
-    if (line.userData.isBayWindow) {
-      other.push(line);
-      return false;
-    }
-    return true;
-  });
-  repetitiveTask(2, () => lines = stepElimination(lines, 0.1, stepEliminationMerge));
-  WallInsertObject.recomputed(lines);
-  return [...lines, ...other];
-}
 function shortDistanceLink(lines, radius = 0.1) {
   const dpSet = findDiscretePoint(lines.filter((line) => !line.userData.isDoor)), pointVirtualGrid = createPointSpatialHash(dpSet.map((v2) => v2)), appendLines = [], visited = /* @__PURE__ */ new Set();
   const getWeight2 = (target, point2, line) => {
@@ -19564,7 +19469,6 @@ function correction(lines, targettLine, option) {
   }
   new WallInsertObject(newLines).recomputed().merge();
   newLines = removeDangline(newLines, 0.15, true);
-  newLines = linesSmoothing(newLines);
   newLines.push(...otherLines);
   return newLines.filter((line) => line.length() > 1e-9);
 }
@@ -22522,7 +22426,6 @@ async function buildJson(opt) {
   if (opt.axisAlignCorr !== false) {
     dxfSystem.Dxf.addPreProcessor(PRE_PROCESSOR.AxisAlignCorr);
     dxfSystem.Dxf.addPreProcessor(PRE_PROCESSOR.RemoveShortDoubleWall);
-    dxfSystem.Dxf.addPreProcessor(PRE_PROCESSOR.DoubleWallAlignment);
   }
   if (trajectory2) {
     if (typeof trajectory2 === "string") {

package/src/utils/algorithms/LineSegmentUtils.d.ts

@@ -1,6 +1,7 @@
 import { LineSegment } from './LineSegment';
 import { Point } from './Point';
 export declare class LineSegmentUtils {
+    clone(lines: LineSegment[]): LineSegment<Record<string, any>>[];
     /** 获取最长线段索引
      * @param lines
      */

package/src/utils/algorithms/PointSpatialHash.d.ts

@@ -108,6 +108,11 @@ export declare class PointSpatialHash<T = Record<string, any>> {
     /** 查找第一个游离的点
      */
     getFreePointFirst(): Target<T> | undefined;
+    /** 通过点快速创建
+     * @param lines
+     * @returns
+     */
+    static from(points: Point[]): PointSpatialHash<number>;
     /** 通过线段快速创建
      * @param lines
      * @returns