Upload preprocess_manual.js

preprocess_manual.js

@@ -514,52 +514,146 @@ function createManualUI(scene, camera, renderer) {
 /**
  * Bounding Box内のスプラットのみをフィルタリング
  */
-/////////////////////////////12/13 17:20 start
+/////////////////////////////12/15 17:20 start
 
 
+// ========================================
+// 修正版 filterSplatsByBox 関数（詳細なデバッグ付き）
+// Line 594付近を置き換え
+// ========================================
+
 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);
+  
   const halfX = boxSize.x / 2;
   const halfY = boxSize.y / 2;
   const halfZ = boxSize.z / 2;
   
-  // ⭐ 修正: 符号を反転（正しい方向に回転）
+  console.log('[filterSplatsByBox] Box half-extents:', { halfX, halfY, halfZ });
+  
+  // 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();
   
-  const filteredVertices = plyData.vertices.filter(vertex => {
-    // Transform vertex to box-local space
+  console.log('[filterSplatsByBox] Rotation matrix created');
+  
+  // デバッグ: 最初の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 && localPos.x <= halfX &&
+      localPos.y >= -halfY && localPos.y <= halfY &&
+      localPos.z >= -halfZ && localPos.z <= halfZ
+    );
+    
+    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
+    });
+  }
+  
+  // 実際のフィルタリング
+  const filteredVertices = plyData.vertices.filter((vertex, index) => {
     const localPos = new THREE.Vector3(
       vertex.x - boxPosition.x,
       vertex.y - boxPosition.y,
       vertex.z - boxPosition.z
     );
     
-    // Apply inverse rotation
     localPos.applyMatrix4(inverseRotationMatrix);
     
-    // Check if inside box bounds
-    return (
+    const inside = (
       localPos.x >= -halfX && localPos.x <= halfX &&
       localPos.y >= -halfY && localPos.y <= halfY &&
       localPos.z >= -halfZ && localPos.z <= halfZ
     );
+    
+    return inside;
   });
   
-  console.log(`[filterSplatsByBox] Filtered: ${filteredVertices.length} / ${plyData.vertices.length} splats (${(filteredVertices.length/plyData.vertices.length*100).toFixed(1)}%)`);
+  // フィルタリング結果の統計
+  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));
+  }
+  
+  // 警告
   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/13 17:20 end
+//////////////////////////////12/15 17:20 end
 
 
 /**
@@ -1127,28 +1221,62 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
               // ----------------------------------------
 /////////////////// 12/15 18:00 全面描き直し
 
+              // ========================================
+              // 修正版 confirmBoxBtn（完全なデバッグ版）
+              // Line 1090-1220付近を置き換え
+              // ========================================
+
               const confirmBoxBtn = document.getElementById('confirm-box-btn');
               if (confirmBoxBtn) {
                 confirmBoxBtn.addEventListener('click', async () => {
-                  console.log('[preprocessManual] ===== CONFIRM BOX CLICKED =====');
-                  console.log('[preprocessManual] Box settings:', { 
-                    boxSize, 
-                    boxPosition, 
-                    boxRotation: {
-                      x: (boxRotation.x * 180 / Math.PI).toFixed(1),
-                      y: (boxRotation.y * 180 / Math.PI).toFixed(1),
-                      z: (boxRotation.z * 180 / Math.PI).toFixed(1)
-                    },
-                    plyOffset 
+                  console.log('\n\n');
+                  console.log('═══════════════════════════════════════════════════════');
+                  console.log('           CONFIRM BOX BUTTON CLICKED');
+                  console.log('═══════════════════════════════════════════════════════');
+                  
+                  // 現在のBOX設定をログ
+                  console.log('[STEP 1] Current BOX Settings:');
+                  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('  PLY Offset:', plyOffset);
+                  
+                  // 元のPLYデータの範囲を表示
+                  console.log('[STEP 2] Original PLY Data:');
+                  console.log('  Total vertices:', plyData.vertices.length);
+                  
+                  let origMinX = Infinity, origMinY = Infinity, origMinZ = Infinity;
+                  let origMaxX = -Infinity, origMaxY = -Infinity, origMaxZ = -Infinity;
+                  
+                  plyData.vertices.forEach(v => {
+                    origMinX = Math.min(origMinX, v.x);
+                    origMinY = Math.min(origMinY, v.y);
+                    origMinZ = Math.min(origMinZ, v.z);
+                    origMaxX = Math.max(origMaxX, v.x);
+                    origMaxY = Math.max(origMaxY, v.y);
+                    origMaxZ = Math.max(origMaxZ, v.z);
+                  });
+                  
+                  console.log('  Original bounds:');
+                  console.log('    X:', origMinX.toFixed(3), 'to', origMaxX.toFixed(3));
+                  console.log('    Y:', origMinY.toFixed(3), 'to', origMaxY.toFixed(3));
+                  console.log('    Z:', origMinZ.toFixed(3), 'to', origMaxZ.toFixed(3));
+                  console.log('  Original center:', {
+                    x: ((origMinX + origMaxX) / 2).toFixed(3),
+                    y: ((origMinY + origMaxY) / 2).toFixed(3),
+                    z: ((origMinZ + origMaxZ) / 2).toFixed(3)
                   });
                   
                   cleanupAnimation();
                   
-                  // ========================================
-                  // ⭐⭐⭐ CRITICAL: PLY OffsetをplyDataに適用してからGSを再読込
-                  // ========================================
+                  // PLY Offsetの適用
                   if (plyOffset.x !== 0 || plyOffset.y !== 0 || plyOffset.z !== 0) {
-                    console.log('[preprocessManual] Applying PLY offset:', plyOffset);
+                    console.log('[STEP 3] Applying PLY offset:', plyOffset);
                     
                     plyData.vertices.forEach(vertex => {
                       vertex.x += plyOffset.x;
@@ -1156,7 +1284,6 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
                       vertex.z += plyOffset.z;
                     });
                     
-                    // GSを再読込
                     await gs.viewer.dispose();
                     
                     const newHeader = plyData.header;
@@ -1165,44 +1292,38 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
                     const adjustedPlyUrl = URL.createObjectURL(blob);
                     
                     gs = await GVRM.initGS(adjustedPlyUrl, undefined, undefined, scene);
-                    console.log('[preprocessManual] ✓ GS reloaded with adjusted position');
+                    console.log('[STEP 3] ✓ GS reloaded with adjusted position');
                     
-                    // ⭐ 重要: PLY offsetをリセット（既に適用済み）
+                    // PLY offsetをリセット
                     plyOffset = { x: 0, y: 0, z: 0 };
+                  } else {
+                    console.log('[STEP 3] No PLY offset to apply');
                   }
                   
                   ui.hidePositionAdjustment();
                   ui.setStatus('Filtering splats with bounding box...');
                   
-                  // ========================================
-                  // ⭐⭐⭐ フィルタリング実行
-                  // ========================================
-                  console.log('[preprocessManual] Starting filtering...');
-                  console.log('[preprocessManual]   Total vertices before filter:', plyData.vertices.length);
-                  
+                  // フィルタリング実行
+                  console.log('[STEP 4] Starting filtering...');
                   const filteredVertices = filterSplatsByBox(plyData, boxSize, boxPosition, boxRotation);
                   
-                  console.log('[preprocessManual]   Filtered vertices:', filteredVertices.length);
-                  console.log('[preprocessManual]   Retention rate:', (filteredVertices.length / plyData.vertices.length * 100).toFixed(1), '%');
-                  
                   if (filteredVertices.length === 0) {
-                    alert('⚠️ No splats found in the box!\n\nPlease adjust the box size/position and try again.');
+                    console.error('[STEP 4] ❌ No splats found in the box!');
+                    alert('⚠️ No splats found in the box!\n\nPlease adjust the box size/position and try again.\n\nCheck the browser console for detailed debug information.');
                     ui.showPositionAdjustment();
                     return;
                   }
                   
                   if (filteredVertices.length < 10) {
-                    alert(`⚠️ Only ${filteredVertices.length} splats found!\n\nThis is too few. Please adjust the box.`);
+                    console.warn('[STEP 4] ⚠️ Only', filteredVertices.length, 'splats found');
+                    alert(`⚠️ Only ${filteredVertices.length} splats found!\n\nThis is too few. Please adjust the box.\n\nCheck the browser console for detailed debug information.`);
                     ui.showPositionAdjustment();
                     return;
                   }
                   
-                  // ========================================
-                  // ⭐⭐⭐ スプラットを中心化（原点へ移動）
-                  // ========================================
-                  console.log('[preprocessManual] ===== CENTERING SPLATS =====');
+                  // スプラットを中心化
+                  console.log('[STEP 5] Centering splats...');
                   
-                  // 現在の中心を計算
                   let newMinX = Infinity, newMinY = Infinity, newMinZ = Infinity;
                   let newMaxX = -Infinity, newMaxY = -Infinity, newMaxZ = -Infinity;
                   
@@ -1219,50 +1340,23 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
                   const centerY = (newMaxY + newMinY) / 2;
                   const centerZ = (newMaxZ + newMinZ) / 2;
                   
-                  console.log('[preprocessManual] Original center:', { 
-                    x: centerX.toFixed(3), 
-                    y: centerY.toFixed(3), 
-                    z: centerZ.toFixed(3) 
+                  console.log('[STEP 5] Before centering:', {
+                    center: { x: centerX.toFixed(3), y: centerY.toFixed(3), z: centerZ.toFixed(3) }
                   });
                   
-                  // 原点へ移動
                   filteredVertices.forEach(vertex => {
                     vertex.x -= centerX;
                     vertex.y -= centerY;
                     vertex.z -= centerZ;
                   });
                   
-                  // 検証
-                  let checkMinX = Infinity, checkMinY = Infinity, checkMinZ = Infinity;
-                  let checkMaxX = -Infinity, checkMaxY = -Infinity, checkMaxZ = -Infinity;
-                  
-                  filteredVertices.forEach(vertex => {
-                    checkMinX = Math.min(checkMinX, vertex.x);
-                    checkMinY = Math.min(checkMinY, vertex.y);
-                    checkMinZ = Math.min(checkMinZ, vertex.z);
-                    checkMaxX = Math.max(checkMaxX, vertex.x);
-                    checkMaxY = Math.max(checkMaxY, vertex.y);
-                    checkMaxZ = Math.max(checkMaxZ, vertex.z);
-                  });
-                  
-                  const newCenterX = (checkMaxX + checkMinX) / 2;
-                  const newCenterY = (checkMaxY + checkMinY) / 2;
-                  const newCenterZ = (checkMaxZ + checkMinZ) / 2;
-                  
-                  console.log('[preprocessManual] New center:', { 
-                    x: newCenterX.toFixed(3), 
-                    y: newCenterY.toFixed(3), 
-                    z: newCenterZ.toFixed(3) 
-                  });
-                  console.log('[preprocessManual] ✓ Splats centered to origin');
+                  console.log('[STEP 5] ✓ Splats centered to origin');
                   
-                  // ========================================
-                  // ⭐ フィルタ済みPLYファイルを保存（中心化後）
-                  // ========================================
+                  // フィルタ済みPLYを保存
+                  console.log('[STEP 6] Saving filtered PLY...');
                   try {
                     ui.setStatus('Saving filtered & centered PLY file...');
                     
-                    // Create new header with updated vertex count
                     const newHeader = plyData.header.map(line => {
                       if (line.startsWith('element vertex')) {
                         return `element vertex ${filteredVertices.length}`;
@@ -1270,45 +1364,36 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
                       return line;
                     });
                     
-                    // Create PLY file data
                     const filteredPlyData = parser.createPLYFile(
                       newHeader,
                       filteredVertices,
                       plyData.vertexSize
                     );
                     
-                    // Generate filename
                     const originalFilename = gsPath.split('/').pop().replace('.ply', '');
                     const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
-                    const filteredFilename = `${originalFilename}_filtered_centered_${timestamp}.ply`;
+                    const filteredFilename = `${originalFilename}_filtered_${timestamp}.ply`;
                     
-                    // Download the file
                     downloadPLY(filteredPlyData, filteredFilename);
                     
-                    console.log('[preprocessManual] ✓ Filtered & centered PLY saved:', filteredFilename);
-                    console.log('[preprocessManual]   Original vertices:', plyData.vertices.length);
-                    console.log('[preprocessManual]   Filtered vertices:', filteredVertices.length);
-                    console.log('[preprocessManual]   Reduction:', 
-                      ((1 - filteredVertices.length / plyData.vertices.length) * 100).toFixed(1), '%');
+                    console.log('[STEP 6] ✓ PLY saved:', filteredFilename);
+                    console.log('[STEP 6] Statistics:');
+                    console.log('  Original:', plyData.vertices.length, 'vertices');
+                    console.log('  Filtered:', filteredVertices.length, 'vertices');
+                    console.log('  Reduction:', ((1 - filteredVertices.length / plyData.vertices.length) * 100).toFixed(1), '%');
                     
-                    // Show success message
                     ui.setStatus(`✓ Saved: ${filteredFilename}`);
-                    
-                    // Wait a moment for user to see the message
                     await new Promise(resolve => setTimeout(resolve, 1000));
                     
                   } catch (error) {
-                    console.error('[preprocessManual] Error saving filtered PLY:', error);
+                    console.error('[STEP 6] ❌ Error saving PLY:', error);
                     alert('Failed to save filtered PLY file: ' + error.message);
-                    // Continue anyway
                   }
                   
-                  // ========================================
-                  // Continue with normal processing
-                  // ========================================
+                  // 残りの処理
+                  console.log('[STEP 7] Loading filtered splats into viewer...');
                   ui.setStatus('Loading filtered splats...');
                   
-                  // Create filtered PLY URL for loading into viewer
                   const filteredPlyUrl = createFilteredPLY(
                     parser,
                     plyData.header,
@@ -1316,27 +1401,27 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
                     plyData.vertexSize
                   );
                   
-                  // Dispose old GS
                   await gs.viewer.dispose();
                   
-                  // Load filtered GS (already centered)
                   const filteredGs = await GVRM.initGS(filteredPlyUrl, undefined, undefined, scene);
-                  console.log('[preprocessManual] ✓ Filtered GS loaded (centered at origin)');
+                  console.log('[STEP 7] ✓ Filtered GS loaded');
                   
                   ui.removeBoundingBox();
                   ui.setStatus('Loading VRM...');
                   
-                  // Load VRM
                   const character = await GVRM.initVRM(vrmPath, scene, camera, renderer, null);
-                  console.log('[preprocessManual] VRM loaded');
+                  console.log('[STEP 7] ✓ VRM loaded');
                   
-                  // Create GVRM instance
                   const gvrm = new GVRM(character, filteredGs);
                   
                   ui.setStatus('Step 2: Assign splats to bones');
                   ui.showBoneAssignment();
                   
-                  // Step 2: Bone Assignment
+                  console.log('═══════════════════════════════════════════════════════');
+                  console.log('           BOX FILTERING COMPLETE');
+                  console.log('═══════════════════════════════════════════════════════');
+                  console.log('\n\n');
+                  
                   const promise2 = setupBoneAssignment(
                     ui, scene, camera, renderer,
                     gvrm, character, filteredGs, filteredPlyUrl,
@@ -1354,6 +1439,7 @@ export function preprocessManual(vrmPath, gsPath, scene, camera, renderer, stage
                 });
               }
 
+////////////////// 12/15 18:00 全面描き直し
 
           }); // GVRM.initGS().then()閉じる
         }); // parser.parsePLY().then()閉じる