基于对应点计算ThreeJS变换矩阵的问题求助

你的核心问题出在矩阵构造逻辑错误，以及Matrix3转Matrix4时的分量映射错误，导致变换结果扭曲。以下是分步修正方案：

1. 正确构造变换计算用的矩阵 #

要推导将点集a映射到b的仿射变换矩阵M，必须将每个点的齐次坐标（x,y,1）作为列向量构造矩阵，而非行向量。ThreeJS的Matrix3构造参数是按行排列的，所以构造时需要对应调整：

// 构造矩阵A：列是a中点的齐次坐标
const aMatrix = new THREE.Matrix3(
  a[0][0], a[1][0], a[2][0], // 第一行：三个点的x值（对应矩阵A的第一列）
  a[0][1], a[1][1], a[2][1], // 第二行：三个点的y值（对应矩阵A的第二列）
  1,       1,       1        // 第三行：齐次坐标的1（对应矩阵A的第三列）
);

const bMatrix = new THREE.Matrix3(
  b[0][0], b[1][0], b[2][0],
  b[0][1], b[1][1], b[2][1],
  1,       1,       1
);

2. 计算变换矩阵并检查可逆性 #

仿射变换满足M * A = B，因此M = B * A⁻¹。ThreeJS的矩阵乘法是右乘逻辑，代码实现时需注意：

• 必须确保aMatrix可逆（即a中的三点不共线），否则求逆会得到无效矩阵。

// 克隆后求逆，避免修改原矩阵
const aInv = aMatrix.clone();
if (!aInv.invert()) {
  console.error("点集a中的三点共线，无法直接求逆，请使用最小二乘法");
  return;
}

// 计算变换矩阵M = bMatrix * aInv
const M = bMatrix.clone().multiply(aInv);

3. 正确将3x3矩阵转换为4x4矩阵应用到Mesh #

ThreeJS中Mesh的matrix是4x4矩阵，直接用setFromMatrix3会丢失3x3矩阵中的平移分量（第三列），必须手动映射分量：

// 将3x3仿射变换矩阵转换为适配3D空间的4x4矩阵
const meshMatrix = new THREE.Matrix4();
const m = M.elements;
// 按ThreeJS Matrix4的分量顺序填充：m11, m12, m13, m14; m21,m22,m23,m24; ...
meshMatrix.set(
  m[0], m[1], 0, m[2], // x轴变换 + x平移
  m[3], m[4], 0, m[5], // y轴变换 + y平移
  0,    0,    1, 0,    // z轴保持不变
  0,    0,    0, 1     // 齐次坐标分量
);

// 应用矩阵到Mesh，禁用自动更新以手动控制矩阵
mesh.matrix.copy(meshMatrix);
mesh.matrixAutoUpdate = false;

4. 处理点集共线/多点的情况 #

如果a中的三点共线，或者点集数量超过3个，需用最小二乘法计算最优仿射变换：

function computeAffineTransform(pointsA, pointsB) {
  const n = pointsA.length;
  let sumXa = 0, sumYa = 0, sumXb = 0, sumYb = 0;
  let sumXaXb = 0, sumYaXb = 0, sumXaYb = 0, sumYaYb = 0;
  let sumXaSq = 0, sumYaSq = 0, sumXaYa = 0;

  for (let i = 0; i < n; i++) {
    const [xa, ya] = pointsA[i];
    const [xb, yb] = pointsB[i];
    sumXa += xa;
    sumYa += ya;
    sumXb += xb;
    sumYb += yb;
    sumXaXb += xa * xb;
    sumYaXb += ya * xb;
    sumXaYb += xa * yb;
    sumYaYb += ya * yb;
    sumXaSq += xa * xa;
    sumYaSq += ya * ya;
    sumXaYa += xa * ya;
  }

  const meanXa = sumXa / n;
  const meanYa = sumYa / n;
  const meanXb = sumXb / n;
  const meanYb = sumYb / n;

  const Sxx = sumXaSq - n * meanXa * meanXa;
  const Syy = sumYaSq - n * meanYa * meanYa;
  const Sxy = sumXaYa - n * meanXa * meanYa;

  const Sxa = sumXaXb - n * meanXa * meanXb;
  const Sya = sumYaXb - n * meanYa * meanXb;
  const Sxb = sumXaYb - n * meanXa * meanYb;
  const Syb = sumYaYb - n * meanYa * meanYb;

  const denom = Sxx * Syy - Sxy * Sxy;
  let a, b, c, d;
  if (Math.abs(denom) < 1e-8) {
    // 共线时的线性变换 fallback
    a = Sxa / (Sxx + Sxy) || 1;
    b = Sxb / (Sxx + Sxy) || 0;
    c = Sya / (Syy + Sxy) || 0;
    d = Syb / (Syy + Sxy) || 1;
  } else {
    a = (Sxa * Syy - Sya * Sxy) / denom;
    b = (Sxb * Syy - Syb * Sxy) / denom;
    c = (Sya * Sxx - Sxa * Sxy) / denom;
    d = (Syb * Sxx - Sxb * Sxy) / denom;
  }

  const tx = meanXb - a * meanXa - b * meanYa;
  const ty = meanYb - c * meanXa - d * meanYa;

  return new THREE.Matrix3(
    a, b, tx,
    c, d, ty,
    0, 0, 1
  );
}

// 使用示例
const M = computeAffineTransform(a, b);
// 后续转换为Matrix4应用到Mesh的逻辑同上

为什么之前的方法会扭曲？ #

1. 矩阵构造错误：你将点按行存储，导致变换的映射逻辑完全偏离仿射变换的标准推导（基于列向量）。
2. Matrix3转Matrix4错误：setFromMatrix3会丢弃3x3矩阵中的平移分量，同时错误映射变换分量，导致模型扭曲。
3. 未检查可逆性：若点集共线，求逆得到的无效矩阵会引发异常变换。

内容的提问来源于stack exchange，提问作者melvona