Upload preprocess_manual.js

preprocess_manual.js

@@ -1647,31 +1647,57 @@ parser.parsePLY(gsPath, true).then((plyData) => {
                   console.log('  boxRotation:', boxRotation);
                   console.log('  plyOffset:', plyOffset);
                   
-                  // 元のPLYデータの範囲を表示
-                  console.log('[STEP 2] Original PLY Data:');
+                  ////////////////////////////////////////////////////0123 start
+                  // ⭐ 修正: 中心化後のPLYデータの範囲を確認
+                  console.log('[STEP 2] Centered PLY Data (should be ~0,0,0):');
                   console.log('  Total vertices:', plyData.vertices.length);
-                  
-                  let origMinX = Infinity, origMinY = Infinity, origMinZ = Infinity;
-                  let origMaxX = -Infinity, origMaxY = -Infinity, origMaxZ = -Infinity;
-                  
+
+                  let centeredMinX = Infinity, centeredMinY = Infinity, centeredMinZ = Infinity;
+                  let centeredMaxX = -Infinity, centeredMaxY = -Infinity, centeredMaxZ = -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);
+                    centeredMinX = Math.min(centeredMinX, v.x);
+                    centeredMinY = Math.min(centeredMinY, v.y);
+                    centeredMinZ = Math.min(centeredMinZ, v.z);
+                    centeredMaxX = Math.max(centeredMaxX, v.x);
+                    centeredMaxY = Math.max(centeredMaxY, v.y);
+                    centeredMaxZ = Math.max(centeredMaxZ, 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)
+
+                  console.log('  Centered bounds:');
+                  console.log('    X:', centeredMinX.toFixed(3), 'to', centeredMaxX.toFixed(3));
+                  console.log('    Y:', centeredMinY.toFixed(3), 'to', centeredMaxY.toFixed(3));
+                  console.log('    Z:', centeredMinZ.toFixed(3), 'to', centeredMaxZ.toFixed(3));
+
+                  const centeredCenter = {
+                    x: (centeredMinX + centeredMaxX) / 2,
+                    y: (centeredMinY + centeredMaxY) / 2,
+                    z: (centeredMinZ + centeredMaxZ) / 2
+                  };
+
+                  console.log('  Centered center:', {
+                    x: centeredCenter.x.toFixed(3),
+                    y: centeredCenter.y.toFixed(3),
+                    z: centeredCenter.z.toFixed(3)
                   });
+
+                  // ⭐ 検証: 中心が 0,0,0 から離れすぎている場合は警告
+                  if (Math.abs(centeredCenter.x) > 0.1 || 
+                      Math.abs(centeredCenter.y) > 0.1 || 
+                      Math.abs(centeredCenter.z) > 0.1) {
+                    console.error('[STEP 2] ❌ ERROR: PLY is NOT properly centered!');
+                    console.error('[STEP 2] Expected ~(0,0,0) but got:', centeredCenter);
+                    console.error('[STEP 2] This will cause Box filtering to fail!');
+                    
+                    // ⭐ 緊急修正: もう一度中心化
+                    console.log('[STEP 2] Emergency re-centering...');
+                    plyData.vertices.forEach(v => {
+                      v.x -= centeredCenter.x;
+                      v.y -= centeredCenter.y;
+                      v.z -= centeredCenter.z;
+                    });
+                    console.log('[STEP 2] ✓ PLY force-centered to origin');
+                  }
                   
                   cleanupAnimation();
                   
@@ -1735,130 +1761,82 @@ parser.parsePLY(gsPath, true).then((plyData) => {
                   ui.setStatus('Filtering splats with bounding box...');
 
 
-      ///////////////////////////////13:47
+      ///////////////////////////////////////13:47 start
 
-              // ⭐⭐⭐ 重要: gs.centers0 を使用してフィルタリング ⭐⭐⭐
-        // plyData.vertices ではなく、実際に表示されている座標を使う
+                  console.log('[STEP 4] ⭐ Transforming Box coordinates to GS local space');
 
-        console.log('[STEP 4] Using gs.centers0 (displayed coordinates) for filtering');
+                  // GS Scene の変換行列を取得
+                  const gsScene = gs.viewer.splatMesh.scenes[0];
+                  gsScene.updateMatrixWorld(true);
 
-        // gs.centers0 から vertices 配列を作成
-        const displayedVertices = [];
-        for (let i = 0; i < gs.splatCount; i++) {
-          displayedVertices.push({
-            x: gs.centers0[i * 3 + 0],
-            y: gs.centers0[i * 3 + 1],
-            z: gs.centers0[i * 3 + 2],
-            // 元のインデックスを保持（後で元のデータを参照するため）
-            originalIndex: i
-          });
-        }
-
-        console.log('[STEP 4] Created displayedVertices array:', displayedVertices.length, 'vertices');
-
-        // ⭐ GS Scene の変換を考慮
-        const gsScene = gs.viewer.splatMesh.scenes[0];
-        gsScene.updateMatrixWorld(true);
-
-        console.log('[STEP 4] GS Scene transform:');
-        console.log('  Position:', gsScene.position);
-        console.log('  Rotation:', gsScene.rotation);
-        console.log('  Scale:', gsScene.scale);
-
-        // ワールド座標に変換されたBox設定を使用
-        const boxWorldPosition = new THREE.Vector3(
-          currentBoxPosition.x,
-          currentBoxPosition.y,
-          currentBoxPosition.z
-        );
-
-        // GS Scene の逆変換を適用（BoxをGSのローカル空間に変換）
-        const gsInverseMatrix = new THREE.Matrix4().copy(gsScene.matrixWorld).invert();
-        boxWorldPosition.applyMatrix4(gsInverseMatrix);
+                  // Box Position を Three.js Vector3 に変換
+                  const boxWorldPosition = new THREE.Vector3(
+                    currentBoxPosition.x,
+                    currentBoxPosition.y,
+                    currentBoxPosition.z
+                  );
 
-        console.log('[STEP 4] Box position in GS local space:', {
-          x: boxWorldPosition.x.toFixed(3),
-          y: boxWorldPosition.y.toFixed(3),
-          z: boxWorldPosition.z.toFixed(3)
-        });
+                  // GS の逆行列を適用してローカル空間に変換
+                  const gsInverseMatrix = new THREE.Matrix4().copy(gsScene.matrixWorld).invert();
+                  const boxLocalPosition = boxWorldPosition.applyMatrix4(gsInverseMatrix);
 
-        // ⭐⭐⭐ 修正版フィルタリング関数を呼び出し ⭐⭐⭐
-        function filterDisplayedSplats(vertices, boxSize, boxPosition, boxRotation) {
-          console.log('[filterDisplayedSplats] Filtering', vertices.length, 'vertices');
-          console.log('[filterDisplayedSplats] Box settings:', {
-            size: boxSize,
-            position: boxPosition,
-            rotation: {
-              x: (boxRotation.x * 180 / Math.PI).toFixed(1) + '°',
-              y: (boxRotation.y * 180 / Math.PI).toFixed(1) + '°',
-              z: (boxRotation.z * 180 / Math.PI).toFixed(1) + '°'
-            }
-          });
-          
-          const halfX = boxSize.x / 2;
-          const halfY = boxSize.y / 2;
-          const halfZ = boxSize.z / 2;
-          const epsilon = 0.01;
-          
-          // 回転行列
-          const rotationMatrix = new THREE.Matrix4();
-          rotationMatrix.makeRotationFromEuler(new THREE.Euler(boxRotation.x, boxRotation.y, boxRotation.z));
-          const inverseRotationMatrix = new THREE.Matrix4().copy(rotationMatrix).invert();
-          
-          // フィルタリング
-          const filtered = vertices.filter((vertex) => {
-            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 + epsilon) && localPos.x <= (halfX + epsilon) &&
-              localPos.y >= -(halfY + epsilon) && localPos.y <= (halfY + epsilon) &&
-              localPos.z >= -(halfZ + epsilon) && localPos.z <= (halfZ + epsilon)
-            );
-            
-            return inside;
-          });
-          
-          console.log('[filterDisplayedSplats] Filtered:', filtered.length, '/', vertices.length);
-          console.log('[filterDisplayedSplats] Retention rate:', (filtered.length / vertices.length * 100).toFixed(1), '%');
-          
-          return filtered;
-        }
+                  console.log('[STEP 4] Box position transformation:');
+                  console.log('  World space:', currentBoxPosition);
+                  console.log('  GS local space:', {
+                    x: boxLocalPosition.x.toFixed(3),
+                    y: boxLocalPosition.y.toFixed(3),
+                    z: boxLocalPosition.z.toFixed(3)
+                  });
 
-        // ⭐ GS local space でフィルタリング
-        const filteredDisplayed = filterDisplayedSplats(
-          displayedVertices,
-          currentBoxSize,
-          boxWorldPosition, // ← GS local space に変換済み
-          currentBoxRotation
-        );
+                  // Box Rotation も変換
+                  const boxRotationEuler = new THREE.Euler(
+                    currentBoxRotation.x,
+                    currentBoxRotation.y,
+                    currentBoxRotation.z
+                  );
+                  const boxRotationMatrix = new THREE.Matrix4().makeRotationFromEuler(boxRotationEuler);
 
-        if (filteredDisplayed.length === 0) {
-          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.');
-          ui.showPositionAdjustment();
-          return;
-        }
+                  // GS の回転を抽出
+                  const gsRotationMatrix = new THREE.Matrix4().extractRotation(gsScene.matrixWorld);
 
-        console.log('[STEP 4] ✓ Filtering complete:', filteredDisplayed.length, 'splats kept');
+                  // 合成: GS^-1 * Box
+                  const combinedRotationMatrix = new THREE.Matrix4()
+                    .copy(gsRotationMatrix)
+                    .invert()
+                    .multiply(boxRotationMatrix);
 
+                  const combinedRotationEuler = new THREE.Euler().setFromRotationMatrix(combinedRotationMatrix);
 
-       /////////////////////////////////////13:47
+                  console.log('[STEP 4] Box rotation transformation:');
+                  console.log('  World space (deg):', {
+                    x: (currentBoxRotation.x * 180 / Math.PI).toFixed(1) + '°',
+                    y: (currentBoxRotation.y * 180 / Math.PI).toFixed(1) + '°',
+                    z: (currentBoxRotation.z * 180 / Math.PI).toFixed(1) + '°'
+                  });
+                  console.log('  GS local space (deg):', {
+                    x: (combinedRotationEuler.x * 180 / Math.PI).toFixed(1) + '°',
+                    y: (combinedRotationEuler.y * 180 / Math.PI).toFixed(1) + '°',
+                    z: (combinedRotationEuler.z * 180 / Math.PI).toFixed(1) + '°'
+                  });
 
-                  // ⭐⭐⭐ 修正: currentBoxSize, currentBoxPosition, currentBoxRotation を使用 ⭐⭐⭐
-                  console.log('[STEP 4] ⭐ Calling filterSplatsByBox with CURRENT values from UI');
+                  // ⭐⭐⭐ 変換後の座標で filterSplatsByBox を呼ぶ
                   const filteredVertices = filterSplatsByBox(
                     plyData, 
-                    currentBoxSize,      // ← UI から取得した値
-                    currentBoxPosition,  // ← UI から取得した値
-                    currentBoxRotation   // ← UI から取得した値
+                    currentBoxSize,
+                    {
+                      x: boxLocalPosition.x,
+                      y: boxLocalPosition.y,
+                      z: boxLocalPosition.z
+                    },
+                    {
+                      x: combinedRotationEuler.x,
+                      y: combinedRotationEuler.y,
+                      z: combinedRotationEuler.z
+                    }
                   );
 
+       /////////////////////////////////////13:47 end
+
                   if (filteredVertices.length === 0) {
                     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.');