Upload preprocess_manual.js

preprocess_manual.js

@@ -525,161 +525,78 @@ function createManualUI(scene, camera, renderer) {
 
 function filterSplatsByBox(plyData, boxSize, boxPosition, boxRotation = { x: 0, y: 0, z: 0 }) {
   console.log('[filterSplatsByBox] ===== FILTERING START =====');
-  console.log('[filterSplatsByBox] Input parameters:');
-  console.log('  Box Size:', boxSize);
-  console.log('  Box Position:', boxPosition);
-  console.log('  Box Rotation (radians):', boxRotation);
-  console.log('  Box Rotation (degrees):', {
-    x: (boxRotation.x * 180 / Math.PI).toFixed(1),
-    y: (boxRotation.y * 180 / Math.PI).toFixed(1),
-    z: (boxRotation.z * 180 / Math.PI).toFixed(1)
-  });
-  console.log('  Total input vertices:', plyData.vertices.length);
+  
+  // ⭐⭐⭐ 追加: すべての頂点の詳細を出力 ⭐⭐⭐
+  console.log('[DEBUG] ALL VERTICES ANALYSIS:');
   
   const halfX = boxSize.x / 2;
   const halfY = boxSize.y / 2;
   const halfZ = boxSize.z / 2;
   
-  // ⭐ 浮動小数点誤差のための許容値
-  const epsilon = 0.0001;
-  
-  console.log('[filterSplatsByBox] Box half-extents:', { halfX, halfY, halfZ });
-  console.log('[filterSplatsByBox] Using epsilon:', epsilon);
-  
-  // Create rotation matrix
   const rotationMatrix = new THREE.Matrix4();
   rotationMatrix.makeRotationFromEuler(new THREE.Euler(boxRotation.x, boxRotation.y, boxRotation.z));
-  
-  // Inverse matrix for transforming points into box space
   const inverseRotationMatrix = new THREE.Matrix4().copy(rotationMatrix).invert();
   
-  console.log('[filterSplatsByBox] Rotation matrix created');
+  let insideCount = 0;
+  let outsideCount = 0;
+  let boundaryVertices = []; // 境界付近の頂点
   
-  // デバッグ: 最初の10個の頂点を詳細にログ
-  console.log('[filterSplatsByBox] Sample vertices (first 10):');
-  for (let i = 0; i < Math.min(10, plyData.vertices.length); i++) {
-    const v = plyData.vertices[i];
-    const localPos = new THREE.Vector3(
-      v.x - boxPosition.x,
-      v.y - boxPosition.y,
-      v.z - boxPosition.z
-    );
-    localPos.applyMatrix4(inverseRotationMatrix);
-    
-    // ⭐ 修正: epsilonを使った境界判定
-    const inside = (
-      localPos.x >= -(halfX + epsilon) && localPos.x <= (halfX + epsilon) &&
-      localPos.y >= -(halfY + epsilon) && localPos.y <= (halfY + epsilon) &&
-      localPos.z >= -(halfZ + epsilon) && localPos.z <= (halfZ + epsilon)
-    );
-    
-    console.log(`  Vertex ${i}:`, {
-      world: { x: v.x.toFixed(3), y: v.y.toFixed(3), z: v.z.toFixed(3) },
-      local: { x: localPos.x.toFixed(3), y: localPos.y.toFixed(3), z: localPos.z.toFixed(3) },
-      inside: inside,
-      distances: {
-        x: `${(localPos.x + halfX).toFixed(3)} / ${(halfX - localPos.x).toFixed(3)}`,
-        y: `${(localPos.y + halfY).toFixed(3)} / ${(halfY - localPos.y).toFixed(3)}`,
-        z: `${(localPos.z + halfZ).toFixed(3)} / ${(halfZ - localPos.z).toFixed(3)}`
-      }
-    });
-  }
-  
-  // 実際のフィルタリング
-  const filteredVertices = plyData.vertices.filter((vertex, index) => {
+  plyData.vertices.forEach((vertex, index) => {
     const localPos = new THREE.Vector3(
       vertex.x - boxPosition.x,
       vertex.y - boxPosition.y,
       vertex.z - boxPosition.z
     );
-    
     localPos.applyMatrix4(inverseRotationMatrix);
     
-    // ⭐⭐⭐ CRITICAL FIX: epsilon付き境界判定 ⭐⭐⭐
     const inside = (
-      localPos.x >= -(halfX + epsilon) && localPos.x <= (halfX + epsilon) &&
-      localPos.y >= -(halfY + epsilon) && localPos.y <= (halfY + epsilon) &&
-      localPos.z >= -(halfZ + epsilon) && localPos.z <= (halfZ + epsilon)
+      localPos.x >= -(halfX + 0.0001) && localPos.x <= (halfX + 0.0001) &&
+      localPos.y >= -(halfY + 0.0001) && localPos.y <= (halfY + 0.0001) &&
+      localPos.z >= -(halfZ + 0.0001) && localPos.z <= (halfZ + 0.0001)
     );
     
-    return inside;
-  });
-  
-  // フィルタリング結果の統計
-  const retentionRate = (filteredVertices.length / plyData.vertices.length * 100).toFixed(1);
-  
-  console.log('[filterSplatsByBox] ===== FILTERING COMPLETE =====');
-  console.log('[filterSplatsByBox] Results:');
-  console.log('  Filtered:', filteredVertices.length, '/', plyData.vertices.length);
-  console.log('  Retention rate:', retentionRate, '%');
-  
-  // フィルタリング後の範囲を計算
-  if (filteredVertices.length > 0) {
-    let minX = Infinity, minY = Infinity, minZ = Infinity;
-    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-    
-    filteredVertices.forEach(v => {
-      minX = Math.min(minX, v.x);
-      minY = Math.min(minY, v.y);
-      minZ = Math.min(minZ, v.z);
-      maxX = Math.max(maxX, v.x);
-      maxY = Math.max(maxY, v.y);
-      maxZ = Math.max(maxZ, v.z);
-    });
-    
-    console.log('[filterSplatsByBox] Filtered bounds (world space):');
-    console.log('  X:', minX.toFixed(3), 'to', maxX.toFixed(3), '(size:', (maxX - minX).toFixed(3), ')');
-    console.log('  Y:', minY.toFixed(3), 'to', maxY.toFixed(3), '(size:', (maxY - minY).toFixed(3), ')');
-    console.log('  Z:', minZ.toFixed(3), 'to', maxZ.toFixed(3), '(size:', (maxZ - minZ).toFixed(3), ')');
-    console.log('  Center:', {
-      x: ((minX + maxX) / 2).toFixed(3),
-      y: ((minY + maxY) / 2).toFixed(3),
-      z: ((minZ + maxZ) / 2).toFixed(3)
-    });
-    
-    // 期待されるBOXの範囲と比較
-    const expectedMinX = boxPosition.x - halfX;
-    const expectedMaxX = boxPosition.x + halfX;
-    const expectedMinY = boxPosition.y - halfY;
-    const expectedMaxY = boxPosition.y + halfY;
-    const expectedMinZ = boxPosition.z - halfZ;
-    const expectedMaxZ = boxPosition.z + halfZ;
-    
-    console.log('[filterSplatsByBox] Expected bounds (if rotation = 0):');
-    console.log('  X:', expectedMinX.toFixed(3), 'to', expectedMaxX.toFixed(3));
-    console.log('  Y:', expectedMinY.toFixed(3), 'to', expectedMaxY.toFixed(3));
-    console.log('  Z:', expectedMinZ.toFixed(3), 'to', expectedMaxZ.toFixed(3));
-    
-    // ⭐ 誤差チェック
-    const errorX = Math.max(Math.abs(minX - expectedMinX), Math.abs(maxX - expectedMaxX));
-    const errorY = Math.max(Math.abs(minY - expectedMinY), Math.abs(maxY - expectedMaxY));
-    const errorZ = Math.max(Math.abs(minZ - expectedMinZ), Math.abs(maxZ - expectedMaxZ));
+    if (inside) {
+      insideCount++;
+    } else {
+      outsideCount++;
+    }
     
-    console.log('[filterSplatsByBox] Boundary errors:');
-    console.log('  X error:', errorX.toFixed(3), 'm');
-    console.log('  Y error:', errorY.toFixed(3), 'm');
-    console.log('  Z error:', errorZ.toFixed(3), 'm');
+    // 境界から0.5m以内の頂点を記録
+    const distToEdgeX = Math.min(Math.abs(localPos.x + halfX), Math.abs(localPos.x - halfX));
+    const distToEdgeY = Math.min(Math.abs(localPos.y + halfY), Math.abs(localPos.y - halfY));
+    const distToEdgeZ = Math.min(Math.abs(localPos.z + halfZ), Math.abs(localPos.z - halfZ));
+    const minDistToEdge = Math.min(distToEdgeX, distToEdgeY, distToEdgeZ);
     
-    if (errorX > 0.1 || errorY > 0.1 || errorZ > 0.1) {
-      console.warn('[filterSplatsByBox] ⚠️ Boundary error > 0.1m detected!');
+    if (minDistToEdge < 0.5) {
+      boundaryVertices.push({
+        index,
+        world: { x: vertex.x, y: vertex.y, z: vertex.z },
+        local: { x: localPos.x, y: localPos.y, z: localPos.z },
+        inside,
+        distToEdge: minDistToEdge
+      });
     }
-  }
+  });
   
-  // 警告
-  if (filteredVertices.length < plyData.vertices.length * 0.1) {
-    console.warn('[filterSplatsByBox] ⚠️ WARNING: Less than 10% of splats kept!');
-    console.warn('[filterSplatsByBox]   Box may be too small or positioned incorrectly');
-  }
+  console.log('[DEBUG] Summary:');
+  console.log('  Inside:', insideCount);
+  console.log('  Outside:', outsideCount);
+  console.log('  Boundary vertices (within 0.5m):', boundaryVertices.length);
   
-  if (filteredVertices.length === 0) {
-    console.error('[filterSplatsByBox] ❌ ERROR: No vertices passed the filter!');
-    console.error('[filterSplatsByBox]   Check box position and size');
+  if (boundaryVertices.length > 0) {
+    console.log('[DEBUG] Boundary vertices details:');
+    boundaryVertices.slice(0, 20).forEach(v => {
+      console.log(`  V${v.index}: world(${v.world.x.toFixed(2)}, ${v.world.y.toFixed(2)}, ${v.world.z.toFixed(2)}) ` +
+                  `→ local(${v.local.x.toFixed(2)}, ${v.local.y.toFixed(2)}, ${v.local.z.toFixed(2)}) ` +
+                  `→ ${v.inside ? 'IN' : 'OUT'} (dist: ${v.distToEdge.toFixed(3)}m)`);
+    });
   }
   
-  return filteredVertices;
+  // 元のコードを続ける...
+  console.log('[filterSplatsByBox] Input parameters:');
+  // ...
 }
 
-
 //////////////////////////////12/15 17:20 end