rm-webgpu-compute-tasks 0.0.7 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rm-webgpu-compute-tasks",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/index.d.ts

@@ -419,10 +419,9 @@ declare function obstacleDetection_(opt: ICreateObstacleDetection): Promise<{
 declare interface Option_2 {
     base: string;
     urls: string[];
-    erodeMaskSize?: number;
+    dilateMaskSize?: number;
     kernelSize?: number;
-    gridSize?: number;
-    gridAmount?: number;
+    groundZ?: number;
 }
 
 export declare class PerspectiveCamera extends THREE.PerspectiveCamera {

package/src/index.js

@@ -457,7 +457,12 @@ async function initWebgpu(opt = {}) {
   if (!navigator.gpu) throw new Error("该环境不支持webgpu");
   if (!adapter) adapter = await navigator.gpu.requestAdapter(opt);
   if (!adapter) throw new Error("获取适配器失败");
-  device = await adapter.requestDevice(opt);
+  device = await adapter.requestDevice({
+    requiredLimits: {
+      maxBufferSize: adapter.limits.maxBufferSize
+    },
+    ...opt
+  });
   if (!adapter) throw new Error("获取设备失败");
   GpuComputed.set(adapter, device);
   return { device, adapter };
@@ -1333,7 +1338,7 @@ class ShaderMaterial {
         set value(v) {
           if (getUniformType(v, uniforms[key]?.atomic) !== type) return;
           v = set(v, value_);
-          if ("copy" in value_ && typeof value_.copy === "function") value_.copy(v);
+          if (typeof value_ === "object" && "copy" in value_ && typeof value_.copy === "function") value_.copy(v);
           else value_ = v;
         }
       };
@@ -2211,22 +2216,6 @@ async function trajectoryHandle(baseUrl, trajectoryData) {
     pointCloudArray
   };
 }
-function getPointsCenter(arr) {
-  let x = 0, y = 0, z = 0;
-  for (let i = 0; i < arr.length; i += 3) {
-    x += arr[i];
-    y += arr[i + 1];
-    z += arr[i + 2];
-  }
-  const count = arr.length / 3;
-  return { x: x / count, y: y / count, z: z / count };
-}
-function getPointDistance(p1, p2) {
-  const dx = p2.x - p1.x;
-  const dy = p2.y - p1.y;
-  const dz = p2.z - p1.z;
-  return Math.sqrt(dx * dx + dy * dy + dz * dz);
-}
 class OcclusionMaterial extends ShaderMaterial {
   constructor(opt) {
     super({
@@ -2570,7 +2559,7 @@ class PointCloudsIndexMaterial extends ShaderMaterial {
         cameraMat: { value: new Matrix3() },
         T_cw: { value: new Matrix4() },
         imageSize: { value: new Vector2(width, height) },
-        groundZ: { value: -0.911335763281652 + 0.1 },
+        groundZ: { value: -1 },
         depth: { value: depthU32, write: true, atomic: true }
       },
       topology: "point-list"
@@ -2647,6 +2636,7 @@ const fragmentShader = (
         @location(0) vId: vec4<f32>,
     ) -> @location(0) vec4<f32> {
         return vId;
+        // return vec4(1.0, 0, 0, 1);
     }
 `
 );
@@ -2660,7 +2650,8 @@ class PolyAreaIndexMaterial extends ShaderMaterial {
       side: "none",
       uniforms: {
         imageSize: { value: new Vector2(width, height) }
-      }
+      },
+      topology: "point-list"
     });
     this.resultTexture = resultTexture;
   }
@@ -2797,93 +2788,19 @@ class ArrayMap extends MapEnhance {
     return this.get(key);
   }
 }
-class UnionFindSet {
-  parent;
-  rank;
-  constructor(size) {
-    this.parent = Array(size).fill(0).map((_, index) => index);
-    this.rank = Array(size).fill(1);
-  }
-  // 查找操作，使用路径压缩优化
-  find(x) {
-    if (this.parent[x] !== x) {
-      this.parent[x] = this.find(this.parent[x]);
-    }
-    return this.parent[x];
-  }
-  // 合并操作，使用按秩合并优化
-  union(x, y) {
-    let rootX = this.find(x);
-    let rootY = this.find(y);
-    if (rootX !== rootY) {
-      if (this.rank[rootX] > this.rank[rootY]) {
-        this.parent[rootY] = rootX;
-      } else if (this.rank[rootX] < this.rank[rootY]) {
-        this.parent[rootX] = rootY;
-      } else {
-        this.parent[rootY] = rootX;
-        this.rank[rootX] += 1;
-      }
-    }
-  }
-  /** 获取所有集合
-   * @returns 
-   */
-  getAllSets() {
-    const sets = new ArrayMap();
-    for (const el of this.parent.keys()) {
-      const root = this.find(el);
-      sets.append(root, el);
-    }
-    return sets;
-  }
-}
-function hash(ix, iy, iz) {
-  return ix * 73856093 ^ iy * 19349663 ^ iz * 83492791;
-}
-function voxelization(pointsArray, size = 0.05) {
-  const inv = 1 / size, keySet = /* @__PURE__ */ new Set(), result = [], points = [];
-  for (let i = 0; i < pointsArray.length; i += 3) {
-    const xi = Math.floor(pointsArray[i] * inv), yi = Math.floor(pointsArray[i + 1] * inv), zi = Math.floor(pointsArray[i + 2] * inv), key = hash(xi, yi, zi);
-    if (keySet.has(key)) continue;
-    keySet.add(key);
-    result.push(xi, yi, zi);
-    points.push(pointsArray[i], pointsArray[i + 1], pointsArray[i + 2]);
-  }
-  return { result, keySet, points };
-}
-function gridClustering(pointsArray, size = 0.05, threshold = 2) {
-  const { result, points, keySet } = voxelization(new Float32Array(pointsArray), size), unionFindSet = new UnionFindSet(keySet.size), keys = [...keySet.values()];
-  const indexMap = /* @__PURE__ */ new Map();
-  keys.forEach((v, i) => indexMap.set(v, i));
-  keys.forEach((key, i) => {
-    const x = result[i * 3];
-    const y = result[i * 3 + 1];
-    const z = result[i * 3 + 2];
-    for (let i2 = -threshold; i2 <= threshold; i2++) {
-      for (let j = -threshold; j <= threshold; j++) {
-        for (let k = -threshold; k <= threshold; k++) {
-          const xx = x + i2, yy = y + j, zz = z + k;
-          if (xx === x && yy === y && zz === z) continue;
-          const id = hash(xx, yy, zz);
-          if (!keySet.has(id)) continue;
-          unionFindSet.union(indexMap.get(key), indexMap.get(id));
-        }
-      }
-    }
-  });
-  return unionFindSet.getAllSets().map(
-    (list) => list.flatMap((i) => {
-      const x = points[i * 3];
-      const y = points[i * 3 + 1];
-      const z = points[i * 3 + 2];
-      return [x, y, z];
-    })
-  );
-}
 const beforeCcde$1 = (
   /* wgsl*/
   `
+    // fn orderedUintToFloat(u: u32) -> f32 {
+    //     let mask = select(0x80000000u, 0xffffffffu, (u & 0x80000000u) != 0u);
+    //     return bitcast<f32>(u ^ mask);
+    // }
+
+    fn orderedUintToFloat(u: u32) -> f32 {
+        let restored = select(u ^ 0xffffffffu, u, (u & 0x80000000u) != 0u);
+        return bitcast<f32>(restored);
+    }
+
     fn packUint(v: u32) -> vec4<f32>{
         return vec4(
             f32(v & 255u),
@@ -2901,9 +2818,17 @@ const beforeCcde$1 = (
         return (a << 24u) | (b << 16u) | (g << 8u)  | r;
     }
 
-    fn isEmpty(value: u32) -> bool {
+    fn isPolyEmpty(value: u32) -> bool {
         return value  == 0xff000000 || value == 0x0 ;
     }
+
+    fn isEmpty(value: u32) -> bool {
+        return value  == 0xff000000;
+    }
+
+    fn isDepthEmpty(value: u32) -> bool {
+        return value  == 0xffffffff;
+    }
 `
 );
 const mainCode$1 = (
@@ -2912,93 +2837,105 @@ const mainCode$1 = (
     let width  = i32(uniforms.size.x);
     let height = i32(uniforms.size.y);
     let half = i32(uniforms.kernelSize / 2);
+    let depthTol = uniforms.depthTol;
 
     let x = i32(id.x);
     let y = i32(id.y);
 
     let idx = u32(y) * u32(width) + u32(x);
 
-    // 当前像素
-    let center = unPackUint(textureLoad(map, vec2<i32>(x, y), 0));
-
-    // 如果当前就是空，直接空
-    if ( isEmpty(center) ) {
-        result[idx] = 0xff000000;
+    // 判断是不是多边形区域
+    let polyPackedIndex = polyAreaIndex[idx];
+    if(isPolyEmpty(polyPackedIndex)) {
         return;
     }
 
-    // 是否被腐蚀
-    var eroded = false;
+    // 获取多边形当前坐标有没有点云（获取深度值判断也是一样的， 深度值和点云索引图一一对应）
+    // let packedIndex = textureLoad(pcIndexMap, vec2<i32>(x, y), 0);
+    // let pointIndex = unPackUint(packedIndex); 
+    // if(isEmpty(pointIndex)) {
+    //     return;
+    // }
 
-    // 遍历邻域
-    for (var ky = -half; ky <= half; ky = ky + 1) {
-        let ny = y + ky;
+    // 获取当前点云深度值
+    // let depthU32 = pcDepth[idx];
+    // let depthF32 = orderedUintToFloat(depthU32);
 
-        if (ny < 0 || ny >= height) {
-            continue;
-        }
+    // 获取范围内最小深度值和对应点云索引
+    let maxDepth = 10000.0;
+    var minDepth = maxDepth;
+    var minPcUv = vec2<i32>(0, 0);
 
+    for (var ky = -half; ky <= half; ky = ky + 1) {
+        let ny = y + ky;
         for (var kx = -half; kx <= half; kx = kx + 1) {
             let nx = x + kx;
 
-            if (nx < 0 || nx >= width) {
+            if (nx < 0 || ny < 0 || nx >= width || ny >= height ) {
                 continue;
             }
 
-            let neighbor = unPackUint(textureLoad(map, vec2<i32>(nx, ny), 0));
+            let idx = u32(ny) * u32(width) + u32(nx);
 
-            // 只要有一个是空 → 腐蚀
-            if (isEmpty(neighbor) || neighbor != center) {
-                eroded = true;
-                break;
-            }
-        }
+            let depthU32 = pcDepth[idx];
+            let depthF32 = orderedUintToFloat( depthU32 );
 
-        if (eroded) {
-            break;
+            if(depthF32 < minDepth) {
+                minDepth = depthF32;
+                minPcUv.x = nx;
+                minPcUv.y = ny;
+            }
         }
     }
 
-    // 写结果
-    if (eroded) {
-        result[idx] = 0xff000000;
-    } else {
-        result[idx] = center;
+    // 是否找到最小值, 当前判断条件为未找到
+    if(minDepth >= maxDepth) {
+        return;
     }
+
+    // 判断当前点深度和最小深度的差值是否小于阈值
+    // if(abs(depthF32 - minDepth) > depthTol) {
+    //     return;
+    // }
+
+    let finalPackedIndex = textureLoad(pcIndexMap, minPcUv, 0);
+    let finalPointIndex = unPackUint(finalPackedIndex);
+    result[finalPointIndex] = polyPackedIndex;
 `
 );
-class ErodeMaskComputeMaterial extends ComputeMaterial {
-  constructor(width = 1920, height = 1200, texture, kernelSize = 3) {
+class SOPCComputeMaterial extends ComputeMaterial {
+  result;
+  constructor(width, height, count, pcIndexTexture, kernelSize = 15) {
+    const result = new Uint32Array(count).fill(4294967295);
     super({
       maxSize: [width, height],
       mainCode: mainCode$1,
       beforeCcde: beforeCcde$1,
       uniforms: {
-        map: { value: texture },
+        pcIndexMap: { value: pcIndexTexture },
+        // 空白填充 0xff_00_00_00
+        pcDepth: { value: new Uint32Array() },
+        // 默认填充 0xff_ff_ff_ff
+        polyAreaIndex: { value: new Uint32Array() },
+        // 空白填充 0xff_00_00_00
         size: { value: new Vector2(width, height) },
         kernelSize: { value: kernelSize },
-        // 建议从3开始
+        depthTol: { value: 0.05 },
         result: {
-          value: new Uint32Array(width * height),
+          value: result,
           write: true
         }
       }
     });
+    this.result = result;
+  }
+  clearResult() {
+    this.uniforms.result.value = this.result;
   }
 }
 const beforeCcde = (
   /* wgsl*/
   `
-    // fn orderedUintToFloat(u: u32) -> f32 {
-    //     let mask = select(0x80000000u, 0xffffffffu, (u & 0x80000000u) != 0u);
-    //     return bitcast<f32>(u ^ mask);
-    // }
-
-    fn orderedUintToFloat(u: u32) -> f32 {
-        let restored = select(u ^ 0xffffffffu, u, (u & 0x80000000u) != 0u);
-        return bitcast<f32>(restored);
-    }
-
     fn packUint(v: u32) -> vec4<f32>{
         return vec4(
             f32(v & 255u),
@@ -3013,19 +2950,11 @@ const beforeCcde = (
         let g = u32(color.g * 255.0);
         let b = u32(color.b * 255.0);
         let a = u32(color.a * 255.0);
-        return (a << 24u) | (b << 16u) | (g << 8u)  | r;
-    }
-
-    fn isPolyEmpty(value: u32) -> bool {
-        return value  == 0xff000000 || value == 0x0 ;
+        return (a << 24u) | (b << 16u) | (g << 8u) | r;
     }
 
     fn isEmpty(value: u32) -> bool {
-        return value  == 0xff000000;
-    }
-
-    fn isDepthEmpty(value: u32) -> bool {
-        return value  == 0xffffffff;
+        return value == 0xff000000 || value == 0x0;
     }
 `
 );
@@ -3035,101 +2964,116 @@ const mainCode = (
     let width  = i32(uniforms.size.x);
     let height = i32(uniforms.size.y);
     let half = i32(uniforms.kernelSize / 2);
-    let depthTol = uniforms.depthTol;
 
     let x = i32(id.x);
     let y = i32(id.y);
 
     let idx = u32(y) * u32(width) + u32(x);
 
-    // 判断是不是多边形区域
-    let polyPackedIndex = polyAreaIndex[idx];
-    if(isPolyEmpty(polyPackedIndex)) {
-        return;
-    }
+    // 当前像素
+    let center = unPackUint(textureLoad(map, vec2<i32>(x, y), 0));
 
-    // 获取多边形当前坐标有没有点云（获取深度值判断也是一样的， 深度值和点云索引图一一对应）
-    let packedIndex = textureLoad(pcIndexMap, vec2<i32>(x, y), 0);
-    let pointIndex = unPackUint(packedIndex); 
-    if(isEmpty(pointIndex)) {
+    // 当前非空，保持原值
+    if (!isEmpty(center)) {
+        result[idx] = center;
         return;
     }
 
-    // 获取当前点云深度值
-    let depthU32 = pcDepth[idx];
-    let depthF32 = orderedUintToFloat(depthU32);
-
-    // 获取范围内最小深度值和对应点云索引
-    let maxDepth = 10000.0;
-    var minDepth = maxDepth;
-    var minPcUv = vec2<i32>(0, 0);
+    // 膨胀：空像素尝试被邻域填充
+    var dilatedValue: u32 = 0xff000000;
 
     for (var ky = -half; ky <= half; ky = ky + 1) {
         let ny = y + ky;
+
+        if (ny < 0 || ny >= height) {
+            continue;
+        }
+
         for (var kx = -half; kx <= half; kx = kx + 1) {
             let nx = x + kx;
 
-            if (nx < 0 || ny < 0 || nx >= width || ny >= height ) {
+            if (nx < 0 || nx >= width) {
                 continue;
             }
 
-            let idx = u32(ny) * u32(width) + u32(nx);
-
-            let depthU32 = pcDepth[idx];
-            let depthF32 = orderedUintToFloat( depthU32 );
+            let neighbor = unPackUint(textureLoad(map, vec2<i32>(nx, ny), 0));
 
-            if(depthF32 < minDepth) {
-                minDepth = depthF32;
-                minPcUv.x = nx;
-                minPcUv.y = ny;
+            // 只要找到非空邻居，直接采用它的值
+            if (!isEmpty(neighbor)) {
+                dilatedValue = neighbor;
+                break;
             }
         }
-    }
 
-    // 是否找到最小值, 当前判断条件为未找到
-    if(minDepth >= maxDepth) {
-        return;
-    }
-
-    // 判断当前点深度和最小深度的差值是否小于阈值
-    if(abs(depthF32 - minDepth) > depthTol) {
-        return;
+        if (!isEmpty(dilatedValue)) {
+            break;
+        }
     }
 
-    let finalPackedIndex = textureLoad(pcIndexMap, minPcUv, 0);
-    let finalPointIndex = unPackUint(packedIndex);
-    result[finalPointIndex] = polyPackedIndex;
+    result[idx] = dilatedValue;
 `
 );
-class SOPCComputeMaterial extends ComputeMaterial {
-  result;
-  constructor(width, height, count, pcIndexTexture, kernelSize = 15) {
-    const result = new Uint32Array(count).fill(4294967295);
+class DilateMaskComputeMaterial extends ComputeMaterial {
+  constructor(width = 1920, height = 1200, texture, kernelSize = 3) {
     super({
       maxSize: [width, height],
       mainCode,
       beforeCcde,
       uniforms: {
-        pcIndexMap: { value: pcIndexTexture },
-        // 空白填充 0xff_00_00_00
-        pcDepth: { value: new Uint32Array() },
-        // 默认填充 0xff_ff_ff_ff
-        polyAreaIndex: { value: new Uint32Array() },
-        // 空白填充 0xff_00_00_00
+        map: { value: texture },
         size: { value: new Vector2(width, height) },
         kernelSize: { value: kernelSize },
-        depthTol: { value: 0.05 },
         result: {
-          value: result,
+          value: new Uint32Array(width * height),
           write: true
         }
       }
     });
-    this.result = result;
   }
-  clearResult() {
-    this.uniforms.result.value = this.result;
+}
+function euclideanClusterExtraction(points, distanceThreshold = 0.2, minClusterSize = 1, maxClusterSize = Infinity) {
+  const pointCount = points.length / 3;
+  const visited = new Uint8Array(pointCount);
+  const clusters = [];
+  const thresholdSq = distanceThreshold * distanceThreshold;
+  function distanceSq(a, b) {
+    const ai = a * 3;
+    const bi = b * 3;
+    const dx = points[ai] - points[bi];
+    const dy = points[ai + 1] - points[bi + 1];
+    const dz = points[ai + 2] - points[bi + 2];
+    return dx * dx + dy * dy + dz * dz;
+  }
+  function regionQuery(index) {
+    const neighbors = [];
+    for (let i = 0; i < pointCount; i++) {
+      if (distanceSq(index, i) <= thresholdSq) {
+        neighbors.push(i);
+      }
+    }
+    return neighbors;
+  }
+  for (let i = 0; i < pointCount; i++) {
+    if (visited[i]) continue;
+    visited[i] = 1;
+    const cluster = [];
+    const queue = [i];
+    while (queue.length > 0) {
+      const current = queue.pop();
+      cluster.push(current);
+      const neighbors = regionQuery(current);
+      for (const neighbor of neighbors) {
+        if (!visited[neighbor]) {
+          visited[neighbor] = 1;
+          queue.push(neighbor);
+        }
+      }
+    }
+    if (cluster.length >= minClusterSize && cluster.length <= maxClusterSize) {
+      clusters.push(cluster);
+    }
   }
+  return clusters;
 }
 async function load(base, urls) {
   let points = await loadPCDCustom(base + "/data/rgb_global_map.pcd");
@@ -3159,16 +3103,11 @@ function getInfo(itemsFile, cindex) {
   itemsFile.sam3Objects.forEach((item) => count += item.coordinates.length);
   const itemPosition = [];
   for (let i = 0; i < itemsFile.sam3Objects.length; i++) {
-    const item = itemsFile.sam3Objects[i], path = item.coordinates.map((coordinate) => new THREE.Vector2(coordinate[0], coordinate[1])), triangles = THREE.ShapeUtils.triangulateShape(path, []);
-    triangles.forEach(
-      (list) => list.forEach(
-        (index) => itemPosition.push(
-          path[index].x,
-          path[index].y,
-          cindex * 200 + i
-        )
-      )
-    );
+    const item = itemsFile.sam3Objects[i];
+    const index = cindex * 200 + i + 1;
+    item.coordinates.map((p) => {
+      itemPosition.push(p[0], p[1], index);
+    });
   }
   return {
     cameraMat,
@@ -3182,10 +3121,9 @@ async function sopc_(opt) {
   const {
     base,
     urls,
-    erodeMaskSize = 3,
+    dilateMaskSize = 2,
     kernelSize = 15,
-    gridSize = 0.05,
-    gridAmount = 2
+    groundZ = 0
   } = opt;
   console.log("开始计算");
   let t = performance.now();
@@ -3195,7 +3133,7 @@ async function sopc_(opt) {
     canvasWidth = window.innerWidth ?? canvasWidth;
     canvasHeight = window.innerHeight ?? canvasHeight;
   }
-  const renderer = new Renderer(canvasWidth, canvasHeight, "rgba8unorm"), camera = new PerspectiveCamera(75, canvasWidth / canvasHeight, 1e-3, 100), { points: pointsArray, itemsFiles, width, height } = await load(base, urls), pointCount = pointsArray.length / 3, pcIndexMaterial = new PointCloudsIndexMaterial(width, height), polyAreaIndexMaterial = new PolyAreaIndexMaterial(width, height), erodeMaskComputeMaterial = new ErodeMaskComputeMaterial(width, height, polyAreaIndexMaterial.resultTexture, erodeMaskSize), sopcComputeMaterial = new SOPCComputeMaterial(width, height, pointCount, pcIndexMaterial.resultTexture, kernelSize), points = new Object3D(
+  const renderer = new Renderer(canvasWidth, canvasHeight, "rgba8unorm"), camera = new PerspectiveCamera(75, canvasWidth / canvasHeight, 1e-3, 100), { points: pointsArray, itemsFiles, width, height } = await load(base, urls), pointCount = pointsArray.length / 3, pcIndexMaterial = new PointCloudsIndexMaterial(width, height), polyAreaIndexMaterial = new PolyAreaIndexMaterial(width, height), dilateMaskComputeMaterial = new DilateMaskComputeMaterial(width, height, polyAreaIndexMaterial.resultTexture, dilateMaskSize), sopcComputeMaterial = new SOPCComputeMaterial(width, height, pointCount, pcIndexMaterial.resultTexture, kernelSize), points = new Object3D(
     new BufferGeometry().setAttribute("position", new THREE.BufferAttribute(pointsArray, 3)),
     pcIndexMaterial
   ), mesh = new Object3D(
@@ -3203,6 +3141,7 @@ async function sopc_(opt) {
     polyAreaIndexMaterial
   );
   camera.position.set(1, 1, 1);
+  pcIndexMaterial.groundZ = groundZ;
   console.log("文件加载耗时：", performance.now() - t);
   t = performance.now();
   for (let i = 0; i < itemsFiles.length; i++) {
@@ -3222,9 +3161,9 @@ async function sopc_(opt) {
     renderer.renderTarget = polyAreaIndexMaterial.resultTexture.view;
     renderer.depthTarget = polyAreaIndexMaterial.resultTexture.depthView;
     renderer.render([mesh], camera);
-    renderer.compute(erodeMaskComputeMaterial);
+    renderer.compute(dilateMaskComputeMaterial);
     sopcComputeMaterial.setStorageBuffer("pcDepth", pcIndexMaterial.getStorageBuffer("depth"));
-    sopcComputeMaterial.setStorageBuffer("polyAreaIndex", erodeMaskComputeMaterial.getStorageBuffer("result"));
+    sopcComputeMaterial.setStorageBuffer("polyAreaIndex", dilateMaskComputeMaterial.getStorageBuffer("result"));
     renderer.compute(sopcComputeMaterial);
   }
   const resultsBuffer = await readGPUBuffer(sopcComputeMaterial.getStorageBuffer("result"), pointCount * 4, Uint32Array);
@@ -3241,23 +3180,17 @@ async function sopc_(opt) {
       arrayMap = new ArrayMap();
       map.set(fileIndex, arrayMap);
     }
-    arrayMap.append(itemIndex, i);
-  }
-  const transcendingCreation = ["window", "calcony railing", "glass balcony railing", "metal balcony railing", "temporary construction guardrail"];
-  const results = new Array(itemsFiles.length);
-  const sort = (pointarr, isTranscendingCreation, position) => {
-    let list = gridClustering(pointarr, gridSize, gridAmount);
-    if (list.length === 1) return list;
-    if (isTranscendingCreation) {
-      const distList = list.map((points2) => getPointDistance(getPointsCenter(points2), position));
-      let indices = Array.from({ length: list.length }, (_, i) => i);
-      indices.sort((a, b) => distList[a] - distList[b]);
-      const min = distList[indices[0]];
-      indices = indices.filter((i) => distList[i] - min < 0.12 * 2);
-      list = indices.map((i) => list[i]);
-    }
-    list.sort((a, b) => b.length - a.length);
-    return list;
+    arrayMap.append(itemIndex - 1, i);
+  }
+  const results = new Array(itemsFiles.length).fill([]).map(() => []);
+  const sort = (pointarr) => {
+    let list = euclideanClusterExtraction(pointarr, 0.2).sort((a, b) => b.length - a.length);
+    if (list.length === 1) return pointarr;
+    return list[0].flatMap((i) => [
+      pointarr[i * 3],
+      pointarr[i * 3 + 1],
+      pointarr[i * 3 + 2]
+    ]);
   };
   map.forEach((arrMap, fileIndex) => {
     arrMap.forEach((pointIndexs, itemIndex) => {
@@ -3269,11 +3202,7 @@ async function sopc_(opt) {
           pointsArray[i * 3 + 2]
         );
       });
-      const itemsFile = itemsFiles[fileIndex];
-      const type = itemsFile.sam3Objects[itemIndex].category;
-      const isTranscendingCreation = transcendingCreation.includes(type);
-      pointarr = sort(pointarr, isTranscendingCreation, itemsFile.position)[0];
-      if (pointarr.length <= 6 * 3) return;
+      pointarr = sort(pointarr);
       if (!results[fileIndex]) results[fileIndex] = new Array(itemsFiles[fileIndex].sam3Objects.length).fill([]);
       results[fileIndex][itemIndex] = pointarr;
     });