Upload preprocess_manual.js

preprocess_manual.js

@@ -526,7 +526,7 @@ function createManualUI(scene, camera, renderer) {
 function filterSplatsByBox(plyData, boxSize, boxPosition, boxRotation = { x: 0, y: 0, z: 0 }) {
   console.log('[filterSplatsByBox] ===== FILTERING START =====');
   
-  // ⭐⭐⭐ 追加: すべての頂点の詳細を出力 ⭐⭐⭐
+  // ⭐ デバッグコード
   console.log('[DEBUG] ALL VERTICES ANALYSIS:');
   
   const halfX = boxSize.x / 2;
@@ -539,7 +539,7 @@ function filterSplatsByBox(plyData, boxSize, boxPosition, boxRotation = { x: 0,
   
   let insideCount = 0;
   let outsideCount = 0;
-  let boundaryVertices = []; // 境界付近の頂点
+  let boundaryVertices = [];
   
   plyData.vertices.forEach((vertex, index) => {
     const localPos = new THREE.Vector3(
@@ -592,9 +592,152 @@ function filterSplatsByBox(plyData, boxSize, boxPosition, boxRotation = { x: 0,
     });
   }
   
-  // 元のコードを続ける...
+  // ⭐⭐⭐ ここから元のコードを続ける ⭐⭐⭐
   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('[filterSplatsByBox] Box half-extents:', { halfX, halfY, halfZ });
+  console.log('[filterSplatsByBox] Using epsilon: 0.0001');
+  
+  console.log('[filterSplatsByBox] Rotation matrix created');
+  
+  // Sample vertices (最初の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);
+    
+    const inside = (
+      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)
+    );
+    
+    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) => {
+    const localPos = new THREE.Vector3(
+      vertex.x - boxPosition.x,
+      vertex.y - boxPosition.y,
+      vertex.z - boxPosition.z
+    );
+    
+    localPos.applyMatrix4(inverseRotationMatrix);
+    
+    const inside = (
+      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)
+    });
+    
+    // 回転がない場合のみ期待値を計算
+    const hasRotation = Math.abs(boxRotation.x) > 0.01 || 
+                        Math.abs(boxRotation.y) > 0.01 || 
+                        Math.abs(boxRotation.z) > 0.01;
+    
+    if (!hasRotation) {
+      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 (no rotation):');
+      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));
+      
+      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');
+      
+      if (errorX > 0.1 || errorY > 0.1 || errorZ > 0.1) {
+        console.warn('[filterSplatsByBox] ⚠️ Boundary error > 0.1m detected!');
+      }
+    } else {
+      console.log('[filterSplatsByBox] ℹ️ Box is rotated - Expected bounds check skipped');
+      console.log('[filterSplatsByBox] Filtered bounds above show actual world-space result');
+    }
+  }
+  
+  // 警告
+  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');
+  }
+  
+  if (filteredVertices.length === 0) {
+    console.error('[filterSplatsByBox] ❌ ERROR: No vertices passed the filter!');
+    console.error('[filterSplatsByBox]   Check box position and size');
+  }
+  
+  // ⭐⭐⭐ 必須: 結果を返す ⭐⭐⭐
+  return filteredVertices;
 }
 
 //////////////////////////////12/15 17:20 end