algorithm - 两组点之间的转换

Question

我有对象让我们说模型图像。我想计算模型图像上的对象和目标图像上的对象之间的变换(位移、比例、旋转)。我想假设对象可以被视为 2D，因此只应计算 2D 转换。

首先我想以手动辅助的方式进行。用户在模型图像上选择基点，然后在目标图像上选择目标点。点数应由用户定义(但至少不少于 2-3 个点)。当点给出不同的信息时，应该对转换进行平均，例如可以从中计算匹配质量。

所以问题是关于计算两组点的变换，但因为我想在图像上做，所以我添加了图像处理标签。

特别欢迎使用一些代码或伪代码的引用和建议。

对于两个点，这是一个非常简单的问题，只需要旋转、缩放和线的位移，但是如何用更多的点来做，并对其求平均并计算一些质量因素。

目前的解决方案是:

void transformFnc(std::vector<PointF> basePoints, std::vector<PointF> targetPoints,
                  PointF& offset, double rotation, double scale)
{
    std::vector<Line> basePointsLines;
    std::vector<Line> targetPointsLines;
    assert(basePoints.size() == targetPoints.size());
    int pointsNumber = basePoints.size();

    for(int i = 0; i < pointsNumber; i++)
    {
         for(int j = i + 1; j < pointsNumber; j++)
         {
             basePointsLines.push_back(Line(basePoints[i], basePoints[j]));
             targetPointsLines.push_back(Line(targetPoints[i], targetPoints[j]));
         }
    }
    std::vector<double> scalesVector;
    std::vector<double> rotationsVector;
    double baseCenterX = 0, baseCenterY = 0, targetCenterX = 0, targetCenterY = 0;
    for(std::vector<Line>::iterator it = basePointsLines.begin(), i = targetPointsLines.begin();
        it != basePointsLines.end(), i != targetPointsLines.end(); it++, i++)
    {
        scalesVector.push_back((*i).length()/(*it).length());
        baseCenterX += (*it).pointAt(0.5).x(); 
        baseCenterY += (*it).pointAt(0.5).y();
        targetCenterX += (*i).pointAt(0.5).x();
        targetCenterY += (*i).pointAt(0.5).y();
        double rotation;
        rotation = (*i).angleTo((*it));
        rotationsVector.push_back(rotation);
    }
    baseCenterX = baseCenterX / pointsNumber;
    baseCenterY = baseCenterY / pointsNumber;
    targetCenterX = targetCenterX / pointsNumber;
    targetCenterY = targetCenterY / pointsNumber;

    offset = PointF(targetCenterX - baseCenterX, targetCenterY - baseCenterY);
    scale = sum(scalesVector) / scalesVector.size();
    rotation = sum(rotationsVector) / rotationsVector.size();
}

我能在这段代码中找到的唯一优化是从缩放和旋转中消除那些与其余值差异太大的值。

我正在寻找解决方案命题的代码或伪代码。也可以是一些代码的引用。

到目前为止，我所知道的答案是:

• 可以使用RANSAC算法
• 我需要寻找一些最小二乘意义上的仿射变换计算算法

Answer 1

首先使用 3x3 仿射变换矩阵将问题概括为简单的仿射变换:即

[M11 M12 M13]
[M21 M22 M23]
[M31 M32 M33]

因为我们已经知道第三行总是 [0 0 1] 我们可以简单地忽略它。

现在我们可以将问题描述为下面的矩阵方程

[xp0]     [x0 y0 1  0  0  0 ]
[yp0]     [0  0  0  x0 y0 1 ]     [M11]
[xp1]     [x1 y1 1  0  0  0 ]     [M12]
[yp1]  =  [0  0  0  x1 y1 1 ]  *  [M13]
[xp2]     [x2 y2 1  0  0  0 ]     [M21]
[yp2]     [0  0  0  x2 y2 1 ]     [M22]
[xp3]     [x3 y3 1  0  0  0 ]     [M23]
[yp3]     [0  0  0  x3 y3 1 ]

其中 xp 和 yp 是投影坐标，x 和 y 是原始坐标。

我们称之为

proj = M * trans

然后我们可以通过以下方式计算适合变换的最小二乘法

trans = pinv(M) * proj

其中 pinv 是伪逆。

这给了我们一个仿射变换，它最适合在最小二乘意义上给定的点。

显然，这也会产生您不想要的剪切、坐标翻转以及非均匀缩放，因此我们需要以某种方式限制仿射变换以避免剪切。事实证明这很容易，我们可以使用一个向量来描述旋转(向量的方向)和缩放(向量的大小)，另一个向量将简单地与它正交。这将自由度减少了两倍。

M21 = -M12
M22 = M11

所以减少到

[xp0]     [x0  y0 1 0]
[yp0]     [y0 -x0 0 1]
[xp1]     [x1  y1 1 0]     [M11]
[yp1]  =  [y1 -x1 0 1]  *  [M12]
[xp2]     [x2  y2 1 0]     [M13]
[yp2]     [y2 -x2 0 1]     [M23]
[xp3]     [x3  y3 1 0]
[yp3]     [y3 -x3 0 1]

求解完上述矩阵方程后，由M12和M11计算出M21和M22。