4 OpenCV实现多目三维重建（多张图片增量式生成稀疏点云）【附源码】

news2024/11/18 15:26:03

本文是基于 OpenCV4.80 进行的，关于环境的配置可能之后会单独说，先提一嘴 vcpkg 真好用

1 大致流程

从多张图片逐步生成稀疏点云，这个过程通常包括以下步骤：

  1. 初始重建：

    初始两张图片的选择十分重要，这是整个流程的基础，后续的增图都是在这两张图片的基础上进行的

    • 对于输入图像，首先需要提取特征点（例如，SIFT、SURF或ORB特征点）。然后，通过匹配不同图像中的特征点，建立它们之间的对应关系
    • 通过两张图像之间的本质矩阵 E 估计相机的外参矩阵（旋转矩阵 R 和平移向量 T ），然后使用三角测量法计算出一些初始的三维点

    具体操作可以查看我前面的博客

  2. 增量式重建：

    从这开始，逐步增加图像，逐渐扩展三维点云

    • 添加新的图像：将新的图像加载到重建流程中
    • 特征提取和匹配：对新的图像提取特征点并与先前图像匹配以获得新的匹配关系
    • 位姿估计：估计新图像相对于先前图像的相机位姿，通常使用 PnP（Perspective-n-Point）—— 在已知相机内参数 K 的前提下，用该角度下的三维点（object_points）与它们对应的图像点（image_points）坐标，估算出此时拍摄位置的信息
    • 三维点三角测量：使用新的匹配对和估计的位姿（R，T）来三角测量，生成新的三维点。
    • 点云合并：将新生成的三维点与先前的点云进行合并，构建一个更大的稀疏点云

  3. 全局点云优化：在稀疏点云已经生成后，可以使用全局点云优化技术，例如Bundle Adjustment，来提高点云的准确性

2 准备代码

之前文章中，我们讲所有代码都挤到了main函数中，十分不美观，现在我们进行一下代码的优化

由于才学C++，比较菜请见谅

2.1 Include.h

这里包含了所有用到的头文件和宏，方便之后使用

由于之后要用 Bundle Adjustment，所以引入了 ceres，具体环境配置之后可能会说（真的比较麻烦，强烈推荐 vcpkg ），其中大量的 #define 和 #pragma warning(disable: 4996) 都是关于 ceres 的报错的

#ifndef INCLUDES_H
#define INCLUDES_H

#define GLOG_NO_ABBREVIATED_SEVERITIES
#define _CRT_NONSTDC_NO_DEPRECATE
#define NOMINMAX
#define _CRT_NONSTDC_NO_WARNINGS
#pragma warning(disable: 4996)

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <fstream>
#include <ceres/ceres.h>
#include <ceres/rotation.h>



using namespace cv;
using namespace std;
#endif // !INCLUDES_H

#pragma once

2.2 Constructor

Constructor 类，其中包含了三维重建的几个关键步骤的函数：

  • findCamera：初始构建使用的求取 E 矩阵和R，T（其中包括了RANSAC）
  • maskoutPoints：通过内点标记mask，来对点进行筛选
  • pointsReconstruct：通过 R，T 匹配点来进行三角化生成三维点云

Constructor.h：

#ifndef CONSTRUCTOR_H
#define CONSTRUCTOR_H

#include "Includes.h"
#include "Images.h"

class Constructor
{
public:
	// 输入K，图1的匹配点，图2的匹配点；输出R，T；点经过筛选
	static void findCamera(Mat K, vector<Point2f>& point1, vector<Point2f>& point2, Mat& output_R, Mat& output_T, vector<uchar>& mask);
	
	// 输入图匹配点，内点标记mask；返回mask后的vector<Point2f>匹配点
	static void maskoutPoints(vector<Point2f>& input_points, vector<uchar>& input_mask);

	// 输入图一的R，T，匹配点，图二的R，T，匹配点；返回vector<Point3f>三维点
	static vector<Point3d>& pointsReconstruct(const Mat& K, Mat& R1, Mat& T1, Mat& R2, Mat& T2, vector<Point2f>& points1, vector<Point2f>& points2);
};


#endif // !CONSTRUCTOR_H

#pragma once

Constructor.cpp：

#include "Constructor.h"

void Constructor::findCamera(Mat K, vector<Point2f>& point1, vector<Point2f>& point2, Mat& output_R, Mat& output_T, vector<uchar>& mask)
{
	vector<uchar> inliers;

	Mat F;
	F = findFundamentalMat(point1, point2, inliers, FM_RANSAC, 1, 0.5);
	Mat E = K.t() * F * K;

	//Mat E = findEssentialMat(point1, point2, K, RANSAC, 0.6, 1.0, inliners);
	
	mask = inliers;

	// 根据内点筛选出新的匹配点
	Constructor::maskoutPoints(point1, inliers);
	Constructor::maskoutPoints(point2, inliers);

	// 分解E矩阵，获取R，T矩阵
	int pass_count = recoverPose(E, point1, point2, K, output_R, output_T);
}


void Constructor::maskoutPoints(vector<Point2f>& input_points, vector<uchar>& input_mask)
{
	vector<Point2f> temp_points(input_points);
	input_points.clear();

	for (int i = 0; i < temp_points.size(); ++i)
	{
		if (input_mask[i])
		{
			input_points.push_back(temp_points[i]);
		}
	}
}


vector<Point3d>& Constructor::pointsReconstruct(const Mat& K, Mat& R1, Mat& T1, Mat& R2, Mat& T2, vector<Point2f>& points1, vector<Point2f>& points2)
{
	// 构造投影矩阵
	Mat proj1(3, 4, CV_32FC1);
	Mat proj2(3, 4, CV_32FC1);

	// 将旋转矩阵和平移向量合并为投影矩阵
	R1.convertTo(proj1(Range(0, 3), Range(0, 3)), CV_32FC1);
	T1.convertTo(proj1.col(3), CV_32FC1);

	R2.convertTo(proj2(Range(0, 3), Range(0, 3)), CV_32FC1);
	T2.convertTo(proj2.col(3), CV_32FC1);

	// 将内参矩阵与投影矩阵相乘，得到最终的投影矩阵
	Mat fK;
	K.convertTo(fK, CV_32FC1);
	proj1 = fK * proj1;
	proj2 = fK * proj2;

	// 三角化，得到齐次坐标
	Mat point4D_homogeneous(4, points1.size(), CV_64F);
	triangulatePoints(proj1, proj2, points1, points2, point4D_homogeneous);

	// 将齐次坐标转换为三维坐标
	vector<Point3d> point3D;
	point3D.clear();
	point3D.reserve(point4D_homogeneous.cols);
	for (int i = 0; i < point4D_homogeneous.cols; ++i)
	{
		Mat<float> col = point4D_homogeneous.col(i);
		col /= col(3);
		point3D.push_back(Point3d(col(0), col(1), col(2)));
	}

	// 将三维坐标存储在Point3d向量中并返回
	return point3D;
}

2.3 Image

为了增图，我们需要存储图像中每个特征点在空间中的对应点—— correspond_struct_idx

Image 类，其中有成员变量：

  • Mat image—— 存储图像
  • vector<KeyPoint> keyPoints—— 存储特征点
  • Mat descriptor—— 存储特征描述符
  • vector<int> correspond_struct_idx—— 匹配点所对应的空间点在点云中的索引
  • vector<Point2f> matchedPoints—— 存储匹配点
  • vector<Vec3b> colors—— 存储匹配点的颜色信息
  • Mat R, T—— 存储相机的旋转矩阵和平移向量

同时还有几个关于图像处理的重要函数：

  • Images：构造函数，读取图像时就进行了特征点的提取
  • matchFeatures：匹配特征点
  • findColor：提取颜色信息
  • getObjPointsAndImgPoints：找出当前匹配中已经在点云中的点，获取 object_points，以及 image_points —— 为 PnP 做准备

Image.h：

#ifndef IMAGES_H
#define IMAGES_H

#include "Includes.h"

class Images
{
public:
	Mat image; // 存储图像
	vector<KeyPoint> keyPoints; // 存储特征点
	Mat descriptor; // 存储特征描述符
	vector<int> correspond_struct_idx; // 匹配点所对应的空间点在点云中的索引
	vector<Point2f> matchedPoints; // 存储匹配点
	vector<Vec3b> colors; // 存储匹配点的颜色信息
	Mat R, T; // 存储相机的旋转矩阵和平移向量

	vector<Point3f> object_points; // 前一张图中匹配点对应的三维点
	vector<Point2f> image_points; // 在现图像中对应的像素点

	// 构造函数，从指定路径读取图像，并提取SIFT特征点和描述符
	Images(string const image_paths);

	// 特征匹配函数，将当前图像与另一个图像进行特征匹配
	void matchFeatures(Images& otherImage, vector<DMatch>& outputMatches);

	// 从匹配点中提取颜色信息
	void findColor();

	// 遍历当前匹配，找出当前匹配中已经在点云中的点，获取object_points，以及image_points
	void getObjPointsAndImgPoints(vector<DMatch>& matches, vector<Point3d>& all_reconstructed_points, Images& preImage);
};


#endif // !IMAGES_H
#pragma once

Image.cpp：

#include "Images.h"


Images::Images(string const image_path) 
{
	// 读取图像
	this->image = imread(image_path);
	if (this->image.empty()) 
	{
		cout << "Could not read image: " << image_path << endl;
	}

	// 提取SIFT特征点和描述符
	Ptr<SIFT> sift = SIFT::create(0, 17, 0.0000000001, 16);
	sift->detectAndCompute(this->image, noArray(), this->keyPoints, this->descriptor);

	for (int i = 0; i < keyPoints.size(); i++)
	{
		correspond_struct_idx.push_back(-1);
	}
}


void Images::findColor()
{
	// 遍历所有匹配点
	for (Point2f& Points : this->matchedPoints)
	{	
		// 获取像素点的颜色
		Vec3b color = this->image.at<Vec3b>(Points.y, Points.x);

		// 将颜色存储在颜色向量中
		this->colors.push_back(color);
	}
}


void Images::matchFeatures(Images& otherImage, vector<DMatch>& outputMatches)
{
	// 清空匹配点
	otherImage.matchedPoints.clear();
	this->matchedPoints.clear();

	vector<vector<DMatch>> matches;
	FlannBasedMatcher matcher;

	// 使用FlannBasedMatcher进行特征匹配
	matcher.knnMatch(this->descriptor, otherImage.descriptor, matches, 2);

	// 计算最小距离
	float min_dist = FLT_MAX;
	for (int r = 0; r < matches.size(); ++r)
	{
		// 如果最近邻距离大于次近邻距离的2.5倍，则跳过该匹配点
		if (matches[r][0].distance < 2.5 * matches[r][1].distance)
		{
			// 计算最小距离
			float dist = matches[r][0].distance;
			if (dist < min_dist)
			{
				min_dist = dist;
			}
		}
	}


	// 筛选出好的匹配点
	for (int i = 0; i < matches.size(); i++)
	{
		if (matches[i][0].distance < 0.76 * matches[i][1].distance && matches[i][0].distance < 8 * max(min_dist, 10.0f))
		{
			outputMatches.push_back(matches[i][0]);
		}
	}

	// 将匹配点存储在matchedPoints向量中
	for (int i = 0; i < outputMatches.size(); ++i)
	{
		this->matchedPoints.push_back(this->keyPoints[outputMatches[i].queryIdx].pt);
		otherImage.matchedPoints.push_back(otherImage.keyPoints[outputMatches[i].trainIdx].pt);
	}
}

// 从匹配点中获取三维空间点和图像点
void Images::getObjPointsAndImgPoints(vector<DMatch>& matches, vector<Point3d>& all_reconstructed_points, Images& preImage)
{
	// 清空object_points和image_points
	this->object_points.clear();
	this->image_points.clear();

	// 遍历所有匹配点
	for (int i = 0; i < matches.size(); i++)
	{
		// 获取匹配点在前一张图像中对应的三维空间点的索引
		int matched_world_point_indices = preImage.correspond_struct_idx[matches[i].queryIdx];

		// 如果匹配点在前一张图像中对应的三维空间点存在
		if (matched_world_point_indices > 0)
		{
			// 将其（前一张图像中的三维点）添加到object_points中
			this->object_points.push_back(all_reconstructed_points[matched_world_point_indices]);

			// 将匹配点（该新图像的二维点）添加到image_points中
			this->image_points.push_back(this->keyPoints[matches[i].trainIdx].pt);
		}
	}
}

3 具体实现

在先前的两张图片的初始三维点云的构建的基础上，我们来实现多张图的增量构建

3.1 初始构建

在前面几篇博客中已经详细讲述过了：匹配，用计算 E 矩阵的方式求得相机外参 R，T，进行三角化构建点云

特别：为了后面的增图重建，我们需要记录初始两张图各个点和点云的关系

void initConstruction(vector<Images>& initImages, vector<Point3d>& all_reconstructed_points, vector<Vec3b>& all_points_colors)
{
    
    initImages.push_back(*(new Images(INIT_IMG_PATH1)));
    initImages.push_back(*(new Images(INIT_IMG_PATH2)));

    vector<DMatch> matches;
    initImages[0].matchFeatures(initImages[1], matches);

    vector<uchar> mask;
    Constructor::findCamera(K, initImages[0].matchedPoints, initImages[1].matchedPoints, initImages[1].R, initImages[1].T, mask);
    initImages[0].R = Mat::eye(3, 3, CV_64FC1);
    initImages[0].T = Mat::zeros(3, 1, CV_64FC1);
    all_reconstructed_points = Constructor::pointsReconstruct(K, initImages[0].R, initImages[0].T, initImages[1].R, initImages[1].T, initImages[0].matchedPoints, initImages[1].matchedPoints);
    
    initImages[1].findColor();
    for (int i = 0; i < initImages[1].colors.size(); i++)
    {
        all_points_colors.push_back(initImages[1].colors[i]);
    }


    // 根据mask来记录初始两张图各个点和点云的关系
    int idx = 0;
    for (int i = 0; i < matches.size(); i++)
    {
        if (mask[i])
        {
            initImages[0].correspond_struct_idx[matches[i].queryIdx] = idx;
            initImages[1].correspond_struct_idx[matches[i].trainIdx] = idx;
            idx++;
        }
    }
}

3.2 增量构建

  1. 创建subImageBag，然后将initImages[1]添加到容器中，即表示initImages中的第二张图像（数组索引为1）将与后续进行比较（否则下一张图添加进来跟谁进行匹配呢）

  2. 循环，遍历sub_image_paths容器中的图像文件路径

  3. 在循环中，为每个图像文件路径创建一个新的Images，并将其添加到subImageBag容器中。这样，容器subImageBag中就包含了多张图像，其中第一张图像是初始图像对的第二张，其余图像是逐步添加的

  4. 调用addImageConstruction函数，将subImageBag作为参数传递，以及用于存储稀疏点云的all_reconstructed_points和点云颜色的all_points_colors

    • 循环遍历subImageBag容器中的每个图像，从索引1开始（因为第一个图像是初始图像用于了初始构建，跳过）

    • 对于每对相邻的图像，执行以下操作：

      • 使用matchFeatures方法，找到两个相邻图像之间的特征点匹配关系，并将匹配结果存储在matches容器中

      • 使用getObjPointsAndImgPoints方法，获取匹配的特征点对应的三维点和图像点 —— 为 PnP 做准备

      • 通过RANSAC筛选，使用findCamera方法筛选匹配点并生成一个mask，用于标记有效的匹配点（只是为了筛选罢了）

      • 使用solvePnPRansac方法，估计新图像的相机位姿，获得R，T

      • 转换旋转向量为旋转矩阵（solvePnPRansac得到的是 r 向量）

      • 使用pointsReconstruct方法，重建新图像与前图像之间的三维点，并将结果存储在new_restructure_points中

      • 使用findColor方法，获取新图像中点的颜色信息

      • 记录初始两张图各个点和点云的关系：

        遍历matches，根据mask中的标记，将新生成的点与初始两张图像的各个点和点云的关系进行记录，维护点与点云之间的对应关系

      • 最后，将新生成的三维点new_restructure_points以及它们的颜色信息添加到all_reconstructed_points和all_points_colors中，不断扩展点云

void addImageConstruction(vector<Images>& subImageBag, vector<Point3d>& all_reconstructed_points, vector<Vec3b>& all_points_colors)
{
    for (int i = 1; i < subImageBag.size(); i++)
    {
        cout << i << endl;
        vector<DMatch> matches;
        subImageBag[i - 1].matchFeatures(subImageBag[i], matches);

        subImageBag[i].getObjPointsAndImgPoints(matches, all_reconstructed_points, subImageBag[i - 1]);

        // 只是为了进行RANSAC筛选匹配点和获取mask
        vector<uchar> mask;
        Mat discardR, discardT;
        Constructor::findCamera(K, subImageBag[i - 1].matchedPoints, subImageBag[i].matchedPoints, discardR, discardT, mask);


        solvePnPRansac(subImageBag[i].object_points, subImageBag[i].image_points, K, noArray(), subImageBag[i].R, subImageBag[i].T);
        Rodrigues(subImageBag[i].R, subImageBag[i].R);

        vector<Point3d> new_restructure_points;
        new_restructure_points = Constructor::pointsReconstruct(K, subImageBag[i - 1].R, subImageBag[i - 1].T, subImageBag[i].R, subImageBag[i].T, subImageBag[i - 1].matchedPoints, subImageBag[i].matchedPoints);

        subImageBag[i].findColor();

        // 记录初始两张图各个点和点云的关系
        int idx = 0;
        for (int k = 0; k < matches.size(); k++)
        {
            if (mask[k])
            {
                subImageBag[i - 1].correspond_struct_idx[matches[k].queryIdx] = all_reconstructed_points.size() + idx;
                subImageBag[i].correspond_struct_idx[matches[k].trainIdx] = all_reconstructed_points.size() + idx;
                idx++;
            }

        }
   
        for (int k = 0; k < new_restructure_points.size(); k++)
        {
            all_reconstructed_points.push_back(new_restructure_points[k]);
            all_points_colors.push_back(subImageBag[i].colors[k]);
        }
    }
}

3.3 完整main.cpp

// 定义图像文件路径和保存结果的路径
//#define INIT_IMG_PATH1 "test_img\\images\\100_7103.jpg"
//#define INIT_IMG_PATH2 "test_img\\images\\100_7104.jpg"
#define INIT_IMG_PATH1 "test_img\\First stage\\B25.jpg"
#define INIT_IMG_PATH2 "test_img\\First stage\\B24.jpg"
#define PLY_SAVE_PATH "test_img\\results\\output.ply"

#include "Includes.h"
#include "Images.h"
#include "Constructor.h"

//const Mat K = (Mat_<double>(3, 3) << 2905.88, 0, 1416, 0, 2905.88, 1064, 0, 0, 1);
const Mat K = (Mat_<double>(3, 3) << 719.5459, 0, 0, 0, 719.5459, 0, 0, 0, 1);

//const vector<string> sub_image_paths = { /*"test_img\\images\\100_7100.jpg", "test_img\\images\\100_7101.jpg", "test_img\\images\\100_7102.jpg",*/ /*"test_img\\images\\100_7103.jpg", "test_img\\images\\100_7104.jpg",*/ "test_img\\images\\100_7105.jpg", "test_img\\images\\100_7106.jpg", "test_img\\images\\100_7107.jpg", "test_img\\images\\100_7108.jpg", "test_img\\images\\100_7109.jpg"/*, "test_img\\images\\100_7110.jpg"*/ };


const vector<string> sub_image_paths = { "test_img\\First stage\\B23.jpg", "test_img\\First stage\\B22.jpg", "test_img\\First stage\\B21.jpg" };
void initConstruction(vector<Images>& initImages, vector<Point3d>& all_reconstructed_points, vector<Vec3b>& all_points_colors)
{
    
    initImages.push_back(*(new Images(INIT_IMG_PATH1)));
    initImages.push_back(*(new Images(INIT_IMG_PATH2)));

    vector<DMatch> matches;
    initImages[0].matchFeatures(initImages[1], matches);

    vector<uchar> mask;
    Constructor::findCamera(K, initImages[0].matchedPoints, initImages[1].matchedPoints, initImages[1].R, initImages[1].T, mask);
    initImages[0].R = Mat::eye(3, 3, CV_64FC1);
    initImages[0].T = Mat::zeros(3, 1, CV_64FC1);
    all_reconstructed_points = Constructor::pointsReconstruct(K, initImages[0].R, initImages[0].T, initImages[1].R, initImages[1].T, initImages[0].matchedPoints, initImages[1].matchedPoints);
    
    initImages[1].findColor();
    for (int i = 0; i < initImages[1].colors.size(); i++)
    {
        all_points_colors.push_back(initImages[1].colors[i]);
    }


    // 根据mask来记录初始两张图各个点和点云的关系
    int idx = 0;
    for (int i = 0; i < matches.size(); i++)
    {
        if (mask[i])
        {
            initImages[0].correspond_struct_idx[matches[i].queryIdx] = idx;
            initImages[1].correspond_struct_idx[matches[i].trainIdx] = idx;
            idx++;
        }
    }
}

void addImageConstruction(vector<Images>& subImageBag, vector<Point3d>& all_reconstructed_points, vector<Vec3b>& all_points_colors)
{
    for (int i = 1; i < subImageBag.size(); i++)
    {
        cout << i << endl;
        vector<DMatch> matches;
        subImageBag[i - 1].matchFeatures(subImageBag[i], matches);

        subImageBag[i].getObjPointsAndImgPoints(matches, all_reconstructed_points, subImageBag[i - 1]);

        // 只是为了进行RANSAC筛选匹配点和获取mask
        vector<uchar> mask;
        Mat discardR, discardT;
        Constructor::findCamera(K, subImageBag[i - 1].matchedPoints, subImageBag[i].matchedPoints, discardR, discardT, mask);


        solvePnPRansac(subImageBag[i].object_points, subImageBag[i].image_points, K, noArray(), subImageBag[i].R, subImageBag[i].T);
        Rodrigues(subImageBag[i].R, subImageBag[i].R);

        vector<Point3d> new_restructure_points;
        new_restructure_points = Constructor::pointsReconstruct(K, subImageBag[i - 1].R, subImageBag[i - 1].T, subImageBag[i].R, subImageBag[i].T, subImageBag[i - 1].matchedPoints, subImageBag[i].matchedPoints);

        subImageBag[i].findColor();

        // 记录初始两张图各个点和点云的关系
        int idx = 0;
        for (int k = 0; k < matches.size(); k++)
        {
            if (mask[k])
            {
                subImageBag[i - 1].correspond_struct_idx[matches[k].queryIdx] = all_reconstructed_points.size() + idx;
                subImageBag[i].correspond_struct_idx[matches[k].trainIdx] = all_reconstructed_points.size() + idx;
                idx++;
            }

        }


       

        for (int k = 0; k < new_restructure_points.size(); k++)
        {
            all_reconstructed_points.push_back(new_restructure_points[k]);
            all_points_colors.push_back(subImageBag[i].colors[k]);
        }
    }

}

int main()
{
    try
    {
        vector<Images> initImages;
        vector<Point3d> all_reconstructed_points;
        vector<Vec3b> all_points_colors;

        initConstruction(initImages, all_reconstructed_points, all_points_colors);

        vector<Images> subImageBag;
        subImageBag.push_back(initImages[1]);
        for (auto& image_path : sub_image_paths)
        {
            subImageBag.push_back(Images(image_path));
        }

        addImageConstruction(subImageBag, all_reconstructed_points, all_points_colors);        
        
        // 手动输出点云ply文件
        std::ofstream plyFile(PLY_SAVE_PATH);

        // ply的头部信息
        plyFile << "ply\n";
        plyFile << "format ascii 1.0\n";
        plyFile << "element vertex " << all_reconstructed_points.size() << "\n";
        plyFile << "property float x\n";
        plyFile << "property float y\n";
        plyFile << "property float z\n";
        plyFile << "property uchar blue\n";
        plyFile << "property uchar green\n";
        plyFile << "property uchar red\n";
        plyFile << "end_header\n";

        // 写入点云数据
        for (int i = 0; i < all_reconstructed_points.size(); ++i)
        {
            cv::Vec3b color = all_points_colors[i];
            cv::Point3f point = all_reconstructed_points[i];
            plyFile << point.x << " " << point.y << " " << point.z << " "
                << static_cast<int>(color[0]) << " "
                << static_cast<int>(color[1]) << " "
                << static_cast<int>(color[2]) << std::endl;
        }

        plyFile.close();
        return 0;
    }
    catch (Exception e)
    {
        cout << e.msg << endl;
    }
    
}

4 总结注意

源码 即上面给出的 Include.h，Constructor.h，Constructor.cpp，Image.h，Image.cpp，main.cpp

增量加图前（两张初始图的构建）：

image-20231020200930233

增量加图构造后：

image-20231020200946321

注意：

目前只是完成了基本流程，有很多地方都需要优化，比如

  • SIFT 的参数设置
  • RANSAC 的参数设置
  • 初始图片的选择（很重要）
  • matchFeatures 中的 ratio test 的设置
  • 还可以增加其他优化措施来剔除离谱点
  • 最重要的 BA 还没有加入！
  • ·······

目前，出来的效果不好，革命尚未成功，同志还需努力！😭😭😭

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1115400.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

nginx+nodejs 一台服务器站架多个网站

nginx+nodejs 一台服务器站架多个网站

一、一台服务器架设多个 nodejs 网站的拓扑结构 二、搭建 Nodejs 生产环境 1、下载 下载 nodejs 二进制代码包或者&#xff0c;然后减压到 /usr/local/nodejs 2、配置环境变量 (1).vi /etc/profile (2).最后面添加&#xff1a; export NODE_HOME/usr/local/nodejs/bin…
阅读更多...
常见问题-找不到vcruntime140.dll无法继续执行代码解决方案

常见问题-找不到vcruntime140.dll无法继续执行代码解决方案

本文将介绍五种不同的解决方案&#xff0c;帮助大家解决这个问题。 首先&#xff0c;我们需要了解为什么会出现找不到vcruntime140.dll的情况。这种情况通常是由于以下几个原因导致的&#xff1a; 1. 系统环境变量设置不正确&#xff1a;系统环境变量中可能没有包含vcruntime…
阅读更多...
卷积神经网络CNN学习笔记

卷积神经网络CNN学习笔记

目录 1.全连接层存在的问题2.卷积运算3.填充(padding)3.1填充(padding)的意义 4.步幅(stride)5.三维数据的卷积运算6.结合方块思考7.批处理8.conv2d代码参考文章 1.全连接层存在的问题 在全连接层中&#xff0c;相邻层的神经元全部连接在一起&#xff0c;输出的数量可以任意决…
阅读更多...
大数据之LibrA数据库系统概览

大数据之LibrA数据库系统概览

实时监控 “实时监控”页面如图1所示&#xff0c;用户可单击刷新按钮手动刷新当前页面&#xff0c;也可在点刷新按钮前选择自动刷新时长&#xff0c;刷新时长包括&#xff1a;每30秒刷新一次、每60秒刷新一次、停止刷新。 实时监控数据&#xff08;监控时间轴产生的新曲线&am…
阅读更多...
win32汇编-PUSHAD和POPAD指令

win32汇编-PUSHAD和POPAD指令

PUSHAD是一个x86汇编指令&#xff0c;用于将当前程序的所有通用寄存器&#xff08;EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI&#xff09;的值依次入栈 PUSHAD指令压入32位寄存器 其堆栈指针SP将加32 PUSHAD POPAD不会影响标志位 POPAD指令则是PUSHAD指令的逆操作。POPAD指令…
阅读更多...
家装、家居两不误，VR全景打造沉浸式家装体验

家装、家居两不误，VR全景打造沉浸式家装体验

当下&#xff0c;用户对生活品质要求日益提升&#xff0c;越来越多的用户对多功能家装用品需求较大&#xff0c;由此造就了VR全景家装开始盛行。VR全景家装打破传统二维空间模式&#xff0c;通过视觉、交互等功能让用户更加真实、直观的体验和感受家居布置的效果。 一般来说&am…
阅读更多...
数据结构-----图(graph)的储存和创建

数据结构-----图(graph)的储存和创建

目录 前言 图的储存结构 1.邻接矩阵 无向图的邻接矩阵 有向图的邻接矩阵 网&#xff08;赋权图&#xff09;的邻接矩阵 代码表示 2.邻接表 无向图的邻接表 有向图的邻接表 代码表示 3.邻接矩阵和邻接表对比 邻接矩阵 邻接表 图的创建 1.邻接矩阵创建图&#xff0…
阅读更多...
idea2023配置maven

idea2023配置maven

看过【黑马程序员Maven全套教程&#xff0c;maven项目管理从基础到高级&#xff0c;Java项目开发必会管理工具maven】https://www.bilibili.com/video/BV1Ah411S7ZE?p9&vd_sourceedf9d91e5a0a27db51e3d6d4b9400637 配置的&#xff0c;前提要素配置也在这个课程里有啦&…
阅读更多...
在 Tubi 做 Tech Lead 有多刺激！

在 Tubi 做 Tech Lead 有多刺激！

上周我们发布了一篇《当你在 Tubi 是一位 Tech Lead》采访稿&#xff0c;后台收到了这样一条留言&#xff0c;说出了许多技术人在选择管理岗位还是继续深耕技术方向时的纠结&#xff1a; ‘有些同事更喜欢投入精力处理有挑战的事情&#xff0c;而不愿花费太多时间进行人际沟通&…
阅读更多...
Janus: 逆向思维，以数据为中心的MoE训练范式

Janus: 逆向思维，以数据为中心的MoE训练范式

文章链接&#xff1a;Janus: A Unified Distributed Training Framework for Sparse Mixture-of-Experts Models 发表会议: ACM SIGCOMM 2023 (计算机网络顶会) 目录 1.背景介绍all-to-allData-centric Paradigm 2.内容摘要关键技术Janus细粒度任务调度拓扑感知优先级策略预取…
阅读更多...
30二叉树-了解二叉树

30二叉树-了解二叉树

目录 树的定义 二叉树&#xff08;Binary Tree&#xff09; 二叉树的存储方式 链式存储 顺序存储 二叉树的遍历方式 LeetCode之路——144. 二叉树的前序遍历 分析 树的定义 树结构&#xff08;Tree Structure&#xff09;是一种分层的非线性数据结构&#xff0c;它由节…
阅读更多...
【OpenCV实现鼠标绘图，轨迹栏做调色板，图像的基本操作】

【OpenCV实现鼠标绘图，轨迹栏做调色板，图像的基本操作】

文章目录 鼠标绘图轨迹栏做调色板图像的基本操作 鼠标绘图 在OpenCV中操作鼠标事件 函数&#xff1a;cv.setMouseCallback() 目的是在鼠标双击的地方画一个圆。首先&#xff0c;我们需要创建一个鼠标回调函数&#xff0c;该函数会在鼠标事件发生时执行。鼠标事件包括左键按下…
阅读更多...
PyQt学习笔记-获取Hash值的小工具

PyQt学习笔记-获取Hash值的小工具

目录 一、概述1.1 版本信息&#xff1a;1.2 基本信息&#xff1a;1.2.1 软件支持的内容&#xff1a;1.2.2 支持的编码格式 1.3 软件界面图 二、代码实现2.1 View2.2 Controller2.3 Model 三、测试示例 一、概述 本工具居于hashlibPyQtQFileDialog写的小工具&#xff0c;主要是…
阅读更多...
中国移动启动算网大脑“天穹”全网试商用

中国移动启动算网大脑“天穹”全网试商用

10月12日&#xff0c;中国移动在2023全球合作伙伴大会主论坛正式启动算网大脑“天穹”全网试商用&#xff0c;全面开启算力网络2.0新征程&#xff0c;标志着中国移动算力网络迈向“融合统一”新阶段。 为落实国家“东数西算”战略&#xff0c;中国移动开创性提出算力网络新理念…
阅读更多...
操作系统【OS】微内核

操作系统【OS】微内核

基本概念 微内核结构将操作系统划分为两大部分&#xff1a;微内核多个服务器微内核包含&#xff1a; 与硬件处理紧密相关的部分一些较基本的功能客户和服务器间的通信客户与服务器之间是借助微内核提供的消息传递机制来实现交互的 基本功能 进程管理 进程的通信、切换、调度…
阅读更多...
【算法练习Day24】递增子序列全排列全排列 II

【算法练习Day24】递增子序列全排列全排列 II

​&#x1f4dd;个人主页&#xff1a;Sherry的成长之路 &#x1f3e0;学习社区&#xff1a;Sherry的成长之路&#xff08;个人社区&#xff09; &#x1f4d6;专栏链接&#xff1a;练题 &#x1f3af;长路漫漫浩浩&#xff0c;万事皆有期待 文章目录 递增子序列容易出错的地方 …
阅读更多...
微信手续费2023标准

微信手续费2023标准

不管是微信还是支付宝&#xff0c;商户最低的收款手续费率可以达到0.2%费率。一般我们普通商户的收款费率一般在0.6左右&#xff0c;当然也有使用0.3的&#xff0c;也就是1万元的费率是30-60块钱&#xff0c;对于一些流水比较大的商家来说&#xff0c;确实很有必要把这个手续费…
阅读更多...
【实用技巧】Latex写算法伪代码（格式篇）

【实用技巧】Latex写算法伪代码（格式篇）

本文主要介绍个人在编写Latex算法伪代码时所遇到的格式问题。 目录 包冲突换行与缩进算法换页 包冲突 \usepackage{algorithm} \usepackage{algorithmic} \usepackage{algorithmicx} \usepackage{algpseudocode} 网上查找算法伪代码第三方包&#xff0c;主要会跳出来这四…
阅读更多...
虹科案例 | 瑞士Agroscope研究所利用压力传感器自动测量反刍动物（奶牛）的咀嚼运动

虹科案例 | 瑞士Agroscope研究所利用压力传感器自动测量反刍动物（奶牛）的咀嚼运动

——用于动物测量研究的数据记录仪&#xff1a;虹科MSR145 瑞士Agroscope研究所隶属于联邦农业办公室&#xff0c;是农业、食品和环境领域可持续发展的推动力量&#xff0c;为农业和环境政策决策以及法规执行提供科学和技术基础。 作为Agroscope研究所的合作代表&…
阅读更多...
【超详细】CentOS 7安装MySQL 5.7【安装及密码配置、字符集配置、远程连接配置】

【超详细】CentOS 7安装MySQL 5.7【安装及密码配置、字符集配置、远程连接配置】

准备工作&#xff1a;CentOS 7系统&#xff0c;并确保可以联通网络 1、获取MySQL 5.7 Community Repository软件包 注意&#xff1a;这里使用的是root用户身份。 wget https://dev.mysql.com/get/mysql57-community-release-el7-8.noarch.rpm2、安装软件包 rpm -ivh mysql5…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023