三维重建SfM算法_sfm三维重建

概述

三维重建的 SfM (Structure from Motion) 算法是通过多张二维图片来重建三维场景的算法。

算法实现流程：

1. 特征点提取
   在这个步骤中，需要对每张图片提取出一些特征点，并计算它们的描述子。在特征点提取的过程中，可以使用 SIFT，SURF 等算法。一般来说，一个好的特征点需要具备旋转不变性、尺度不变性和灰度不变性。
2. 特征匹配
   将不同图片中的特征点进行匹配，找到它们之间的对应关系。可以使用 KNN，FLANN 等算法进行特征匹配。需要注意的是，在匹配的过程中，需要使用一些鲁棒的技巧来避免匹配误差的影响。
3. 相机姿态估计
   通过特征点匹配，可以得到不同图片之间的几何变换关系。通过这些变换关系，可以估计出相机的姿态，包括相机的位置和方向。常用的算法包括 RANSAC 算法和 P3P 算法。
4. 三角测量
   在相机姿态估计的基础上，通过三角测量的方法来估计场景中每个特征点的三维位置。一般来说，需要使用两个相机的视角来进行三角测量，这个过程叫做三角化。
5. 重建场景
   在完成了每张图片的三维重建之后，需要将它们融合起来来构建整个场景的三维模型。可以使用 BA（Bundle Adjustment）等算法对重建结果进行优化。
   需要注意的是，由于 SfM 算法是一种迭代的算法，所以在每个步骤中都需要不断地调整参数和优化结果，以获得更加准确和稳定的结果。

使用golang实现

以下是使用 Golang 实现 SfM 的基本步骤：

1. 特征点提取
   可以使用 GoCV 库中的 SIFT 特征点提取函数，如下所示：

import (
    "gocv.io/x/gocv"
)

func extractFeatures(img gocv.Mat) gocv.KeyPoints {
    sift := gocv.NewSIFT()
    defer sift.Close()

    mask := gocv.NewMat()
    defer mask.Close()

    descriptors := gocv.NewMat()
    defer descriptors.Close()

    keypoints := sift.Detect(img, mask)
    descriptors = sift.Compute(img, keypoints)

    return keypoints
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2. 特征匹配
   可以使用 GoCV 库中的 FlannBasedMatcher 特征匹配函数，如下所示：

import (
    "gocv.io/x/gocv"
)

func matchFeatures(des1, des2 gocv.Mat) []gocv.DMatch {
    matcher := gocv.NewFlannBasedMatcher()
    defer matcher.Close()

    matches := matcher.KnnMatch(des1, des2, 2)
    var goodMatches []gocv.DMatch

    for i, match := range matches {
        if len(match) < 2 {
            continue
        }
        if match[0].Distance < 0.7*match[1].Distance {
            goodMatches = append(goodMatches, matches[i][0])
        }
    }

    return goodMatches
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3. 相机姿态估计
   可以使用 GoCV 库中的 SolvePnPRansac 函数，如下所示：

import (
    "gocv.io/x/gocv"
)

func estimatePose(keypoints1, keypoints2 []gocv.KeyPoint, matches []gocv.DMatch, cameraMatrix gocv.Mat) (gocv.Mat, gocv.Mat) {
    points1 := make([]gocv.Point2f, len(matches))
    points2 := make([]gocv.Point3f, len(matches))

    for i, match := range matches {
        points1[i] = keypoints1[match.QueryIdx].Pt
        points2[i] = gocv.Point3f{
            X: float32(keypoints2[match.TrainIdx].Pt.X),
            Y: float32(keypoints2[match.TrainIdx].Pt.Y),
            Z: 0.0,
        }
    }

    rvec := gocv.NewMat()
    defer rvec.Close()

    tvec := gocv.NewMat()
    defer tvec.Close()

    inliers := make([]byte, len(matches))

    gocv.SolvePnPRansac(points2, points1, cameraMatrix, gocv.NewMat(), &rvec, &tvec, false, 100, 8.0, 0.99, gocv.NewMatVector(), gocv.SolvePnpIterCount, 2000, &inliers)

    return rvec, tvec
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

4. 三角测量
   可以使用 GoCV 库中的 TriangulatePoints 函数，如下所示：

import (
    "gocv.io/x/gocv"
)

func triangulatePoints(points1, points2 []gocv.Point2f, cameraMatrix1, cameraMatrix2, distCoeffs1, distCoeffs2 gocv.Mat, rvec1, tvec1, rvec2, tvec2 gocv.Mat) gocv.Mat {
    projectionMatrix1 := gocv.NewMat()
    defer projectionMatrix1.Close()

    gocv.ComposeRT(rvec1, tvec1, &projectionMatrix1)
    projectionMatrix1.Multiply(cameraMatrix1, &projectionMatrix1)

    projectionMatrix2 := gocv.NewMat()
    defer projectionMatrix2.Close()

    gocv.ComposeRT(rvec2, tvec2, &projectionMatrix2)
    projectionMatrix2.Multiply(cameraMatrix2, &projectionMatrix2)

    points4D := gocv.NewMat()
    defer points4D.Close()

    gocv.TriangulatePoints(projectionMatrix1, projectionMatrix2, points1, points2, &points4D)

    points3D := gocv.NewMat()
    defer points3D.Close()

    gocv.ConvertPointsFromHomogeneous(points4D.T(), &points3D)

    return points3D
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

5. 点云重建
   可以使用 PCL 库中的 PointCloud 函数，如下所示：

import (
    "github.com/strawberryfg/pcl"
)

func reconstructPointCloud(points3D []gocv.Point3f) *pcl.PointCloud {
    cloud := pcl.NewPointCloud()
    defer cloud.Close()

    for _, point := range points3D {
        pclPoint := pcl.NewPointXYZRGB(point.X, point.Y, point.Z, 255, 255, 255)
        cloud.PushBack(pclPoint)
    }

    return cloud
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

以上这些代码片段可以组合成一个 SfM 算法的基本实现。当然，这只是一个简单的示例，实际应用中可能需要更多的步骤和复杂的实现。