build-dxf 0.1.127 → 0.1.129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-dxf",
-  "version": "0.1.127",
+  "version": "0.1.129",
   "description": "",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/build.js

@@ -5850,299 +5850,6 @@ function smallestSurroundingRectangleByArea(geoJsonInput) {
   }
   return resultPolygon;
 }
-const tmpPoint1 = [0, 0];
-const tmpPoint2 = [0, 0];
-function lineSegmentsIntersect(p1, p2, q1, q2) {
-  const dx = p2[0] - p1[0];
-  const dy = p2[1] - p1[1];
-  const da2 = q2[0] - q1[0];
-  const db = q2[1] - q1[1];
-  if (da2 * dy - db * dx === 0) {
-    return false;
-  }
-  const s = (dx * (q1[1] - p1[1]) + dy * (p1[0] - q1[0])) / (da2 * dy - db * dx);
-  const t2 = (da2 * (p1[1] - q1[1]) + db * (q1[0] - p1[0])) / (db * dx - da2 * dy);
-  return s >= 0 && s <= 1 && t2 >= 0 && t2 <= 1;
-}
-function triangleArea(a2, b4, c) {
-  return (b4[0] - a2[0]) * (c[1] - a2[1]) - (c[0] - a2[0]) * (b4[1] - a2[1]);
-}
-function isLeft(a2, b4, c) {
-  return triangleArea(a2, b4, c) > 0;
-}
-function isLeftOn(a2, b4, c) {
-  return triangleArea(a2, b4, c) >= 0;
-}
-function isRight(a2, b4, c) {
-  return triangleArea(a2, b4, c) < 0;
-}
-function isRightOn(a2, b4, c) {
-  return triangleArea(a2, b4, c) <= 0;
-}
-function collinear(a2, b4, c, thresholdAngle) {
-  if (thresholdAngle === void 0) {
-    thresholdAngle = 0;
-  }
-  if (!thresholdAngle) {
-    return triangleArea(a2, b4, c) === 0;
-  } else {
-    const ab = tmpPoint1;
-    const bc = tmpPoint2;
-    ab[0] = b4[0] - a2[0];
-    ab[1] = b4[1] - a2[1];
-    bc[0] = c[0] - b4[0];
-    bc[1] = c[1] - b4[1];
-    const dot = ab[0] * bc[0] + ab[1] * bc[1];
-    const magA = Math.sqrt(ab[0] * ab[0] + ab[1] * ab[1]);
-    const magB = Math.sqrt(bc[0] * bc[0] + bc[1] * bc[1]);
-    const angle = Math.acos(dot / (magA * magB));
-    return angle < thresholdAngle;
-  }
-}
-function sqdist(a2, b4) {
-  const dx = b4[0] - a2[0];
-  const dy = b4[1] - a2[1];
-  return dx * dx + dy * dy;
-}
-function polygonAt(polygon2, i) {
-  const s = polygon2.length;
-  return polygon2[i < 0 ? i % s + s : i % s];
-}
-function polygonAppend(polygon2, poly, from, to2) {
-  for (let i = from; i < to2; i++) {
-    polygon2.push(poly[i]);
-  }
-}
-function makeCCW(polygon2) {
-  let br2 = 0;
-  const v2 = polygon2;
-  for (let i = 1; i < polygon2.length; ++i) {
-    if (v2[i][1] < v2[br2][1] || v2[i][1] === v2[br2][1] && v2[i][0] > v2[br2][0]) {
-      br2 = i;
-    }
-  }
-  if (!isLeft(polygonAt(polygon2, br2 - 1), polygonAt(polygon2, br2), polygonAt(polygon2, br2 + 1))) {
-    polygonReverse(polygon2);
-    return true;
-  } else {
-    return false;
-  }
-}
-function polygonReverse(polygon2) {
-  const tmp = [];
-  const N = polygon2.length;
-  for (let i = 0; i !== N; i++) {
-    tmp.push(polygon2.pop());
-  }
-  for (let i = 0; i !== N; i++) {
-    polygon2[i] = tmp[i];
-  }
-}
-function polygonIsReflex(polygon2, i) {
-  return isRight(polygonAt(polygon2, i - 1), polygonAt(polygon2, i), polygonAt(polygon2, i + 1));
-}
-function polygonCanSee2(polygon2, a2, b4) {
-  for (let i = 0; i !== polygon2.length; ++i) {
-    if (i === a2 || i === b4 || (i + 1) % polygon2.length === a2 || (i + 1) % polygon2.length === b4) {
-      continue;
-    }
-    if (lineSegmentsIntersect(polygonAt(polygon2, a2), polygonAt(polygon2, b4), polygonAt(polygon2, i), polygonAt(polygon2, i + 1))) {
-      return false;
-    }
-  }
-  return true;
-}
-function getIntersectionPoint(p1, p2, q1, q2, delta) {
-  if (delta === void 0) {
-    delta = 0;
-  }
-  const a1 = p2[1] - p1[1];
-  const b1 = p1[0] - p2[0];
-  const c1 = a1 * p1[0] + b1 * p1[1];
-  const a2 = q2[1] - q1[1];
-  const b22 = q1[0] - q2[0];
-  const c22 = a2 * q1[0] + b22 * q1[1];
-  const det = a1 * b22 - a2 * b1;
-  if (!scalarsEqual(det, 0, delta)) {
-    return [(b22 * c1 - b1 * c22) / det, (a1 * c22 - a2 * c1) / det];
-  } else {
-    return [0, 0];
-  }
-}
-function quickDecomp(polygon2, result, reflexVertices, steinerPoints, delta, maxlevel, level) {
-  if (result === void 0) {
-    result = [];
-  }
-  if (reflexVertices === void 0) {
-    reflexVertices = [];
-  }
-  if (steinerPoints === void 0) {
-    steinerPoints = [];
-  }
-  if (delta === void 0) {
-    delta = 25;
-  }
-  if (maxlevel === void 0) {
-    maxlevel = 100;
-  }
-  if (level === void 0) {
-    level = 0;
-  }
-  let upperInt = [0, 0];
-  let lowerInt = [0, 0];
-  let p2 = [0, 0];
-  let upperDist = 0;
-  let lowerDist = 0;
-  let d2 = 0;
-  let closestDist = 0;
-  let upperIndex = 0;
-  let lowerIndex = 0;
-  let closestIndex = 0;
-  const lowerPoly = [];
-  const upperPoly = [];
-  const poly = polygon2;
-  const v2 = polygon2;
-  if (v2.length < 3) {
-    return result;
-  }
-  level++;
-  if (level > maxlevel) {
-    console.warn("quickDecomp: max level (" + maxlevel + ") reached.");
-    return result;
-  }
-  for (let i = 0; i < polygon2.length; ++i) {
-    if (polygonIsReflex(poly, i)) {
-      reflexVertices.push(poly[i]);
-      upperDist = lowerDist = Number.MAX_VALUE;
-      for (let j = 0; j < polygon2.length; ++j) {
-        if (isLeft(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j)) && isRightOn(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j - 1))) {
-          p2 = getIntersectionPoint(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j), polygonAt(poly, j - 1));
-          if (isRight(polygonAt(poly, i + 1), polygonAt(poly, i), p2)) {
-            d2 = sqdist(poly[i], p2);
-            if (d2 < lowerDist) {
-              lowerDist = d2;
-              lowerInt = p2;
-              lowerIndex = j;
-            }
-          }
-        }
-        if (isLeft(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j + 1)) && isRightOn(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j))) {
-          p2 = getIntersectionPoint(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j), polygonAt(poly, j + 1));
-          if (isLeft(polygonAt(poly, i - 1), polygonAt(poly, i), p2)) {
-            d2 = sqdist(poly[i], p2);
-            if (d2 < upperDist) {
-              upperDist = d2;
-              upperInt = p2;
-              upperIndex = j;
-            }
-          }
-        }
-      }
-      if (lowerIndex === (upperIndex + 1) % polygon2.length) {
-        p2[0] = (lowerInt[0] + upperInt[0]) / 2;
-        p2[1] = (lowerInt[1] + upperInt[1]) / 2;
-        steinerPoints.push(p2);
-        if (i < upperIndex) {
-          polygonAppend(lowerPoly, poly, i, upperIndex + 1);
-          lowerPoly.push(p2);
-          upperPoly.push(p2);
-          if (lowerIndex !== 0) {
-            polygonAppend(upperPoly, poly, lowerIndex, poly.length);
-          }
-          polygonAppend(upperPoly, poly, 0, i + 1);
-        } else {
-          if (i !== 0) {
-            polygonAppend(lowerPoly, poly, i, poly.length);
-          }
-          polygonAppend(lowerPoly, poly, 0, upperIndex + 1);
-          lowerPoly.push(p2);
-          upperPoly.push(p2);
-          polygonAppend(upperPoly, poly, lowerIndex, i + 1);
-        }
-      } else {
-        if (lowerIndex > upperIndex) {
-          upperIndex += polygon2.length;
-        }
-        closestDist = Number.MAX_VALUE;
-        if (upperIndex < lowerIndex) {
-          return result;
-        }
-        for (let j = lowerIndex; j <= upperIndex; ++j) {
-          if (isLeftOn(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j)) && isRightOn(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j))) {
-            d2 = sqdist(polygonAt(poly, i), polygonAt(poly, j));
-            if (d2 < closestDist && polygonCanSee2(poly, i, j)) {
-              closestDist = d2;
-              closestIndex = j % polygon2.length;
-            }
-          }
-        }
-        if (i < closestIndex) {
-          polygonAppend(lowerPoly, poly, i, closestIndex + 1);
-          if (closestIndex !== 0) {
-            polygonAppend(upperPoly, poly, closestIndex, v2.length);
-          }
-          polygonAppend(upperPoly, poly, 0, i + 1);
-        } else {
-          if (i !== 0) {
-            polygonAppend(lowerPoly, poly, i, v2.length);
-          }
-          polygonAppend(lowerPoly, poly, 0, closestIndex + 1);
-          polygonAppend(upperPoly, poly, closestIndex, i + 1);
-        }
-      }
-      if (lowerPoly.length < upperPoly.length) {
-        quickDecomp(lowerPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
-        quickDecomp(upperPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
-      } else {
-        quickDecomp(upperPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
-        quickDecomp(lowerPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
-      }
-      return result;
-    }
-  }
-  result.push(polygon2);
-  return result;
-}
-function removeCollinearPoints(polygon2, thresholdAngle) {
-  if (thresholdAngle === void 0) {
-    thresholdAngle = 0;
-  }
-  let num = 0;
-  for (let i = polygon2.length - 1; polygon2.length > 3 && i >= 0; --i) {
-    if (collinear(polygonAt(polygon2, i - 1), polygonAt(polygon2, i), polygonAt(polygon2, i + 1), thresholdAngle)) {
-      polygon2.splice(i % polygon2.length, 1);
-      num++;
-    }
-  }
-  return num;
-}
-function scalarsEqual(a2, b4, precision) {
-  if (precision === void 0) {
-    precision = 0;
-  }
-  precision = precision || 0;
-  return Math.abs(a2 - b4) <= precision;
-}
-function pointsEqual(a2, b4, precision) {
-  if (precision === void 0) {
-    precision = 0;
-  }
-  return scalarsEqual(a2[0], b4[0], precision) && scalarsEqual(a2[1], b4[1], precision);
-}
-function removeDuplicatePoints(polygon2, precision) {
-  if (precision === void 0) {
-    precision = 0;
-  }
-  for (let i = polygon2.length - 1; i >= 1; --i) {
-    const pi2 = polygon2[i];
-    for (let j = i - 1; j >= 0; --j) {
-      if (pointsEqual(pi2, polygon2[j], precision)) {
-        polygon2.splice(i, 1);
-        continue;
-      }
-    }
-  }
-}
 class Polygon extends Array {
   [Symbol.iterator]() {
     return super[Symbol.iterator]();
@@ -6461,18 +6168,6 @@ class Polygon extends Array {
     this.set(polygons[0]);
     return true;
   }
-  /** 拆分为凸包
-   * @returns 
-   */
-  splitConvexHull() {
-    const concavePolygon = this.toArrays();
-    makeCCW(concavePolygon);
-    removeDuplicatePoints(concavePolygon);
-    removeCollinearPoints(concavePolygon);
-    const optimalConvexPolygons = quickDecomp(concavePolygon);
-    if (!optimalConvexPolygons) return null;
-    return optimalConvexPolygons.map((array) => new Polygon(array.map((item) => Point.from(item))));
-  }
   /** 包围盒检测
    * @param box 
    * @returns 
@@ -7556,27 +7251,27 @@ class OBB2 extends OBB$1 {
    * @param box 
    * @param position 
    * @param rotation 
-   * @param obb 
+   * @param out 
    * @returns 
    */
-  static from(box, position, rotation, obb2 = new OBB2()) {
+  static from(box, position, rotation, out = new OBB2()) {
     if (rotation instanceof THREE.Euler) quat.setFromEuler(rotation);
     else if (rotation instanceof THREE.Quaternion) quat.copy(rotation);
     else throw new Error(`传入的旋转不是欧拉角或者四元数`);
     matrix4.compose(position, quat, scale);
-    obb2.center.copy(position);
-    obb2.halfSize.copy(box.multiplyScalar(0.5));
-    obb2.rotation.setFromMatrix4(matrix4);
-    return obb2;
+    out.center.copy(position);
+    out.halfSize.copy(box.multiplyScalar(0.5));
+    out.rotation.setFromMatrix4(matrix4);
+    return out;
   }
   /** 通过2d路径创建
    * @param path 
    * @param origin 
    * @param height 
-   * @param obb_ 
+   * @param out 
    * @returns 
    */
-  static fromByPath2D(path, origin, height, obb_ = new OBB2()) {
+  static fromByPath2D(path, origin, height, out = new OBB2()) {
     const result = smallestSurroundingRectangleByArea({
       type: "Polygon",
       coordinates: [path.map((p2) => [p2.x, p2.y])]
@@ -7591,8 +7286,8 @@ class OBB2 extends OBB$1 {
     const [x, y] = getCenter(rectangle);
     origin.x = x;
     origin.y = y;
-    const obb2 = this.from(vec3, origin, euler, obb_);
-    return obb2;
+    out = this.from(vec3, origin, euler, out);
+    return out;
   }
 }
 const matrix4 = new THREE.Matrix4(), quat = new THREE.Quaternion(), euler = new THREE.Euler(), scale = new THREE.Vector3(1, 1, 1), vec3 = new THREE.Vector3(), box3$2 = new THREE.Box3();
@@ -10850,7 +10545,9 @@ class ThreeVJiaPipeline extends Pipeline {
         console.warn(`第${i}个物品轮廓为空`);
         return;
       }
-      const itemPoly = new Polygon(contour.map((p2) => Point.from(p2).rotate(json.center, json.angle))), center = itemPoly.getCenter(), index2 = roomPloys.findIndex((poly) => poly.pointWithin(center));
+      const itemPoly = new Polygon(
+        contour.map((p2) => Point.from(p2).rotate(json.center, json.angle))
+      ), center = itemPoly.getCenter(), index2 = roomPloys.findIndex((poly) => poly.pointWithin(center));
       if (index2 < 0) return;
       try {
         const rect = itemPoly.getMinimumBoundingRectangle().map((p2) => p2.toJson2D());
@@ -22451,8 +22148,9 @@ class SceneAutoGenerat {
     await Promise.all(this.itemList.map(async (item) => await this.getModel(item)));
   }
   static itemParse(item) {
-    if (!Array.isArray(item.contour) || !item.contour.length) return null;
-    const contour = Point.fromByList(item.contour ?? []), rectangle = new Polygon(Qa(contour.map((p2) => [p2.x, p2.y])).map((p2) => Point.from(p2)));
+    const contourData = item.quadContour ?? item.contour;
+    if (!Array.isArray(contourData) || contourData.length) return null;
+    const contour = Point.fromByList(contourData), rectangle = new Polygon(Qa(contour.map((p2) => [p2.x, p2.y])).map((p2) => Point.from(p2)));
     rectangle.pop();
     const z = item.box.min.z, height = Math.abs(item.box.max.z - z), max = rectangle.getMaxLengthInfo(), min = rectangle.getMinLengthInfo(), direction = max.start.y < max.end.y ? max.start.directionFrom(max.end) : max.end.directionFrom(max.start), shape = new THREE.Shape();
     rectangle.forEach((p2, i) => {

package/src/demo.d.ts

@@ -0,0 +1 @@
+export {};

package/src/index.css

@@ -137,6 +137,10 @@
   position: absolute;
 }
 
+.fixed {
+  position: fixed;
+}
+
 .relative {
   position: relative;
 }

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

@@ -0,0 +1,17 @@
+export declare class Variable {
+    value: number;
+    fixed: boolean;
+    constructor(value: number, fixed?: boolean);
+}
+export interface Constraint {
+    evaluate(): number[];
+}
+export declare class ConstraintSystem {
+    constraints: Constraint[];
+    variables: Variable[];
+    addConstraint(c: Constraint): void;
+    addVariable(v: Variable): void;
+    residuals(): number[];
+    jacobian(eps?: number): number[][];
+    solve(iterations?: number): void;
+}

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

@@ -12,19 +12,19 @@ export declare class OBB extends OBB_ {
      * @param box
      * @param position
      * @param rotation
-     * @param obb
+     * @param out
      * @returns
      */
-    static from(box: THREE.Vector3, position: THREE.Vector3, rotation: THREE.Euler | THREE.Quaternion, obb?: OBB): OBB;
+    static from(box: THREE.Vector3, position: THREE.Vector3, rotation: THREE.Euler | THREE.Quaternion, out?: OBB): OBB;
     /** 通过2d路径创建
      * @param path
      * @param origin
      * @param height
-     * @param obb_
+     * @param out
      * @returns
      */
     static fromByPath2D(path: {
         x: number;
         y: number;
-    }[], origin: THREE.Vector3, height: number, obb_?: OBB): OBB;
+    }[], origin: THREE.Vector3, height: number, out?: OBB): OBB;
 }

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

@@ -91,10 +91,6 @@ export declare class Polygon<T = any> extends Array<Point<T>> {
      * @param polygon
      */
     difference(polygons: Polygon | Polygon[], scale?: number): boolean;
-    /** 拆分为凸包
-     * @returns
-     */
-    splitConvexHull(): Polygon<Record<string, any>>[] | null;
     /** 包围盒检测
      * @param box
      * @returns

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

@@ -0,0 +1,9 @@
+import { LineSegment } from './LineSegment';
+import { Polygon } from './Polygon';
+export declare class PolygonUtils {
+    /** 拆分为凸包
+     * @returns
+     */
+    static splitConvexHull(ploy: Polygon): Polygon<Record<string, any>>[] | null;
+    static splitByLine(lines: LineSegment[], clipLine: LineSegment): LineSegment[][];
+}

package/src/utils/geometry-manager/GeometryManager.d.ts

@@ -0,0 +1,2 @@
+export declare class GeometryManager {
+}