rm-graphical-computing-node 1.0.56 → 1.0.57

package/dist/index.mjs

@@ -711,10 +711,10 @@ var require_concaveman = __commonJS({
     }
     module.exports = concaveman2;
     module.exports.default = concaveman2;
-    function concaveman2(points, concavity, lengthThreshold) {
+    function concaveman2(points2, concavity, lengthThreshold) {
       concavity = Math.max(0, concavity === void 0 ? 2 : concavity);
       lengthThreshold = lengthThreshold || 0;
-      var hull = fastConvexHull(points);
+      var hull = fastConvexHull(points2);
       var tree = new RBush(16);
       tree.toBBox = function(a2) {
         return {
@@ -730,7 +730,7 @@ var require_concaveman = __commonJS({
       tree.compareMinY = function(a2, b2) {
         return a2[1] - b2[1];
       };
-      tree.load(points);
+      tree.load(points2);
       var queue = [];
       for (var i = 0, last; i < hull.length; i++) {
         var p = hull[i];
@@ -837,13 +837,13 @@ var require_concaveman = __commonJS({
       node.maxY = Math.max(p1[1], p2[1]);
       return node;
     }
-    function fastConvexHull(points) {
-      var left = points[0];
-      var top = points[0];
-      var right = points[0];
-      var bottom = points[0];
-      for (var i = 0; i < points.length; i++) {
-        var p = points[i];
+    function fastConvexHull(points2) {
+      var left = points2[0];
+      var top = points2[0];
+      var right = points2[0];
+      var bottom = points2[0];
+      for (var i = 0; i < points2.length; i++) {
+        var p = points2[i];
         if (p[0] < left[0]) left = p;
         if (p[0] > right[0]) right = p;
         if (p[1] < top[1]) top = p;
@@ -851,8 +851,8 @@ var require_concaveman = __commonJS({
       }
       var cull = [left, top, right, bottom];
       var filtered = cull.slice();
-      for (i = 0; i < points.length; i++) {
-        if (!pointInPolygon2(points[i], cull)) filtered.push(points[i]);
+      for (i = 0; i < points2.length; i++) {
+        if (!pointInPolygon2(points2[i], cull)) filtered.push(points2[i]);
       }
       return convexHull(filtered);
     }
@@ -961,21 +961,21 @@ var require_concaveman = __commonJS({
     function compareByX(a, b) {
       return a[0] === b[0] ? a[1] - b[1] : a[0] - b[0];
     }
-    function convexHull(points) {
-      points.sort(compareByX);
+    function convexHull(points2) {
+      points2.sort(compareByX);
       var lower = [];
-      for (var i = 0; i < points.length; i++) {
-        while (lower.length >= 2 && cross3(lower[lower.length - 2], lower[lower.length - 1], points[i]) <= 0) {
+      for (var i = 0; i < points2.length; i++) {
+        while (lower.length >= 2 && cross3(lower[lower.length - 2], lower[lower.length - 1], points2[i]) <= 0) {
           lower.pop();
         }
-        lower.push(points[i]);
+        lower.push(points2[i]);
       }
       var upper = [];
-      for (var ii = points.length - 1; ii >= 0; ii--) {
-        while (upper.length >= 2 && cross3(upper[upper.length - 2], upper[upper.length - 1], points[ii]) <= 0) {
+      for (var ii = points2.length - 1; ii >= 0; ii--) {
+        while (upper.length >= 2 && cross3(upper[upper.length - 2], upper[upper.length - 1], points2[ii]) <= 0) {
           upper.pop();
         }
-        upper.push(points[ii]);
+        upper.push(points2[ii]);
       }
       upper.pop();
       lower.pop();
@@ -1322,7 +1322,7 @@ var WallSubdivisionAnalyzer = class {
    *     { projectPlane: plane }
    * );
    */
-  analyzePointDistribution(wallGroup, points, tolerance = 0.01, options = {}) {
+  analyzePointDistribution(wallGroup, points2, tolerance = 0.01, options = {}) {
     const projectPlane = options.projectPlane || null;
     this.results = {
       totalSegments: 0,
@@ -1388,8 +1388,8 @@ var WallSubdivisionAnalyzer = class {
     plane.setFromCoplanarPoints(p0, p1, p3);
     const temp = new Vector33();
     const tempProjectedPoint = new Vector33();
-    for (let pointIndex = 0; pointIndex < points.length; pointIndex += 3) {
-      const rawPoint = new Vector33(points[pointIndex], points[pointIndex + 1], points[pointIndex + 2]);
+    for (let pointIndex = 0; pointIndex < points2.length; pointIndex += 3) {
+      const rawPoint = new Vector33(points2[pointIndex], points2[pointIndex + 1], points2[pointIndex + 2]);
       const point2 = projectPlane ? projectPlane.projectPoint(rawPoint, tempProjectedPoint) : rawPoint;
       const distanceToPlane = Math.abs(plane.distanceToPoint(point2));
       if (distanceToPlane > tolerance) {
@@ -2063,7 +2063,7 @@ var WallSubdivisionAnalyzer2 = class {
    *     { projectPlane: plane }
    * );
    */
-  analyzePointDistribution(wallGroup, points, tolerance = 0.01, options = {}) {
+  analyzePointDistribution(wallGroup, points2, tolerance = 0.01, options = {}) {
     const projectPlane = options.projectPlane || null;
     this.results = {
       totalSegments: 0,
@@ -2129,8 +2129,8 @@ var WallSubdivisionAnalyzer2 = class {
     plane.setFromCoplanarPoints(p0, p1, p3);
     const temp = new Vector35();
     const tempProjectedPoint = new Vector35();
-    for (let pointIndex = 0; pointIndex < points.length; pointIndex++) {
-      const rawPoint = points[pointIndex];
+    for (let pointIndex = 0; pointIndex < points2.length; pointIndex++) {
+      const rawPoint = points2[pointIndex];
       const point2 = projectPlane ? projectPlane.projectPoint(rawPoint, tempProjectedPoint) : rawPoint;
       const distanceToPlane = Math.abs(plane.distanceToPoint(point2));
       if (distanceToPlane > tolerance) {
@@ -2558,10 +2558,10 @@ import { Vector3 as Vector37 } from "three";
 var PointsUtils = class {
   points = [];
   _tempArr = [0, 0, 0];
-  constructor(points) {
+  constructor(points2) {
   }
-  initPoints(points) {
-    this.points = points;
+  initPoints(points2) {
+    this.points = points2;
   }
   getPointByIndex(index, target) {
     const i = index * 3;
@@ -2584,17 +2584,17 @@ var PointsUtils = class {
     arr.push(index * 3 + 1);
     arr.push(index * 3 + 2);
   }
-  pointsToVector3Arr(points) {
+  pointsToVector3Arr(points2) {
     const vecArr = [];
-    for (let i = 0; i < points.length / 3; i++) {
-      vecArr.push(new Vector37(points[i * 3], points[i * 3 + 1], points[i * 3 + 2]));
+    for (let i = 0; i < points2.length / 3; i++) {
+      vecArr.push(new Vector37(points2[i * 3], points2[i * 3 + 1], points2[i * 3 + 2]));
     }
     return vecArr;
   }
-  vector3ArrToPoints(points) {
+  vector3ArrToPoints(points2) {
     const arr = [];
-    for (let i = 0; i < points.length; i++) {
-      arr.push(points[i].x, points[i].y, points[i].z);
+    for (let i = 0; i < points2.length; i++) {
+      arr.push(points2[i].x, points2[i].y, points2[i].z);
     }
     return arr;
   }
@@ -2717,10 +2717,10 @@ var isParallel = (v1, v2, tolerance = 0.01) => {
     angle
   };
 };
-var getPointCloudData = (points, gridWidth, gridHeight, centerPts) => {
+var getPointCloudData = (points2, gridWidth, gridHeight, centerPts) => {
   if (gridWidth < 1e-4 || gridHeight < 1e-4)
     return {};
-  const pts = points;
+  const pts = points2;
   let clonedCenterPts = [];
   if (centerPts && centerPts.length) {
     clonedCenterPts = centerPts.map((p) => p.clone());
@@ -3011,27 +3011,27 @@ function closestDistanceBetweenSegments(A, B2, C, D2) {
   const closest2 = C.clone().add(CD.clone().multiplyScalar(t));
   return closest1.distanceTo(closest2);
 }
-var getPointsMinAndMax = (points) => {
+var getPointsMinAndMax = (points2) => {
   let minZ = 999999;
   let maxZ = -999999;
   let minZPt = new THREE3.Vector3();
   let maxZPt = new THREE3.Vector3();
   let averagePz2 = 0;
-  for (let i = 0; i < points.length; i++) {
-    if (points[i].z > maxZ) {
-      maxZ = points[i].z;
-      maxZPt.set(points[i].x, points[i].y, points[i].z);
+  for (let i = 0; i < points2.length; i++) {
+    if (points2[i].z > maxZ) {
+      maxZ = points2[i].z;
+      maxZPt.set(points2[i].x, points2[i].y, points2[i].z);
     }
-    if (points[i].z < minZ) {
-      minZ = points[i].z;
-      minZPt.set(points[i].x, points[i].y, points[i].z);
+    if (points2[i].z < minZ) {
+      minZ = points2[i].z;
+      minZPt.set(points2[i].x, points2[i].y, points2[i].z);
     }
-    averagePz2 += points[i].z;
+    averagePz2 += points2[i].z;
   }
-  averagePz2 = averagePz2 / points.length;
+  averagePz2 = averagePz2 / points2.length;
   return { minZ, maxZ, averagePz: averagePz2, minZPt, maxZPt };
 };
-var getProjectedPointOnLine = (lineSt, lineEd, points) => {
+var getProjectedPointOnLine = (lineSt, lineEd, points2) => {
   let plane = new THREE3.Plane();
   const regionPt1 = new THREE3.Vector3(lineSt.x, lineSt.y, lineSt.z);
   const regionPt2 = new THREE3.Vector3(lineEd.x, lineEd.y, lineEd.z);
@@ -3039,7 +3039,7 @@ var getProjectedPointOnLine = (lineSt, lineEd, points) => {
   plane.setFromCoplanarPoints(regionPt1, regionPt2, regionPt3);
   const projectPoints = [];
   const origionProjectPoints = [];
-  points.forEach((point2) => {
+  points2.forEach((point2) => {
     const target = new THREE3.Vector3();
     plane.projectPoint(point2, target);
     origionProjectPoints.push(target.clone());
@@ -3058,7 +3058,7 @@ var getProjectedPointOnLine = (lineSt, lineEd, points) => {
   projectPoints.forEach((point2, i) => {
     let ptClose = line3Tmp.closestPointToPoint(point2, true, ptTarget);
     if (ptClose.distanceTo(point2) < 1e-3) {
-      newOriginalPoints.push(points[i]);
+      newOriginalPoints.push(points2[i]);
       newOnLinePoints.push(origionProjectPoints[i]);
     } else {
       newProjectPoints.push(point2);
@@ -3229,15 +3229,15 @@ var isPointOnLine2 = (lineStart, lineEnd, point2, tolerance = 1e-6) => {
   line2.closestPointToPoint(new THREE3.Vector3(point2.x, point2.y, point2.z), true, closestPoint);
   return closestPoint.distanceTo(new THREE3.Vector3(point2.x, point2.y, point2.z)) < tolerance;
 };
-var getFarthestPoints = (points) => {
+var getFarthestPoints = (points2) => {
   let maxDist = 0;
   let result = [];
-  for (let i = 0; i < points.length; i++) {
-    for (let j = i + 1; j < points.length; j++) {
-      const dist3 = points[i].distanceTo(points[j]);
+  for (let i = 0; i < points2.length; i++) {
+    for (let j = i + 1; j < points2.length; j++) {
+      const dist3 = points2[i].distanceTo(points2[j]);
       if (dist3 > maxDist) {
         maxDist = dist3;
-        result = [points[i], points[j]];
+        result = [points2[i], points2[j]];
       }
     }
   }
@@ -3252,10 +3252,10 @@ var randomLightHex = () => {
   const b = Math.floor(Math.random() * 75 + 180).toString(16).padStart(2, "0");
   return `#${r}${g}${b}`;
 };
-var uniqueVector3ByTolerance = (points, tolerance = 1e-3) => {
+var uniqueVector3ByTolerance = (points2, tolerance = 1e-3) => {
   const map = /* @__PURE__ */ new Map();
   const result = [];
-  for (const p of points) {
+  for (const p of points2) {
     const ix = Math.round(p.x / tolerance);
     const iy = Math.round(p.y / tolerance);
     const iz = Math.round(p.z / tolerance);
@@ -3278,7 +3278,7 @@ var getOBBPoints = (obb) => {
   function makePoint(sx, sy, sz) {
     return center.clone().addScaledVector(xAxis, sx).addScaledVector(yAxis, sy).addScaledVector(zAxis, sz);
   }
-  const points = [
+  const points2 = [
     // 下方一圈，局部 Z = -1
     makePoint(-1, -1, -1),
     makePoint(1, -1, -1),
@@ -3290,7 +3290,7 @@ var getOBBPoints = (obb) => {
     makePoint(1, 1, 1),
     makePoint(-1, 1, 1)
   ];
-  return points;
+  return points2;
 };
 var createBoxGeometryFromRectPoints = (rectPoints, height) => {
   const p0 = rectPoints[0];
@@ -3318,12 +3318,12 @@ var createBoxGeometryFromRectPoints = (rectPoints, height) => {
   geometry.computeVertexNormals();
   return geometry;
 };
-var getPointSetCentroid = (points) => {
-  if (!points || points.length === 0) {
+var getPointSetCentroid = (points2) => {
+  if (!points2 || points2.length === 0) {
     return null;
   }
   const center = new THREE3.Vector3(0, 0, 0);
-  for (const p of points) {
+  for (const p of points2) {
     if (Array.isArray(p)) {
       center.x += p[0];
       center.y += p[1];
@@ -3334,18 +3334,18 @@ var getPointSetCentroid = (points) => {
       center.z += p.z;
     }
   }
-  center.divideScalar(points.length);
+  center.divideScalar(points2.length);
   return center;
 };
-var calculatePolygonArea = (points) => {
-  if (!points || points.length < 3) {
+var calculatePolygonArea = (points2) => {
+  if (!points2 || points2.length < 3) {
     return 0;
   }
-  let isArray = Array.isArray(points[0]);
+  let isArray = Array.isArray(points2[0]);
   let area2 = 0;
-  for (let i = 0; i < points.length; i++) {
-    const p1 = points[i];
-    const p2 = points[(i + 1) % points.length];
+  for (let i = 0; i < points2.length; i++) {
+    const p1 = points2[i];
+    const p2 = points2[(i + 1) % points2.length];
     if (isArray) {
       area2 += p1[0] * p2[1] - p2[0] * p1[1];
     } else {
@@ -3447,11 +3447,11 @@ function pointToSegmentDistance(p, a, b) {
     p.y - y
   );
 }
-var voxelDownsample2DForContour = (points, cellSize) => {
-  if (!points || points.length === 0) return [];
+var voxelDownsample2DForContour = (points2, cellSize) => {
+  if (!points2 || points2.length === 0) return [];
   const map = /* @__PURE__ */ new Map();
-  for (let i = 0; i < points.length; i++) {
-    const p = points[i];
+  for (let i = 0; i < points2.length; i++) {
+    const p = points2[i];
     const x = p[0];
     const y = p[1];
     const gx = Math.floor(x / cellSize);
@@ -3506,10 +3506,10 @@ var voxelDownsample2DForContour = (points, cellSize) => {
   }
   return result;
 };
-var setPointsSameZ = (points, z) => {
-  for (let i = 0; i < points.length; i++)
-    points[i].z = z;
-  return points;
+var setPointsSameZ = (points2, z) => {
+  for (let i = 0; i < points2.length; i++)
+    points2[i].z = z;
+  return points2;
 };
 
 // src/utils/updateLine.mjs
@@ -3618,12 +3618,12 @@ function isPointInRect2D(point2, rectPoints, plane = "xy") {
   }
   return true;
 }
-function getPointSetCentroid2(points) {
-  if (!points || points.length === 0) {
+function getPointSetCentroid2(points2) {
+  if (!points2 || points2.length === 0) {
     return null;
   }
   const center = new THREE4.Vector3(0, 0, 0);
-  for (const p of points) {
+  for (const p of points2) {
     if (Array.isArray(p)) {
       center.x += p[0];
       center.y += p[1];
@@ -3634,7 +3634,7 @@ function getPointSetCentroid2(points) {
       center.z += p.z;
     }
   }
-  center.divideScalar(points.length);
+  center.divideScalar(points2.length);
   return center;
 }
 function toVector3(p) {
@@ -3701,17 +3701,17 @@ function eigenVector2x2(a, b, c) {
     y: y / len
   };
 }
-function getTrendLineEndpoints(points, options = {}) {
+function getTrendLineEndpoints(points2, options = {}) {
   const {
     plane = "xy",
     // 0 表示完全取最远两端
     // 0.05 表示两端各去掉 5% 离群点
     trimRatio = 0
   } = options;
-  if (!points || points.length < 2) {
+  if (!points2 || points2.length < 2) {
     return null;
   }
-  const pts = points.map((p) => get2D1(p, plane));
+  const pts = points2.map((p) => get2D1(p, plane));
   let meanX = 0;
   let meanY = 0;
   let meanUp = 0;
@@ -5510,7 +5510,7 @@ function splitSegmentsAtIntersections(inputSegments, project, EPS = 1e-6) {
     const segA = inputSegments[i];
     const a1 = project(segA.start);
     const a2 = project(segA.end);
-    const points = [
+    const points2 = [
       {
         t: 0,
         point: clonePoint(segA.start)
@@ -5528,15 +5528,15 @@ function splitSegmentsAtIntersections(inputSegments, project, EPS = 1e-6) {
       const hit = segmentIntersection(a1, a2, b1, b2, EPS);
       if (!hit) continue;
       if (hit.t > EPS && hit.t < 1 - EPS) {
-        points.push({
+        points2.push({
           t: hit.t,
           point: lerpPoint(segA.start, segA.end, hit.t)
         });
       }
     }
-    points.sort((p1, p2) => p1.t - p2.t);
+    points2.sort((p1, p2) => p1.t - p2.t);
     const uniquePoints = [];
-    for (const p of points) {
+    for (const p of points2) {
       if (uniquePoints.length === 0 || Math.abs(p.t - uniquePoints[uniquePoints.length - 1].t) > EPS) {
         uniquePoints.push(p);
       }
@@ -5597,11 +5597,11 @@ function dist2(a, b) {
   const dy = a.y - b.y;
   return dx * dx + dy * dy;
 }
-function signedArea(points) {
+function signedArea(points2) {
   let area2 = 0;
-  for (let i = 0; i < points.length; i++) {
-    const p = points[i];
-    const q = points[(i + 1) % points.length];
+  for (let i = 0; i < points2.length; i++) {
+    const p = points2[i];
+    const q = points2[(i + 1) % points2.length];
     area2 += p.x * q.y - q.x * p.y;
   }
   return area2 / 2;
@@ -5629,7 +5629,7 @@ function clonePoint(p) {
 
 // src/geometry/colLine.mjs
 import * as gfx from "rm-gxf-computing-rusts";
-var getColLine = (lines, runDataList, collectDataPath, pointCloudCluster = null) => {
+var getColLine = async (lines, runDataList, collectDataPath, pointCloudCluster = null) => {
   if (!lines || lines.length <= 0) return;
   let colDatas = {
     rectangles: [],
@@ -5958,8 +5958,105 @@ var getColLine = (lines, runDataList, collectDataPath, pointCloudCluster = null)
       colDatas.threeEdgeRect.push(colIndexs);
     }
   }
+  if (colDatas.threeEdgeRect) {
+    let trajectoryObj = {};
+    for (let r = 0; r < runDataList.length; r++) {
+      trajectoryObj[r] = runDataList[r];
+    }
+    let lines2 = [];
+    for (let i = 0; i < colDatas.threeEdgeRect.length; i++) {
+      const data = colDatas.threeEdgeRect[i];
+      const start = data.missingEdge.start;
+      const end = data.missingEdge.end;
+      const direction = new THREE6.Vector3().subVectors(end, start).normalize();
+      let tmpLineData = {
+        checkResults: [],
+        direction,
+        start,
+        end,
+        rooftopPz: data.rooftopPz,
+        originalPoints: [],
+        length: start.distanceTo(end),
+        index: i
+      };
+      getOneLineCheckResults(tmpLineData);
+      if (tmpLineData.checkResults.length != 1) continue;
+      lines2.push(tmpLineData);
+    }
+    await penetratingTask(lines2, trajectoryObj, collectDataPath);
+    for (let i = 0; i < lines2.length; i++) {
+      let len = lines2[i].checkResults[0].allCenterPoints.length;
+      const allCenterPoints = lines2[i].allCenterPoints;
+      let newPoints = [];
+      if (pointCloudCluster != null) {
+        let clusterResult = pointCloudCluster([allCenterPoints], {
+          tolerance: 0.1,
+          minClusterSize: 30,
+          maxClusterSize: 1e7,
+          threadCount: 1
+        });
+        if (clusterResult.length > 0) {
+          let maxNum = 0;
+          for (const cluster of clusterResult[0]) {
+            if (cluster.length < 50) continue;
+            const newOriginalPoints = cluster.map((i2) => points[i2]);
+            if (maxNum < newOriginalPoints.length) {
+              maxNum = newOriginalPoints.length;
+              newPoints = newOriginalPoints;
+            }
+          }
+        } else
+          newPoints = allCenterPoints;
+      } else
+        newPoints = allCenterPoints;
+      let retNum = newPoints.length;
+      let ps = retNum / len * 100;
+      if (ps < 60) {
+        colDatas.threeEdgeRect[lines2[i].index].isDel = true;
+      }
+    }
+    colDatas.threeEdgeRect = colDatas.threeEdgeRect.filter((p) => !p.isDel);
+  }
   return colDatas;
 };
+var penetratingTask = async (finalLines, trajectoryObj, collectDataPath, type = "normal", diff = 0.01) => {
+  if (!finalLines.length) return finalLines;
+  const offsets = [];
+  for (let i = 0; i < finalLines[0].checkResults[0].originalVertices.length; i++) {
+    offsets.push(0.01);
+  }
+  finalLines[0].checkResults[0].offsets = offsets;
+  const t = performance.now();
+  const pcdDir = type === "normal" || "res" ? `${collectDataPath}/pcd` : `${collectDataPath}/customData/pcd`;
+  const floatArray = await gfx.squareBackfacePointCloudTestAsync({
+    base: type === "normal" || "res" ? `${collectDataPath}` : `${collectDataPath}/customData`,
+    lines: finalLines,
+    trajectorys: trajectoryObj,
+    pcdDir,
+    distProjection: false,
+    view: false
+  });
+  console.log("\u6D88\u8017\u65F6\u95F4\uFF1A", performance.now() - t, "ms");
+  const data = floatArray;
+  finalLines.forEach((line2) => {
+    line2.allNewPoints = [];
+    line2.allNewSegments = [];
+  });
+  for (let n = 0; n < data.length; n += 4) {
+    const i = data[n];
+    const j = data[n + 1];
+    const k = data[n + 2];
+    const l = data[n + 3];
+    const line2 = finalLines[i];
+    const item = line2.checkResults[j];
+    const vertices = item.originalVertices[k];
+    const center = item.allCenterPoints[k];
+    if (!line2.allCenterPoints)
+      line2.allCenterPoints = [center];
+    else
+      line2.allCenterPoints.push(center);
+  }
+};
 
 // src/pointCloudProcessing/mergeMeaning.mjs
 import * as THREE8 from "three";
@@ -6338,11 +6435,11 @@ var Delaunator = class _Delaunator {
    * @param {(p: P) => number} [getY]
    */
   // @ts-expect-error TS2322
-  static from(points, getX = defaultGetX, getY = defaultGetY) {
-    const n = points.length;
+  static from(points2, getX = defaultGetX, getY = defaultGetY) {
+    const n = points2.length;
     const coords = new Float64Array(n * 2);
     for (let i = 0; i < n; i++) {
-      const p = points[i];
+      const p = points2[i];
       coords[2 * i] = getX(p);
       coords[2 * i + 1] = getY(p);
     }
@@ -6819,19 +6916,19 @@ var Voronoi = class {
     return this;
   }
   _init() {
-    const { delaunay: { points, hull, triangles }, vectors } = this;
+    const { delaunay: { points: points2, hull, triangles }, vectors } = this;
     let bx, by;
     const circumcenters = this.circumcenters = this._circumcenters.subarray(0, triangles.length / 3 * 2);
     for (let i = 0, j = 0, n = triangles.length, x, y; i < n; i += 3, j += 2) {
       const t1 = triangles[i] * 2;
       const t2 = triangles[i + 1] * 2;
       const t3 = triangles[i + 2] * 2;
-      const x12 = points[t1];
-      const y12 = points[t1 + 1];
-      const x2 = points[t2];
-      const y2 = points[t2 + 1];
-      const x3 = points[t3];
-      const y3 = points[t3 + 1];
+      const x12 = points2[t1];
+      const y12 = points2[t1 + 1];
+      const x2 = points2[t2];
+      const y2 = points2[t2 + 1];
+      const x3 = points2[t3];
+      const y3 = points2[t3 + 1];
       const dx = x2 - x12;
       const dy = y2 - y12;
       const ex = x3 - x12;
@@ -6840,7 +6937,7 @@ var Voronoi = class {
       if (Math.abs(ab4) < 1e-9) {
         if (bx === void 0) {
           bx = by = 0;
-          for (const i2 of hull) bx += points[i2 * 2], by += points[i2 * 2 + 1];
+          for (const i2 of hull) bx += points2[i2 * 2], by += points2[i2 * 2 + 1];
           bx /= hull.length, by /= hull.length;
         }
         const a = 1e9 * Math.sign((bx - x12) * ey - (by - y12) * ex);
@@ -6858,13 +6955,13 @@ var Voronoi = class {
     }
     let h = hull[hull.length - 1];
     let p0, p1 = h * 4;
-    let x0, x1 = points[2 * h];
-    let y0, y1 = points[2 * h + 1];
+    let x0, x1 = points2[2 * h];
+    let y0, y1 = points2[2 * h + 1];
     vectors.fill(0);
     for (let i = 0; i < hull.length; ++i) {
       h = hull[i];
       p0 = p1, x0 = x1, y0 = y1;
-      p1 = h * 4, x1 = points[2 * h], y1 = points[2 * h + 1];
+      p1 = h * 4, x1 = points2[2 * h], y1 = points2[2 * h + 1];
       vectors[p0 + 2] = vectors[p1] = y0 - y1;
       vectors[p0 + 3] = vectors[p1 + 1] = x1 - x0;
     }
@@ -6903,21 +7000,21 @@ var Voronoi = class {
   }
   renderCell(i, context) {
     const buffer = context == null ? context = new Path() : void 0;
-    const points = this._clip(i);
-    if (points === null || !points.length) return;
-    context.moveTo(points[0], points[1]);
-    let n = points.length;
-    while (points[0] === points[n - 2] && points[1] === points[n - 1] && n > 1) n -= 2;
+    const points2 = this._clip(i);
+    if (points2 === null || !points2.length) return;
+    context.moveTo(points2[0], points2[1]);
+    let n = points2.length;
+    while (points2[0] === points2[n - 2] && points2[1] === points2[n - 1] && n > 1) n -= 2;
     for (let i2 = 2; i2 < n; i2 += 2) {
-      if (points[i2] !== points[i2 - 2] || points[i2 + 1] !== points[i2 - 1])
-        context.lineTo(points[i2], points[i2 + 1]);
+      if (points2[i2] !== points2[i2 - 2] || points2[i2 + 1] !== points2[i2 - 1])
+        context.lineTo(points2[i2], points2[i2 + 1]);
     }
     context.closePath();
     return buffer && buffer.value();
   }
   *cellPolygons() {
-    const { delaunay: { points } } = this;
-    for (let i = 0, n = points.length / 2; i < n; ++i) {
+    const { delaunay: { points: points2 } } = this;
+    for (let i = 0, n = points2.length / 2; i < n; ++i) {
       const cell = this.cellPolygon(i);
       if (cell) cell.index = i, yield cell;
     }
@@ -6961,35 +7058,35 @@ var Voronoi = class {
     const { circumcenters, delaunay: { inedges, halfedges, triangles } } = this;
     const e0 = inedges[i];
     if (e0 === -1) return null;
-    const points = [];
+    const points2 = [];
     let e = e0;
     do {
       const t = Math.floor(e / 3);
-      points.push(circumcenters[t * 2], circumcenters[t * 2 + 1]);
+      points2.push(circumcenters[t * 2], circumcenters[t * 2 + 1]);
       e = e % 3 === 2 ? e - 2 : e + 1;
       if (triangles[e] !== i) break;
       e = halfedges[e];
     } while (e !== e0 && e !== -1);
-    return points;
+    return points2;
   }
   _clip(i) {
     if (i === 0 && this.delaunay.hull.length === 1) {
       return [this.xmax, this.ymin, this.xmax, this.ymax, this.xmin, this.ymax, this.xmin, this.ymin];
     }
-    const points = this._cell(i);
-    if (points === null) return null;
+    const points2 = this._cell(i);
+    if (points2 === null) return null;
     const { vectors: V } = this;
     const v2 = i * 4;
-    return this._simplify(V[v2] || V[v2 + 1] ? this._clipInfinite(i, points, V[v2], V[v2 + 1], V[v2 + 2], V[v2 + 3]) : this._clipFinite(i, points));
+    return this._simplify(V[v2] || V[v2 + 1] ? this._clipInfinite(i, points2, V[v2], V[v2 + 1], V[v2 + 2], V[v2 + 3]) : this._clipFinite(i, points2));
   }
-  _clipFinite(i, points) {
-    const n = points.length;
+  _clipFinite(i, points2) {
+    const n = points2.length;
     let P = null;
-    let x0, y0, x1 = points[n - 2], y1 = points[n - 1];
+    let x0, y0, x1 = points2[n - 2], y1 = points2[n - 1];
     let c0, c1 = this._regioncode(x1, y1);
     let e0, e1 = 0;
     for (let j = 0; j < n; j += 2) {
-      x0 = x1, y0 = y1, x1 = points[j], y1 = points[j + 1];
+      x0 = x1, y0 = y1, x1 = points2[j], y1 = points2[j + 1];
       c0 = c1, c1 = this._regioncode(x1, y1);
       if (c0 === 0 && c1 === 0) {
         e0 = e1, e1 = 0;
@@ -7037,8 +7134,8 @@ var Voronoi = class {
       else x1 = x, y1 = y, c1 = this._regioncode(x1, y1);
     }
   }
-  _clipInfinite(i, points, vx0, vy0, vxn, vyn) {
-    let P = Array.from(points), p;
+  _clipInfinite(i, points2, vx0, vy0, vxn, vyn) {
+    let P = Array.from(points2), p;
     if (p = this._project(P[0], P[1], vx0, vy0)) P.unshift(p[0], p[1]);
     if (p = this._project(P[P.length - 2], P[P.length - 1], vxn, vyn)) P.push(p[0], p[1]);
     if (P = this._clipFinite(i, P)) {
@@ -7152,13 +7249,13 @@ function jitter(x, y, r) {
   return [x + Math.sin(x + y) * r, y + Math.cos(x - y) * r];
 }
 var Delaunay = class _Delaunay {
-  static from(points, fx = pointX, fy = pointY, that) {
-    return new _Delaunay("length" in points ? flatArray(points, fx, fy, that) : Float64Array.from(flatIterable(points, fx, fy, that)));
+  static from(points2, fx = pointX, fy = pointY, that) {
+    return new _Delaunay("length" in points2 ? flatArray(points2, fx, fy, that) : Float64Array.from(flatIterable(points2, fx, fy, that)));
   }
-  constructor(points) {
-    this._delaunator = new Delaunator(points);
-    this.inedges = new Int32Array(points.length / 2);
-    this._hullIndex = new Int32Array(points.length / 2);
+  constructor(points2) {
+    this._delaunator = new Delaunator(points2);
+    this.inedges = new Int32Array(points2.length / 2);
+    this._hullIndex = new Int32Array(points2.length / 2);
     this.points = this._delaunator.coords;
     this._init();
   }
@@ -7168,16 +7265,16 @@ var Delaunay = class _Delaunay {
     return this;
   }
   _init() {
-    const d = this._delaunator, points = this.points;
+    const d = this._delaunator, points2 = this.points;
     if (d.hull && d.hull.length > 2 && collinear(d)) {
-      this.collinear = Int32Array.from({ length: points.length / 2 }, (_, i) => i).sort((i, j) => points[2 * i] - points[2 * j] || points[2 * i + 1] - points[2 * j + 1]);
-      const e = this.collinear[0], f = this.collinear[this.collinear.length - 1], bounds = [points[2 * e], points[2 * e + 1], points[2 * f], points[2 * f + 1]], r = 1e-8 * Math.hypot(bounds[3] - bounds[1], bounds[2] - bounds[0]);
-      for (let i = 0, n = points.length / 2; i < n; ++i) {
-        const p = jitter(points[2 * i], points[2 * i + 1], r);
-        points[2 * i] = p[0];
-        points[2 * i + 1] = p[1];
-      }
-      this._delaunator = new Delaunator(points);
+      this.collinear = Int32Array.from({ length: points2.length / 2 }, (_, i) => i).sort((i, j) => points2[2 * i] - points2[2 * j] || points2[2 * i + 1] - points2[2 * j + 1]);
+      const e = this.collinear[0], f = this.collinear[this.collinear.length - 1], bounds = [points2[2 * e], points2[2 * e + 1], points2[2 * f], points2[2 * f + 1]], r = 1e-8 * Math.hypot(bounds[3] - bounds[1], bounds[2] - bounds[0]);
+      for (let i = 0, n = points2.length / 2; i < n; ++i) {
+        const p = jitter(points2[2 * i], points2[2 * i + 1], r);
+        points2[2 * i] = p[0];
+        points2[2 * i + 1] = p[1];
+      }
+      this._delaunator = new Delaunator(points2);
     } else {
       delete this.collinear;
     }
@@ -7239,15 +7336,15 @@ var Delaunay = class _Delaunay {
     return c;
   }
   _step(i, x, y) {
-    const { inedges, hull, _hullIndex, halfedges, triangles, points } = this;
-    if (inedges[i] === -1 || !points.length) return (i + 1) % (points.length >> 1);
+    const { inedges, hull, _hullIndex, halfedges, triangles, points: points2 } = this;
+    if (inedges[i] === -1 || !points2.length) return (i + 1) % (points2.length >> 1);
     let c = i;
-    let dc = pow(x - points[i * 2], 2) + pow(y - points[i * 2 + 1], 2);
+    let dc = pow(x - points2[i * 2], 2) + pow(y - points2[i * 2 + 1], 2);
     const e0 = inedges[i];
     let e = e0;
     do {
       let t = triangles[e];
-      const dt = pow(x - points[t * 2], 2) + pow(y - points[t * 2 + 1], 2);
+      const dt = pow(x - points2[t * 2], 2) + pow(y - points2[t * 2 + 1], 2);
       if (dt < dc) dc = dt, c = t;
       e = e % 3 === 2 ? e - 2 : e + 1;
       if (triangles[e] !== i) break;
@@ -7255,7 +7352,7 @@ var Delaunay = class _Delaunay {
       if (e === -1) {
         e = hull[(_hullIndex[i] + 1) % hull.length];
         if (e !== t) {
-          if (pow(x - points[e * 2], 2) + pow(y - points[e * 2 + 1], 2) < dc) return e;
+          if (pow(x - points2[e * 2], 2) + pow(y - points2[e * 2 + 1], 2) < dc) return e;
         }
         break;
       }
@@ -7264,14 +7361,14 @@ var Delaunay = class _Delaunay {
   }
   render(context) {
     const buffer = context == null ? context = new Path() : void 0;
-    const { points, halfedges, triangles } = this;
+    const { points: points2, halfedges, triangles } = this;
     for (let i = 0, n = halfedges.length; i < n; ++i) {
       const j = halfedges[i];
       if (j < i) continue;
       const ti = triangles[i] * 2;
       const tj = triangles[j] * 2;
-      context.moveTo(points[ti], points[ti + 1]);
-      context.lineTo(points[tj], points[tj + 1]);
+      context.moveTo(points2[ti], points2[ti + 1]);
+      context.lineTo(points2[tj], points2[tj + 1]);
     }
     this.renderHull(context);
     return buffer && buffer.value();
@@ -7280,9 +7377,9 @@ var Delaunay = class _Delaunay {
     if (r === void 0 && (!context || typeof context.moveTo !== "function")) r = context, context = null;
     r = r == void 0 ? 2 : +r;
     const buffer = context == null ? context = new Path() : void 0;
-    const { points } = this;
-    for (let i = 0, n = points.length; i < n; i += 2) {
-      const x = points[i], y = points[i + 1];
+    const { points: points2 } = this;
+    for (let i = 0, n = points2.length; i < n; i += 2) {
+      const x = points2[i], y = points2[i + 1];
       context.moveTo(x + r, y);
       context.arc(x, y, r, 0, tau);
     }
@@ -7290,12 +7387,12 @@ var Delaunay = class _Delaunay {
   }
   renderHull(context) {
     const buffer = context == null ? context = new Path() : void 0;
-    const { hull, points } = this;
+    const { hull, points: points2 } = this;
     const h = hull[0] * 2, n = hull.length;
-    context.moveTo(points[h], points[h + 1]);
+    context.moveTo(points2[h], points2[h + 1]);
     for (let i = 1; i < n; ++i) {
       const h2 = 2 * hull[i];
-      context.lineTo(points[h2], points[h2 + 1]);
+      context.lineTo(points2[h2], points2[h2 + 1]);
     }
     context.closePath();
     return buffer && buffer.value();
@@ -7307,13 +7404,13 @@ var Delaunay = class _Delaunay {
   }
   renderTriangle(i, context) {
     const buffer = context == null ? context = new Path() : void 0;
-    const { points, triangles } = this;
+    const { points: points2, triangles } = this;
     const t0 = triangles[i *= 3] * 2;
     const t1 = triangles[i + 1] * 2;
     const t2 = triangles[i + 2] * 2;
-    context.moveTo(points[t0], points[t0 + 1]);
-    context.lineTo(points[t1], points[t1 + 1]);
-    context.lineTo(points[t2], points[t2 + 1]);
+    context.moveTo(points2[t0], points2[t0 + 1]);
+    context.lineTo(points2[t1], points2[t1 + 1]);
+    context.lineTo(points2[t2], points2[t2 + 1]);
     context.closePath();
     return buffer && buffer.value();
   }
@@ -7329,21 +7426,21 @@ var Delaunay = class _Delaunay {
     return polygon2.value();
   }
 };
-function flatArray(points, fx, fy, that) {
-  const n = points.length;
+function flatArray(points2, fx, fy, that) {
+  const n = points2.length;
   const array = new Float64Array(n * 2);
   for (let i = 0; i < n; ++i) {
-    const p = points[i];
-    array[i * 2] = fx.call(that, p, i, points);
-    array[i * 2 + 1] = fy.call(that, p, i, points);
+    const p = points2[i];
+    array[i * 2] = fx.call(that, p, i, points2);
+    array[i * 2 + 1] = fy.call(that, p, i, points2);
   }
   return array;
 }
-function* flatIterable(points, fx, fy, that) {
+function* flatIterable(points2, fx, fy, that) {
   let i = 0;
-  for (const p of points) {
-    yield fx.call(that, p, i, points);
-    yield fy.call(that, p, i, points);
+  for (const p of points2) {
+    yield fx.call(that, p, i, points2);
+    yield fy.call(that, p, i, points2);
     ++i;
   }
 }
@@ -7369,12 +7466,12 @@ function addAdj(adj, i, j) {
   }
   arr.push(j);
 }
-function computeContour(points) {
-  if (!points || points.length < 3) return [];
+function computeContour(points2) {
+  if (!points2 || points2.length < 3) return [];
   const seen = /* @__PURE__ */ new Set();
   const uniq = [];
-  for (let i = 0; i < points.length; i++) {
-    const p = points[i];
+  for (let i = 0; i < points2.length; i++) {
+    const p = points2[i];
     const k = `${p[0]}_${p[1]}`;
     if (!seen.has(k)) {
       seen.add(k);
@@ -7830,14 +7927,14 @@ function geomReduce(geojson, callback, initialValue) {
 var import_concaveman = __toESM(require_concaveman(), 1);
 function convex(geojson, options = {}) {
   options.concavity = options.concavity || Infinity;
-  const points = [];
+  const points2 = [];
   coordEach(geojson, (coord) => {
-    points.push([coord[0], coord[1]]);
+    points2.push([coord[0], coord[1]]);
   });
-  if (!points.length) {
+  if (!points2.length) {
     return null;
   }
-  const convexHull = (0, import_concaveman.default)(points, options.concavity);
+  const convexHull = (0, import_concaveman.default)(points2, options.concavity);
   if (convexHull.length > 3) {
     return polygon([convexHull]);
   }
@@ -8288,9 +8385,9 @@ function distance(p1, p2) {
   const dy = p2[1] - p1[1];
   return Math.sqrt(dx * dx + dy * dy);
 }
-function getCenter(points) {
+function getCenter(points2) {
   let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-  for (const [x, y] of points) {
+  for (const [x, y] of points2) {
     if (x < minX) minX = x;
     if (x > maxX) maxX = x;
     if (y < minY) minY = y;
@@ -8437,14 +8534,14 @@ function calculateClosePointRatioWithGrid2(pointsA, pointsB, threshold = 5e-3, m
 function isNumber2(num) {
   return !isNaN(num) && num !== null && !Array.isArray(num);
 }
-function calculateClosePointWithOBB(points, box, maxCalculate = 0.5) {
+function calculateClosePointWithOBB(points2, box, maxCalculate = 0.5) {
   let closePointsCount = 0;
   let calculate = 0;
-  for (const point2 of points) {
+  for (const point2 of points2) {
     const inside = box.containsPoint(point2);
     if (inside) {
       closePointsCount++;
-      calculate = closePointsCount / points.length;
+      calculate = closePointsCount / points2.length;
       if (calculate > maxCalculate) {
         break;
       }
@@ -8480,32 +8577,32 @@ function compareBoxVolume(box1, box2) {
     return 0;
   }
 }
-function containsObbPoints(obb, points) {
+function containsObbPoints(obb, points2) {
   let contains = true;
-  for (let i = 0; i < points.length; i++) {
-    if (!obb.containsPoint(points[i])) {
+  for (let i = 0; i < points2.length; i++) {
+    if (!obb.containsPoint(points2[i])) {
       contains = false;
       break;
     }
   }
   return contains;
 }
-function getCenterAndPointHeight(points) {
-  if (points.length === 0)
+function getCenterAndPointHeight(points2) {
+  if (points2.length === 0)
     return { x: 0, y: 0, z: 0, h: 0 };
   let x = 0;
   let y = 0;
   let maxz = -Infinity;
   let minz = Infinity;
-  for (const p of points) {
+  for (const p of points2) {
     x += p.x;
     y += p.y;
     maxz = Math.max(maxz, p.z);
     minz = Math.min(minz, p.z);
   }
   return {
-    x: x / points.length,
-    y: y / points.length,
+    x: x / points2.length,
+    y: y / points2.length,
     z: 0,
     maxz,
     minz,
@@ -8538,19 +8635,19 @@ var drawStaircase = (pcdPointsArr, scene) => {
     side: THREE8.DoubleSide
   });
   for (let i = 0; i < pcdPointsArr.length; i++) {
-    const points = [];
+    const points2 = [];
     for (let j = 0; j < pcdPointsArr[i].path.length; j++) {
-      points.push(new THREE8.Vector3(
+      points2.push(new THREE8.Vector3(
         pcdPointsArr[i].path[j][0],
         pcdPointsArr[i].path[j][1],
         0
       ));
     }
-    if (points.length == 0)
+    if (points2.length == 0)
       continue;
     pointCloudGroup.add(pcdPointsArr[i].obb.getBoxEdge());
     const geometry3 = new THREE8.BufferGeometry();
-    geometry3.setFromPoints(points);
+    geometry3.setFromPoints(points2);
     const hex = "green";
     const _lineMaterial = new THREE8.LineBasicMaterial({ color: hex, depthTest: false, depthWrite: false });
     const line2 = new THREE8.Line(geometry3, _lineMaterial);
@@ -8600,7 +8697,7 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
   const pcdPointsArr = [];
   const mapMaxSortFloor = /* @__PURE__ */ new Map();
   for (let i = 0; i < allProjectionResults.length; i++) {
-    let points = allProjectionResults[i].points.map((p) => [p.x, p.y]);
+    let points2 = allProjectionResults[i].points.map((p) => [p.x, p.y]);
     let obj_id = allProjectionResults[i].obj_id;
     obj_id = obj_id.replace(/calcony railing/g, "balcony railing").replace(/glass balcony railing/g, "balcony railing").replace(/metal balcony railing/g, "balcony railing").replace(/temporary construction guardrail/g, "balcony railing").replace(/the floor of the house/g, "floor").replace(/the outdoor floor/g, "floor").replace(/roof/g, "Ceiling");
     const category = obj_id.split("_").slice(1, 3).join("_").split(".")[0].split("_")[0];
@@ -8651,8 +8748,8 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
       let mostFrequentEntry = [...mapSortPoint.entries()].reduce(
         (max, cur) => cur[1].num > max[1].num ? cur : max
       );
-      points = [];
-      points = mostFrequentEntry[1].points.map((p) => [p.x, p.y]);
+      points2 = [];
+      points2 = mostFrequentEntry[1].points.map((p) => [p.x, p.y]);
       threePoints = [];
       threePoints = mostFrequentEntry[1].points.map((p) => new THREE8.Vector3(p.x, p.y, p.z));
       floorZ = mostFrequentEntry[0];
@@ -8660,7 +8757,7 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
     const centerData = getCenterAndPointHeight(threePoints);
     const data = {
       points: threePoints,
-      path: computeContour(points),
+      path: computeContour(points2),
       h: centerData.h,
       minz: centerData.minz,
       maxz: centerData.maxz,
@@ -9127,15 +9224,15 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
       let newArray = [];
       for (let j = 0; j < array.length; j++) {
         if (delArray.has(j)) continue;
-        let points = array[j].points;
+        let points2 = array[j].points;
         let obj_id = array[j].obj_id;
         let type2 = array[j].type;
         let averagePz3 = array[j].averagePz;
         let positionArr = array[j].positionArr;
         let isStaircaseBalconyRailing = array[j].isStaircaseBalconyRailing;
-        if (points.length < 50)
+        if (points2.length < 50)
           continue;
-        let clusterResult = pointCloudCluster([points], {
+        let clusterResult = pointCloudCluster([points2], {
           tolerance: tolerancePointCloudCluster,
           minClusterSize: 50,
           maxClusterSize: 1e7,
@@ -9145,7 +9242,7 @@ var getMergeMeaning = (allProjectionResults, averagePz2, pointCloudCluster = nul
         if (clusterResult.length > 0 && clusterResult[0].length > 1) {
           for (const cluster of clusterResult[0]) {
             if (cluster.length < 50) continue;
-            const newOriginalPoints = cluster.map((i2) => points[i2]);
+            const newOriginalPoints = cluster.map((i2) => points2[i2]);
             const centerData = getCenterAndPointHeight(newOriginalPoints);
             let pathPoints = newOriginalPoints.map((p) => [p.x, p.y]);
             const data = {
@@ -9205,7 +9302,7 @@ var getMergeFloorMeaning = (allProjectionResults) => {
   const pcdPointsArr = [];
   const mapMaxSortFloor = /* @__PURE__ */ new Map();
   for (let i = 0; i < allProjectionResults.length; i++) {
-    let points = allProjectionResults[i].points.map((p) => [p.x, p.y]);
+    let points2 = allProjectionResults[i].points.map((p) => [p.x, p.y]);
     let obj_id = allProjectionResults[i].obj_id;
     obj_id = obj_id.replace(/the floor of the house/g, "floor").replace(/the outdoor floor/g, "floor");
     const category = obj_id.split("_").slice(1, 3).join("_").split(".")[0].split("_")[0];
@@ -9240,8 +9337,8 @@ var getMergeFloorMeaning = (allProjectionResults) => {
       let mostFrequentEntry = [...mapSortPoint.entries()].reduce(
         (max, cur) => cur[1].num > max[1].num ? cur : max
       );
-      points = [];
-      points = mostFrequentEntry[1].points.map((p) => [p.x, p.y]);
+      points2 = [];
+      points2 = mostFrequentEntry[1].points.map((p) => [p.x, p.y]);
       threePoints = [];
       threePoints = mostFrequentEntry[1].points.map((p) => new THREE8.Vector3(p.x, p.y, p.z));
       floorZ = mostFrequentEntry[0];
@@ -9249,7 +9346,7 @@ var getMergeFloorMeaning = (allProjectionResults) => {
     const centerData = getCenterAndPointHeight(threePoints);
     const data = {
       points: threePoints,
-      path: computeContour(points),
+      path: computeContour(points2),
       h: centerData.h,
       minz: centerData.minz,
       maxz: centerData.maxz,
@@ -9385,7 +9482,7 @@ var getStaircase = (allProjectionResults, scene) => {
     let pcdPointsArr = [];
     const floorAllProjectionResults = splitFloorProjectsResults[i];
     for (let i2 = 0; i2 < floorAllProjectionResults.length; i2++) {
-      let points = floorAllProjectionResults[i2].points.map((p) => [p.x, p.y]);
+      let points2 = floorAllProjectionResults[i2].points.map((p) => [p.x, p.y]);
       let obj_id = floorAllProjectionResults[i2].obj_id;
       obj_id = obj_id.replace(/the floor of the house/g, "floor").replace(/the outdoor floor/g, "floor").replace(/calcony railing/g, "balcony railing").replace(/glass balcony railing/g, "balcony railing").replace(/metal balcony railing/g, "balcony railing").replace(/temporary construction guardrail/g, "balcony railing");
       const category = obj_id.split("_").slice(1, 3).join("_").split(".")[0].split("_")[0];
@@ -9421,7 +9518,7 @@ var getStaircase = (allProjectionResults, scene) => {
       const centerData = getCenterAndPointHeight(threePoints);
       const data = {
         points: threePoints,
-        path: computeContour(points),
+        path: computeContour(points2),
         h: centerData.h,
         minz: centerData.minz,
         maxz: centerData.maxz,
@@ -9662,7 +9759,7 @@ var getStaircase = (allProjectionResults, scene) => {
       let minDist = 0.2;
       for (let i = 0; i < StaircaseArray.length; i++) {
         const size = StaircaseArray[i].obb.halfSize.clone().multiplyScalar(2);
-        const points = StaircaseArray[i].points;
+        const points2 = StaircaseArray[i].points;
         let width = size.x;
         let length2 = size.y;
         let height = size.z;
@@ -9688,31 +9785,31 @@ var getStaircase = (allProjectionResults, scene) => {
         let nearLine6PtArray = [];
         let nearLine7PtArray = [];
         let nearLine8PtArray = [];
-        for (let j = 0; j < points.length; j++) {
-          let pt1 = line1.closestPointToPoint(points[j], true, new THREE8.Vector3());
-          let pt2 = line2.closestPointToPoint(points[j], true, new THREE8.Vector3());
-          let pt3 = line3.closestPointToPoint(points[j], true, new THREE8.Vector3());
-          let pt4 = line4.closestPointToPoint(points[j], true, new THREE8.Vector3());
-          let pt5 = line5.closestPointToPoint(points[j], true, new THREE8.Vector3());
-          let pt6 = line6.closestPointToPoint(points[j], true, new THREE8.Vector3());
-          let pt7 = line7.closestPointToPoint(points[j], true, new THREE8.Vector3());
-          let pt8 = line8.closestPointToPoint(points[j], true, new THREE8.Vector3());
-          if (pt1.distanceTo(points[j]) < minDist)
-            nearLine1PtArray.push(points[j]);
-          if (pt2.distanceTo(points[j]) < minDist)
-            nearLine2PtArray.push(points[j]);
-          if (pt3.distanceTo(points[j]) < minDist)
-            nearLine3PtArray.push(points[j]);
-          if (pt4.distanceTo(points[j]) < minDist)
-            nearLine4PtArray.push(points[j]);
-          if (pt5.distanceTo(points[j]) < minDist)
-            nearLine5PtArray.push(points[j]);
-          if (pt6.distanceTo(points[j]) < minDist)
-            nearLine6PtArray.push(points[j]);
-          if (pt7.distanceTo(points[j]) < minDist)
-            nearLine7PtArray.push(points[j]);
-          if (pt8.distanceTo(points[j]) < minDist)
-            nearLine8PtArray.push(points[j]);
+        for (let j = 0; j < points2.length; j++) {
+          let pt1 = line1.closestPointToPoint(points2[j], true, new THREE8.Vector3());
+          let pt2 = line2.closestPointToPoint(points2[j], true, new THREE8.Vector3());
+          let pt3 = line3.closestPointToPoint(points2[j], true, new THREE8.Vector3());
+          let pt4 = line4.closestPointToPoint(points2[j], true, new THREE8.Vector3());
+          let pt5 = line5.closestPointToPoint(points2[j], true, new THREE8.Vector3());
+          let pt6 = line6.closestPointToPoint(points2[j], true, new THREE8.Vector3());
+          let pt7 = line7.closestPointToPoint(points2[j], true, new THREE8.Vector3());
+          let pt8 = line8.closestPointToPoint(points2[j], true, new THREE8.Vector3());
+          if (pt1.distanceTo(points2[j]) < minDist)
+            nearLine1PtArray.push(points2[j]);
+          if (pt2.distanceTo(points2[j]) < minDist)
+            nearLine2PtArray.push(points2[j]);
+          if (pt3.distanceTo(points2[j]) < minDist)
+            nearLine3PtArray.push(points2[j]);
+          if (pt4.distanceTo(points2[j]) < minDist)
+            nearLine4PtArray.push(points2[j]);
+          if (pt5.distanceTo(points2[j]) < minDist)
+            nearLine5PtArray.push(points2[j]);
+          if (pt6.distanceTo(points2[j]) < minDist)
+            nearLine6PtArray.push(points2[j]);
+          if (pt7.distanceTo(points2[j]) < minDist)
+            nearLine7PtArray.push(points2[j]);
+          if (pt8.distanceTo(points2[j]) < minDist)
+            nearLine8PtArray.push(points2[j]);
         }
         let len1 = obbPoints[0].distanceTo(obbPoints[1]);
         let len2 = obbPoints[1].distanceTo(obbPoints[2]);
@@ -10395,7 +10492,7 @@ function filterPointSetByMainDirection(inputPoints, options = {}) {
   const sideY = dirX;
   let minT = Infinity;
   let maxT = -Infinity;
-  const points = rawPoints.map((p) => {
+  const points2 = rawPoints.map((p) => {
     const dx = p.x - meanX;
     const dy = p.y - meanY;
     const t = dx * dirX + dy * dirY;
@@ -10411,7 +10508,7 @@ function filterPointSetByMainDirection(inputPoints, options = {}) {
   const totalT = maxT - minT || 1;
   const binSize = totalT / binCount;
   const bins = /* @__PURE__ */ new Map();
-  for (const p of points) {
+  for (const p of points2) {
     let bin = Math.floor((p.t - minT) / binSize);
     if (bin < 0) bin = 0;
     if (bin >= binCount) bin = binCount - 1;
@@ -10458,7 +10555,7 @@ function filterPointSetByMainDirection(inputPoints, options = {}) {
   }
   const keep = [];
   const removed = [];
-  for (const p of points) {
+  for (const p of points2) {
     let bin = Math.floor((p.t - minT) / binSize);
     if (bin < 0) bin = 0;
     if (bin >= binCount) bin = binCount - 1;
@@ -10502,10 +10599,10 @@ function medianSorted(arr) {
   }
   return arr[mid];
 }
-function buildPointGrid(points, cellSize) {
+function buildPointGrid(points2, cellSize) {
   const grid = /* @__PURE__ */ new Map();
-  for (let i = 0; i < points.length; i++) {
-    const p = points[i];
+  for (let i = 0; i < points2.length; i++) {
+    const p = points2[i];
     const ix = Math.floor(p.x / cellSize);
     const iy = Math.floor(p.y / cellSize);
     const iz = Math.floor(p.z / cellSize);
@@ -10517,8 +10614,8 @@ function buildPointGrid(points, cellSize) {
   }
   return grid;
 }
-function findPointNeighbors(points, grid, pointIndex, radius, radiusSq) {
-  const p = points[pointIndex];
+function findPointNeighbors(points2, grid, pointIndex, radius, radiusSq) {
+  const p = points2[pointIndex];
   const ix = Math.floor(p.x / radius);
   const iy = Math.floor(p.y / radius);
   const iz = Math.floor(p.z / radius);
@@ -10531,7 +10628,7 @@ function findPointNeighbors(points, grid, pointIndex, radius, radiusSq) {
         if (!list) continue;
         for (const candidateIndex of list) {
           if (candidateIndex === pointIndex) continue;
-          const q = points[candidateIndex];
+          const q = points2[candidateIndex];
           const ddx = p.x - q.x;
           const ddy = p.y - q.y;
           const ddz = p.z - q.z;
@@ -10577,18 +10674,18 @@ function removeSmallClustersKeepInfo(inputPoints, options = {}) {
   const {
     radius = 0.35
   } = options;
-  const points = inputPoints.map((p, index) => ({
+  const points2 = inputPoints.map((p, index) => ({
     index,
     x: p.x,
     y: p.y,
     z: p.z,
     raw: p
   }));
-  const grid = buildPointGrid(points, radius);
+  const grid = buildPointGrid(points2, radius);
   const radiusSq = radius * radius;
-  const visited = new Array(points.length).fill(false);
+  const visited = new Array(points2.length).fill(false);
   const clusters = [];
-  for (let i = 0; i < points.length; i++) {
+  for (let i = 0; i < points2.length; i++) {
     if (visited[i]) continue;
     const cluster = [];
     const queue = [i];
@@ -10597,7 +10694,7 @@ function removeSmallClustersKeepInfo(inputPoints, options = {}) {
       const currentIndex = queue.shift();
       cluster.push(currentIndex);
       const neighbors = findPointNeighbors(
-        points,
+        points2,
         grid,
         currentIndex,
         radius,
@@ -10613,7 +10710,7 @@ function removeSmallClustersKeepInfo(inputPoints, options = {}) {
     clusters.push(cluster);
   }
   return {
-    points,
+    points: points2,
     clusters
   };
 }
@@ -10658,8 +10755,8 @@ function obbContainsPoint(obb, point2, epsilon3 = 1e-6) {
 }
 
 // src/utils/clusert.mjs
-function alphaForTriangle(points, ia, ib, ic) {
-  const xZero = points[ia][0] === 0 || points[ib][0] === 0 || points[ic][0] === 0;
+function alphaForTriangle(points2, ia, ib, ic) {
+  const xZero = points2[ia][0] === 0 || points2[ib][0] === 0 || points2[ic][0] === 0;
   return 1 + (xZero ? 1 : 0);
 }
 function circumradius2(ax, ay, bx, by, cx, cy) {
@@ -10670,11 +10767,11 @@ function circumradius2(ax, ay, bx, by, cx, cy) {
   if (area2 === 0) return Infinity;
   return a * b * c / (4 * area2);
 }
-function computeContour2(points) {
-  if (!points || points.length < 3) return [];
+function computeContour2(points2) {
+  if (!points2 || points2.length < 3) return [];
   const seen = /* @__PURE__ */ new Set();
   const uniq = [];
-  for (const p of points) {
+  for (const p of points2) {
     const k = `${p[0]}_${p[1]}`;
     if (!seen.has(k)) {
       seen.add(k);
@@ -10766,28 +10863,28 @@ var getFlatSlabData = (lines, runDataList, pointCloudCluster = null) => {
   let maxPointsNum = 0;
   let maxPointsZ = 0;
   for (const line2 of lines) {
-    let points = line2[1].points;
-    if (points.length < 30) continue;
+    let points2 = line2[1].points;
+    if (points2.length < 30) continue;
     let mapSortPoint = /* @__PURE__ */ new Map();
-    for (let c = 0; c < points.length; c++) {
-      let z = points[c].z;
+    for (let c = 0; c < points2.length; c++) {
+      let z = points2[c].z;
       z = Math.floor(z * 10) / 10;
       if (mapSortPoint.has(z)) {
         const item = mapSortPoint.get(z);
         item.num += 1;
-        item.points.push(points[c]);
+        item.points.push(points2[c]);
         mapSortPoint.set(z, item);
       } else {
-        mapSortPoint.set(z, { num: 1, points: [points[c]] });
+        mapSortPoint.set(z, { num: 1, points: [points2[c]] });
       }
     }
     let mostFrequentEntry = [...mapSortPoint.entries()].reduce(
       (max, cur) => cur[1].num > max[1].num ? cur : max
     );
-    points = mostFrequentEntry[1].points.map((p) => new THREE9.Vector3(p.x, p.y, p.z));
+    points2 = mostFrequentEntry[1].points.map((p) => new THREE9.Vector3(p.x, p.y, p.z));
     let newPoints = [];
     if (pointCloudCluster != null) {
-      let clusterResult = pointCloudCluster([points], {
+      let clusterResult = pointCloudCluster([points2], {
         tolerance: 0.1,
         minClusterSize: 30,
         maxClusterSize: 1e7,
@@ -10796,13 +10893,13 @@ var getFlatSlabData = (lines, runDataList, pointCloudCluster = null) => {
       if (clusterResult.length > 0) {
         for (const cluster of clusterResult[0]) {
           if (cluster.length < 50) continue;
-          const newOriginalPoints = cluster.map((i) => points[i]);
+          const newOriginalPoints = cluster.map((i) => points2[i]);
           newPoints.push(newOriginalPoints);
         }
       } else
-        newPoints.push(points);
+        newPoints.push(points2);
     } else
-      newPoints.push(points);
+      newPoints.push(points2);
     for (let u4 = 0; u4 < newPoints.length; u4++) {
       let { minZ, maxZ, averagePz: averagePz2 } = getPointsMinAndMax(newPoints[u4]);
       const height = maxZ - minZ;
@@ -10875,10 +10972,10 @@ var getObliqueSlabData = (lines, runDataList, pointCloudCluster = null) => {
   }
   const averageZ = totalZ / (runDataList.length - 1) + 0.3;
   for (let i = 0; i < lines.length; i++) {
-    let points = lines[i][1].points;
+    let points2 = lines[i][1].points;
     let newPoints = [];
     if (pointCloudCluster != null) {
-      let clusterResult = pointCloudCluster([points], {
+      let clusterResult = pointCloudCluster([points2], {
         tolerance: 0.2,
         minClusterSize: 30,
         maxClusterSize: 1e7,
@@ -10887,13 +10984,13 @@ var getObliqueSlabData = (lines, runDataList, pointCloudCluster = null) => {
       if (clusterResult.length > 0) {
         for (const cluster of clusterResult[0]) {
           if (cluster.length < 50) continue;
-          const newOriginalPoints = cluster.map((i2) => points[i2]);
+          const newOriginalPoints = cluster.map((i2) => points2[i2]);
           newPoints.push(newOriginalPoints);
         }
       } else
-        newPoints.push(points);
+        newPoints.push(points2);
     } else
-      newPoints.push(points);
+      newPoints.push(points2);
     if (newPoints.length == 0)
       continue;
     for (let x = 0; x < newPoints.length; x++) {
@@ -10944,10 +11041,10 @@ var getObliqueSlabData = (lines, runDataList, pointCloudCluster = null) => {
   }
   slabDatas = [];
   for (let i = 0; i < newSlabDatas.length; i++) {
-    let points = newSlabDatas[i].points;
+    let points2 = newSlabDatas[i].points;
     let newPoints = [];
     if (pointCloudCluster != null) {
-      let clusterResult = pointCloudCluster([points], {
+      let clusterResult = pointCloudCluster([points2], {
         tolerance: 0.2,
         minClusterSize: 30,
         maxClusterSize: 1e7,
@@ -10956,13 +11053,13 @@ var getObliqueSlabData = (lines, runDataList, pointCloudCluster = null) => {
       if (clusterResult.length > 0) {
         for (const cluster of clusterResult[0]) {
           if (cluster.length < 50) continue;
-          const newOriginalPoints = cluster.map((i2) => points[i2]);
+          const newOriginalPoints = cluster.map((i2) => points2[i2]);
           newPoints.push(newOriginalPoints);
         }
       } else
-        newPoints.push(points);
+        newPoints.push(points2);
     } else
-      newPoints.push(points);
+      newPoints.push(points2);
     if (newPoints.length == 0)
       continue;
     for (let x = 0; x < newPoints.length; x++) {
@@ -10985,15 +11082,15 @@ var getObliqueSlabData = (lines, runDataList, pointCloudCluster = null) => {
   }
   return slabDatas;
 };
-function getPathZ(path3, points) {
+function getPathZ(path3, points2) {
   let pathPt = new THREE9.Vector3();
-  for (let i = 0; i < points.length; i++) {
+  for (let i = 0; i < points2.length; i++) {
     for (let j = 0; j < path3.length; j++) {
       if (path3[j].length == 3)
         continue;
-      pathPt.set(path3[j][0], path3[j][1], points[i].z);
-      if (pathPt.distanceTo(points[i]) < 1e-3) {
-        path3[j].push(points[i].z);
+      pathPt.set(path3[j][0], path3[j][1], points2[i].z);
+      if (pathPt.distanceTo(points2[i]) < 1e-3) {
+        path3[j].push(points2[i].z);
         break;
       }
     }
@@ -14720,14 +14817,14 @@ function pointToSegDist(px, pz, x1, z1, x2, z2) {
   const ez = pz - cz;
   return Math.sqrt(ex * ex + ez * ez);
 }
-function polygonArea2(points) {
-  if (points.length < 3) return 0;
+function polygonArea2(points2) {
+  if (points2.length < 3) return 0;
   let area2 = 0;
-  const n = points.length;
+  const n = points2.length;
   for (let i = 0; i < n; i++) {
     const j = (i + 1) % n;
-    area2 += points[i].x * points[j].z;
-    area2 -= points[j].x * points[i].z;
+    area2 += points2[i].x * points2[j].z;
+    area2 -= points2[j].x * points2[i].z;
   }
   return Math.abs(area2) / 2;
 }
@@ -15304,23 +15401,23 @@ function rotatePoint(x, z, angle) {
     z: x * sin + z * cos
   };
 }
-function calcTotalLength(points) {
+function calcTotalLength(points2) {
   let len = 0;
-  for (let i = 1; i < points.length; i++) {
-    const dx = points[i].x - points[i - 1].x;
-    const dz = points[i].z - points[i - 1].z;
+  for (let i = 1; i < points2.length; i++) {
+    const dx = points2[i].x - points2[i - 1].x;
+    const dz = points2[i].z - points2[i - 1].z;
     len += Math.sqrt(dx * dx + dz * dz);
   }
   return len;
 }
-function polygonArea3(points) {
-  if (points.length < 3) return 0;
+function polygonArea3(points2) {
+  if (points2.length < 3) return 0;
   let area2 = 0;
-  const n = points.length;
+  const n = points2.length;
   for (let i = 0; i < n; i++) {
     const j = (i + 1) % n;
-    area2 += points[i].x * points[j].z;
-    area2 -= points[j].x * points[i].z;
+    area2 += points2[i].x * points2[j].z;
+    area2 -= points2[j].x * points2[i].z;
   }
   return Math.abs(area2) / 2;
 }
@@ -15366,10 +15463,10 @@ function minDistBetweenPolylines(a, b) {
 }
 
 // src/wall-shape-classifier/point-cloud.ts
-function buildDensityGrid(points, cellSize) {
+function buildDensityGrid(points2, cellSize) {
   const cells = /* @__PURE__ */ new Map();
   let minX = Infinity, maxX = -Infinity, minZ = Infinity, maxZ = -Infinity;
-  for (const p of points) {
+  for (const p of points2) {
     const cx = Math.floor(p.x / cellSize);
     const cz = Math.floor(p.z / cellSize);
     const key = cx + "," + cz;
@@ -15543,22 +15640,22 @@ function extractBoundaryContour(component, cellSize) {
   }
   return result;
 }
-function simplifyPolyline(points, epsilon3) {
-  if (points.length <= 2) return [...points];
+function simplifyPolyline(points2, epsilon3) {
+  if (points2.length <= 2) return [...points2];
   let maxDist = 0;
   let maxIdx = 0;
-  const first = points[0];
-  const last = points[points.length - 1];
-  for (let i = 1; i < points.length - 1; i++) {
-    const d = distToSegment(points[i].x, points[i].z, first.x, first.z, last.x, last.z);
+  const first = points2[0];
+  const last = points2[points2.length - 1];
+  for (let i = 1; i < points2.length - 1; i++) {
+    const d = distToSegment(points2[i].x, points2[i].z, first.x, first.z, last.x, last.z);
     if (d > maxDist) {
       maxDist = d;
       maxIdx = i;
     }
   }
   if (maxDist > epsilon3) {
-    const left = simplifyPolyline(points.slice(0, maxIdx + 1), epsilon3);
-    const right = simplifyPolyline(points.slice(maxIdx), epsilon3);
+    const left = simplifyPolyline(points2.slice(0, maxIdx + 1), epsilon3);
+    const right = simplifyPolyline(points2.slice(maxIdx), epsilon3);
     return [...left.slice(0, -1), ...right];
   }
   return [first, last];
@@ -16757,10 +16854,10 @@ function emptyResult(rawLines, startTime) {
 }
 
 // src/wall-shape-classifier/point-cloud-filter.ts
-function removeOutlierPoints(points, cellSize, minNeighbors) {
-  if (!points.length || minNeighbors <= 1) return points;
+function removeOutlierPoints(points2, cellSize, minNeighbors) {
+  if (!points2.length || minNeighbors <= 1) return points2;
   const grid = /* @__PURE__ */ new Map();
-  for (const p of points) {
+  for (const p of points2) {
     const gx = Math.floor(p.x / cellSize);
     const gy = Math.floor(p.y / cellSize);
     const key = `${gx},${gy}`;
@@ -16782,7 +16879,7 @@ function removeOutlierPoints(points, cellSize, minNeighbors) {
   }
   const kept = [];
   let removed = 0;
-  for (const p of points) {
+  for (const p of points2) {
     const gx = Math.floor(p.x / cellSize);
     const gy = Math.floor(p.y / cellSize);
     const key = `${gx},${gy}`;
@@ -16794,10 +16891,10 @@ function removeOutlierPoints(points, cellSize, minNeighbors) {
   }
   return kept;
 }
-function applyVoxelFilter(points, voxelSize, minPointsPerVoxel) {
-  if (!points.length || minPointsPerVoxel <= 1 || voxelSize <= 0) return points;
+function applyVoxelFilter(points2, voxelSize, minPointsPerVoxel) {
+  if (!points2.length || minPointsPerVoxel <= 1 || voxelSize <= 0) return points2;
   const grid = /* @__PURE__ */ new Map();
-  for (const p of points) {
+  for (const p of points2) {
     const ix = Math.floor(p.x / voxelSize);
     const iy = Math.floor(p.y / voxelSize);
     const iz = Math.floor(p.z / voxelSize);
@@ -16816,9 +16913,9 @@ function applyVoxelFilter(points, voxelSize, minPointsPerVoxel) {
   }
   return kept;
 }
-function voxelFilter(points, voxelSize, minPointsPerVoxel) {
-  const r = applyVoxelFilter(points, voxelSize, minPointsPerVoxel);
-  const removed = points.length - r.length;
+function voxelFilter(points2, voxelSize, minPointsPerVoxel) {
+  const r = applyVoxelFilter(points2, voxelSize, minPointsPerVoxel);
+  const removed = points2.length - r.length;
   return r;
 }
 function computeVoxelParams(data) {
@@ -17348,14 +17445,14 @@ function growPolylines(lines, connectDist, angleTolRad) {
   }
   return results;
 }
-function computeTurnAngles(points) {
-  if (points.length < 3) return [];
+function computeTurnAngles(points2) {
+  if (points2.length < 3) return [];
   const deltas = [];
-  for (let i = 1; i < points.length - 1; i++) {
-    const dx1 = points[i].x - points[i - 1].x;
-    const dz1 = points[i].z - points[i - 1].z;
-    const dx2 = points[i + 1].x - points[i].x;
-    const dz2 = points[i + 1].z - points[i].z;
+  for (let i = 1; i < points2.length - 1; i++) {
+    const dx1 = points2[i].x - points2[i - 1].x;
+    const dz1 = points2[i].z - points2[i - 1].z;
+    const dx2 = points2[i + 1].x - points2[i].x;
+    const dz2 = points2[i + 1].z - points2[i].z;
     const angle1 = Math.atan2(dz1, dx1);
     const angle2 = Math.atan2(dz2, dx2);
     let delta = normalizeAngle(angle2 - angle1);
@@ -17363,45 +17460,45 @@ function computeTurnAngles(points) {
   }
   return deltas;
 }
-function classifyType(points, minCurvePoints = 6) {
-  if (points.length < 3) return "straight";
-  const first = points[0];
-  const last = points[points.length - 1];
+function classifyType(points2, minCurvePoints = 6) {
+  if (points2.length < 3) return "straight";
+  const first = points2[0];
+  const last = points2[points2.length - 1];
   const dx = last.x - first.x;
   const dz = last.z - first.z;
   const chordLen = Math.sqrt(dx * dx + dz * dz);
   if (chordLen > 0.1) {
     let maxDev = 0;
-    for (const p of points) {
+    for (const p of points2) {
       const d = distToSegment(p.x, p.z, first.x, first.z, last.x, last.z);
       if (d > maxDev) maxDev = d;
     }
     if (maxDev < 0.05) return "straight";
   }
-  const deltas = computeTurnAngles(points);
+  const deltas = computeTurnAngles(points2);
   const totalBend = deltas.reduce((sum2, d) => sum2 + Math.abs(d), 0);
   if (totalBend < 0.1) return "straight";
-  if (points.length < minCurvePoints) return "straight";
+  if (points2.length < minCurvePoints) return "straight";
   let signChanges = 0;
   for (let i = 0; i < deltas.length - 1; i++) {
     if (deltas[i] * deltas[i + 1] < 0) signChanges++;
   }
   return signChanges > 0 ? "S_curve" : "C_curve";
 }
-function splitAtHardCorners(points, thresholdDeg) {
-  if (points.length < 3) return [points];
+function splitAtHardCorners(points2, thresholdDeg) {
+  if (points2.length < 3) return [points2];
   const threshold = degToRad(thresholdDeg);
-  const deltas = computeTurnAngles(points);
+  const deltas = computeTurnAngles(points2);
   const segments = [];
   let startIdx = 0;
   for (let i = 0; i < deltas.length; i++) {
     if (Math.abs(deltas[i]) > threshold) {
-      segments.push(points.slice(startIdx, i + 2));
+      segments.push(points2.slice(startIdx, i + 2));
       startIdx = i + 1;
     }
   }
-  if (startIdx < points.length - 1) {
-    segments.push(points.slice(startIdx));
+  if (startIdx < points2.length - 1) {
+    segments.push(points2.slice(startIdx));
   }
   return segments;
 }