立体视觉

最新推荐文章于 2023-06-23 17:24:18 发布
最新推荐文章于 2023-06-23 17:24:18 发布
阅读量574 收藏 4
点赞数 3
分类专栏： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/koqural/article/details/85049500
版权

单目照相机将三维的事物转化为二维的图像，丢失了距离信息，也就是视深。和我们双眼获知物体距离的原理类似，（对极几何）可以参见下图：

记cc'距离为B,xx'距离为视差d,空间点到基线的距离为Z，相机的焦距为f,则根据相似三角形定理得：d=Bf/Z

也就是距离信息可以转化为根据不同方向的图片求视差d的问题。

局部的方法（计算匹配代价）：

  • SAD（Sum of Absolute Differences）：绝对差值的和
  • SSD（Sum of Squared Differences）：差值平方的和
  • NCC（Normalized Cross Correlation）：图像的相关性

原理简述：其实视差的求取关键在于找到对应的x与x',则问题转换为如何找到左图中某点在右图中的对应点？以图像点x为例，在左图选取一个以x点为中心的特定大小的矩阵块，然后在右图中遍历，选取同样大小的矩阵块使得匹配代价最小，这时矩阵的中心点也就是右图中对应的x'点所在的位置。匹配代价的计算是针对矩阵中对应元素分别操作的，每个元素间的误差有两种定义方式，一种是用绝对差值，一种是用差值的平方，然后要将矩阵中所有元素误差加和，这样寻找最佳匹配点的方法分别叫做SAD和SSD。因为是对矩阵中对应元素操作，既可以按行列遍历操作求解（即下面每种方法给出的第一种代码形式），也可以直接借助矩阵操作函数像absdiff、sum、multiply等进行整体运算。（即每种方法的第二种代码形式）。

NCC计算图像匹配区域的互相关性，与上面两种的计算方法不同，公式如下：

其中Wp为以像素p=(px,py)为中心的匹配窗口。I1为左图匹配窗口内的像素，I2为右图匹配窗口内的像素。注意这里是要找相关性最大的匹配区域。

全局的方法：动态规划、图割法等。

OPENCV3.4.4中提供的方法：

  • BM（Block Matching）
  • SGBM（Semi-Global Block Matching）

原理简述：BM块匹配，可以看作封装好的SAD方法，原理同上。

SGBM因为是半全局算法，涉及到动态规划，效果比BM要好。它的原理较为复杂，具体可参考博客：

https://blog.csdn.net/A_L_A_N/article/details/81490043

这里对全局方法未作展开，后面的文章主要第一借助opencv完成相机的标定工作，第二结合相机参数和视差图，完成视深图和稀疏图的三维重建。

以下代码在VS2017+OPENCV3.4.4的环境下运行成功，参考博客：

https://blog.csdn.net/liyingjiang22/article/details/53156331

https://www.cnblogs.com/riddick/p/8318997.html 

https://blog.csdn.net/cxgincsu/article/details/74451940

SGBM效果比较好，所以后期将采用该种方法继续研究。

下面为可执行代码：

SAD

Mat SAD(Mat left, Mat right, bool turn, int size) {
	int i, j, d, count, x, y, size_s, k, index;
	double temp, temp1, temp2, min = 1000000000;
	int row = left.rows;
	int col = left.cols;
	Mat output(row, col, CV_8UC1);
	vector<pair<double, int>> v;
	size_s = size / 2;
	for (i = 0; i < row; i++) {
		for (j = 0; j < col; j++) {
			v.clear();
			for (d = 0; d <= 79; d++) {//在-79~79范围内搜索
				if (j - d < 0 && turn)break;
				else if (j + d >= col && (!turn))break;
				temp = 0;
				count = 0;//自适应patch，计算窗口像素个数
				if (!turn)d = -d;//用于复用循环
				for (x = i - size_s; x <= i + size_s; x++) {
					for (y = j - d - size_s; y <= j - d + size_s; y++) {
						if (x < 0 || y < 0 || y + d >= col || y + d < 0 || x >= row || y >= col)continue;
						if (turn) {
							temp1 = static_cast<double>(right.ptr<uchar>(x)[y]);
							temp2 = static_cast<double>(left.ptr<uchar>(x)[y + d]);
						}
						else {
							temp1 = static_cast<double>(right.ptr<uchar>(x)[y + d]);
							temp2 = static_cast<double>(right.ptr<uchar>(x)[y]);
						}
						count++;
						temp += temp1 > temp2 ? (temp1 - temp2) : (temp2 - temp1);
					}
				}
				if (!turn)d = -d;
				v.push_back(make_pair(temp / count, d));
			}
			index = 0;
			for (k = 0; k < v.size(); k++) {
				if (v[k].first < min) {
					min = v[k].first;
					index = v[k].second;
				}
			}
			output.ptr<uchar>(i)[j] = static_cast<uchar>(index * 3);
		}
	}
	return output;
}

利用矩阵并行计算，并将方法用类封装。 

#include"iostream"
#include"opencv2/opencv.hpp"
#include"iomanip"
using namespace std;
using namespace cv;

class SAD
{
public:
	SAD() :winSize(7), DSR(30) {}
	SAD(int _winSize, int _DSR) :winSize(_winSize), DSR(_DSR) {}
	Mat computerSAD(Mat &L, Mat &R); //计算SAD
private:
	int winSize; //卷积核的尺寸
	int DSR;     //视差搜索范围
};

Mat SAD::computerSAD(Mat &L, Mat &R)
{
	int Height = L.rows;
	int Width = L.cols;
	Mat Kernel_L(Size(winSize, winSize), CV_8U, Scalar::all(0));
	Mat Kernel_R(Size(winSize, winSize), CV_8U, Scalar::all(0));
	Mat Disparity(Height, Width, CV_8U, Scalar(0)); //视差图
	for (int i = 0; i < Width - winSize; i++)  //左图从DSR开始遍历
	{
		for (int j = 0; j < Height - winSize; j++)
		{
			Kernel_L = L(Rect(i, j, winSize, winSize));
			Mat MM(1, DSR, CV_32F, Scalar(0)); //
			for (int k = 0; k < DSR; k++)
			{
				int x = i - k;
				if (x >= 0)
				{
					Kernel_R = R(Rect(x, j, winSize, winSize));
					Mat Dif;
					absdiff(Kernel_L, Kernel_R, Dif);//
					Scalar ADD = sum(Dif);
					float a = static_cast<float>(ADD[0]);
					MM.at<float>(k) = a;
				}
			}
			Point minLoc;
			minMaxLoc(MM, NULL, NULL, &minLoc, NULL);
			int loc = minLoc.x;
			//int loc=DSR-loc;
			Disparity.at<char>(j, i) = loc * 16;
		}
		double rate = double(i) / (Width);
		cout << "SAD已完成" << setprecision(2) << rate * 100 << "%" << endl; //处理进度
	}
	return Disparity;
}

SSD

Mat SSD(Mat left, Mat right, bool turn, int size) {
	int i, j, d, count, x, y, size_s, k, index;
	double temp, temp1, temp2, min=1000000000;
	int row = left.rows;
	int col = left.cols;
	Mat output(row, col, CV_8UC1);
	vector<pair<double, int>> v;
	size_s = size / 2;
	for (i = 0; i < row; i++) {
		for (j = 0; j < col; j++) {
			v.clear();
			for (d = 0; d <= 79; d++) {//在-79~79范围内搜索
				if (j - d < 0 && turn)break;
				else if (j + d >= col && (!turn))break;
				temp = 0;
				count = 0;//自适应patch，计算窗口像素个数
				if (!turn)d = -d;//用于复用循环
				for (x = i - size_s; x <= i + size_s; x++) {
					for (y = j - d - size_s; y <= j - d + size_s; y++) {
						if (x < 0 || y < 0 || y + d >= col || y + d < 0 || x >= row || y >= col)continue;
						if (turn) {
							temp1 = static_cast<double>(right.ptr<uchar>(x)[y]);
							temp2 = static_cast<double>(left.ptr<uchar>(x)[y + d]);
						}
						else {
							temp1 = static_cast<double>(right.ptr<uchar>(x)[y+d]);
							temp2 = static_cast<double>(right.ptr<uchar>(x)[y]);
						}
						count++;
						temp += pow(temp1 - temp2, 2);
					}
				}
				if (!turn)d = -d;
				v.push_back(make_pair(temp / count, d));
			}
			index = 0;
			for (k = 0; k < v.size(); k++) {
				if (v[k].first < min) {
					min = v[k].first;
					index = v[k].second;
				}
			}
			output.ptr<uchar>(i)[j] = static_cast<uchar>(index * 3);
		}
	}
	return output;
}

利用矩阵并行计算，并将方法用类封装。

#include"iostream"
#include"opencv2/opencv.hpp"
#include"iomanip"
using namespace std;
using namespace cv;

class SSD
{
public:
	SSD() :winSize(7), DSR(30) {}
	SSD(int _winSize, int _DSR) :winSize(_winSize), DSR(_DSR) {}
	Mat computerSSD(Mat &L, Mat &R); //计算SAD
private:
	int winSize; //卷积核的尺寸
	int DSR;     //视差搜索范围
};

Mat SSD::computerSSD(Mat &L, Mat &R)
{
	int Height = L.rows;
	int Width = L.cols;
	Mat Kernel_L(Size(winSize, winSize), CV_8U, Scalar::all(0));
	Mat Kernel_R(Size(winSize, winSize), CV_8U, Scalar::all(0));
	Mat Disparity(Height, Width, CV_8U, Scalar(0)); //视差图
	for (int i = 0; i < Width - winSize; i++)  //左图从DSR开始遍历
	{
		for (int j = 0; j < Height - winSize; j++)
		{
			Kernel_L = L(Rect(i, j, winSize, winSize));
			Mat MM(1, DSR, CV_32F, Scalar(0)); //
			for (int k = 0; k < DSR; k++)
			{
				int x = i - k;
				if (x >= 0)
				{
					Kernel_R = R(Rect(x, j, winSize, winSize));
					Mat Dif;
					absdiff(Kernel_L, Kernel_R, Dif);//
					Dif = Dif.mul(Dif);
					Scalar ADD = sum(Dif);
					float a = static_cast<float>(ADD[0]);
					MM.at<float>(k) = a;
				}
			}
			Point minLoc;
			minMaxLoc(MM, NULL, NULL, &minLoc, NULL);
			int loc = minLoc.x;
			//int loc=DSR-loc;
			Disparity.at<char>(j, i) = loc * 16;
		}
		double rate = double(i) / (Width);
		cout << "SSD已完成" << setprecision(2) << rate * 100 << "%" << endl; //处理进度
	}
	return Disparity;
}

Tip: A.mul(B)是矩阵A与矩阵B对应位相乘得到的新矩阵，A*B则对应着矩阵乘法，二者不是同一概念。

  NCC

Mat NCC(Mat left, Mat right, bool turn, int size) {
	int i, j, d, x, y, size_s, k, index;
	double tempUp, tempDown, temp1, temp2, result, max = 0;
	int row = left.rows;
	int col = left.cols;
	Mat output(row, col, CV_8UC1);
	vector<pair<double, int>> v;
	size_s = size / 2;
	for (i = 0; i < row; i++) {
		for (j = 0; j < col; j++) {
			v.clear();
			for (d = 0; d <= 79; d++) {//在-79~79范围内搜索
				if (j - d < 0 && turn)break;
				else if (j + d >= col && (!turn))break;
				tempUp = 0;
				tempDown = 0;
				if (!turn)d = -d;//用于复用循环
				for (x = i - size_s; x <= i + size_s; x++) {
					for (y = j - d - size_s; y <= j - d + size_s; y++) {
						if (x < 0 || y < 0 || y + d >= col || y + d < 0 || x >= row || y >= col)continue;
						if (turn) {
							temp1 = static_cast<double>(right.ptr<uchar>(x)[y]);
							temp2 = static_cast<double>(left.ptr<uchar>(x)[y + d]);
						}
						else {
							temp1 = static_cast<double>(right.ptr<uchar>(x)[y + d]);
							temp2 = static_cast<double>(right.ptr<uchar>(x)[y]);
						}
						tempUp += temp1 * temp2;
					}
				}
				tempUp = 0;
				tempDown = 0;
				for (x = i - size_s; x <= i + size_s; x++) {
					for (y = j - d - size_s; y <= j - d + size_s; y++) {
						if (x < 0 || y < 0 || y + d >= col || y + d < 0 || x >= row || y >= col)continue;
						if (turn) {
							temp1 = pow(static_cast<double>(right.ptr<uchar>(x)[y]), 2);
							temp2 = pow(static_cast<double>(left.ptr<uchar>(x)[y + d]), 2);
						}
						else {
							temp1 = pow(static_cast<double>(right.ptr<uchar>(x)[y + d]), 2);
							temp2 = pow(static_cast<double>(right.ptr<uchar>(x)[y]), 2);
						}
					}
				}
				tempUp += sqrt(temp1 * temp2);
				result = tempUp / tempDown;
				if (!turn)d = -d;
				v.push_back(make_pair(result, d));
			}
			index = 0;
			for (k = 0; k < v.size(); k++) {
				if (v[k].first >max) {
					max = v[k].first;
					index = v[k].second;
				}
			}
			output.ptr<uchar>(i)[j] = static_cast<uchar>(index * 3);
		}
	}
	return output;
}

利用矩阵并行计算，并将方法用类封装。

#include"iostream"
#include"opencv2/opencv.hpp"
#include"iomanip"
using namespace std;
using namespace cv;

class NCC
{
public:
	NCC() :winSize(7), DSR(30) {}
	NCC(int _winSize, int _DSR) :winSize(_winSize), DSR(_DSR) {}
	Mat computerNCC(Mat &L, Mat &R); //计算SAD
private:
	int winSize; //卷积核的尺寸
	int DSR;     //视差搜索范围
};

Mat NCC::computerNCC(Mat &L, Mat &R)
{
	int Height = L.rows;
	int Width = L.cols;
	Mat Kernel_L(Size(winSize, winSize), CV_8U, Scalar::all(0));
	Mat Kernel_R(Size(winSize, winSize), CV_8U, Scalar::all(0));
	Mat Disparity(Height, Width, CV_8U, Scalar(0)); //视差图
	for (int i = 0; i < Width - winSize; i++)  //左图从DSR开始遍历
	{
		for (int j = 0; j < Height - winSize; j++)
		{
			Kernel_L = L(Rect(i, j, winSize, winSize));
			Mat MM(1, DSR, CV_32F, Scalar(0)); //
			for (int k = 0; k < DSR; k++)
			{
				int x = i - k;
				if (x >= 0)
				{
					Kernel_R = R(Rect(x, j, winSize, winSize));
					Mat Dif = Kernel_L.mul(Kernel_R);
					Scalar ADD = sum(Dif);
					float a = static_cast<float>(ADD[0]);
					MM.at<float>(k) = a;
				}
			}
			for (int k = 0; k < DSR; k++)
			{
				int x = i - k;
				if (x >= 0)
				{
					Kernel_R = R(Rect(x, j, winSize, winSize));
					Scalar ADD2 = sum(Kernel_L)*sum(Kernel_R);
					float b = static_cast<float>(ADD2[0]);
					MM.at<float>(k) /=sqrt(b);
				}
			}
			Point minLoc;
			minMaxLoc(MM, NULL, NULL, &minLoc, NULL);
			int loc = minLoc.x;
			//int loc=DSR-loc;
			Disparity.at<char>(j, i) = loc * 16;
		}
		double rate = double(i) / (Width);
		cout << "NCC已完成" << setprecision(2) << rate * 100 << "%" << endl; //处理进度
	}
	return Disparity;
}

OPENCV3.4.4中，StereoBM不能直接声明实例，需要放到智能指针里cv::Ptr<cv::StereoBM>声明才行，且必须通过setter和

getter方法来设置和获取参数。StereoSGBM同理。（这里的参数要根据实际情况调整，注意图像格式问题）

使用样例如下： 

BM

#include<opencv2/opencv.hpp>
#include<iostream>
using namespace std;
using namespace cv;

int main() {
	//读入灰度图left和right
	Mat left = imread("D:/project_test/stereo_matching/images/im1.png",0);
	Mat right = imread("D:/project_test/stereo_matching/images/im2.png",0);
	if (left.empty()||right.empty()) {
		printf("could not found image!");
		return -1;
	}
	imshow("left", left);
	imshow("right", right);
	//存储视差
	Mat disp(7, 30, CV_8U, Scalar(0)); //视差图
	//bm
	int mindisparity = 0;//最小视差，默认为0。此参数决定左图中的像素点在右图匹配搜索的起点
	int numdisparities = 64;//视差搜索范围长度，其值为16的整数倍。最大视差= minDisparity + numDisparities -1；
	int blocksize =15;//SAD代价计算窗口大小，默认为5。窗口大小为奇数，一般在3*3 到21*21之间
	//智能指针，利用setter和getter对bm操作
	cv::Ptr<cv::StereoBM> bm = cv::StereoBM::create(numdisparities, blocksize);
	//setter设置参数
	bm->setBlockSize(blocksize);
	bm->setMinDisparity(mindisparity);
	bm->setNumDisparities(numdisparities);

	bm->setPreFilterSize(9);
	bm->setPreFilterCap(31);

	bm->setTextureThreshold(10); 
	bm->setUniquenessRatio(15); 
	bm->setSpeckleWindowSize(100);
	bm->setSpeckleRange(32);
	bm->setDisp12MaxDiff(1); 
	
	copyMakeBorder(left, left, 0, 0, 80, 0, IPL_BORDER_REPLICATE);  //防止黑边
	copyMakeBorder(right, right, 0, 0, 80, 0, IPL_BORDER_REPLICATE);
	bm->compute(left, right, disp);
	/*U<S<F*/
	//bm计算出的视差都是CV_16S格式的，使用32位float格式可以得到真实的视差值，所以我们需要除以16
	disp.convertTo(disp, CV_32F, 1.0 / 16); //除以16得到真实视差值
	disp = disp.colRange(80, disp.cols);

	//归一化时，normType应该为cv::NORM_MINMAX，alpha为归一化后的最大值，beta为归一化后的最小值
	Mat disp8U = Mat(disp.rows, disp.cols, CV_8UC1);
	normalize(disp, disp8U, 0, 255, NORM_MINMAX, CV_8UC1);

	imshow("disp", disp8U);
	waitKey(0);
	return 0;
}

minDisparity：最小视差，默认为0。
numDisparities：视差搜索范围长度，其值必须为16的整数倍。
blockSize：SAD代价计算窗口大小，默认为5。窗口大小为奇数，一般在3*3 到21*21之间；
P1、P2：能量函数参数，P1是相邻像素点视差增/减 1 时的惩罚系数；P2是相邻像素点视差变化值大于1时的惩罚系数。

SGBM

#include <iostream>
#include<opencv2/opencv.hpp>
using namespace std;
using namespace cv;

int main()
{
	Mat left = imread("D:/project_test/stereo_matching/images/im1.png", 0);
	Mat right = imread("D:/project_test/stereo_matching/images/im2.png", 0);
	if (!left.data || !right.data) {
		cout << "cannot found images!\n";
	}
	Mat disp(7, 30, CV_8U, Scalar(0));
	int mindisparity = 0;
	int ndisparities = 64;
	int SADWindowSize = 15;
	//SGBM
	Ptr<StereoSGBM> sgbm = StereoSGBM::create(mindisparity, ndisparities, SADWindowSize);
	int P1 = 8 * left.channels() * SADWindowSize* SADWindowSize;
	int P2 = 32 * left.channels() * SADWindowSize* SADWindowSize;
	sgbm->setP1(P1);
	sgbm->setP2(P2);
	sgbm->setPreFilterCap(31);
	sgbm->setUniquenessRatio(15);
	sgbm->setSpeckleRange(32);
	sgbm->setSpeckleWindowSize(100);
	sgbm->setDisp12MaxDiff(1);
	sgbm->compute(left, right, disp);
	copyMakeBorder(left, left, 0, 0, 80, 0, IPL_BORDER_REPLICATE);  //防止黑边
	copyMakeBorder(right, right, 0, 0, 80, 0, IPL_BORDER_REPLICATE);
	disp.convertTo(disp, CV_32F, 1.0 / 16);                //除以16得到真实视差值
	disp = disp.colRange(80, disp.cols);
	Mat disp8U = Mat(disp.rows, disp.cols, CV_8UC1);       //显示
	normalize(disp, disp8U, 0, 255, NORM_MINMAX, CV_8UC1);
	imshow("SBGM_disp",disp8U);
	waitKey(0);
	return 0;
}

这里给出矩阵方法SAD、SSD、NCC和BM、SGBM的运行结果。

得到的视差图如下：

SAD
SSD
NCC
BM
SGBM

上周总结：

  1. 由对极几何基本原理，了解常见的局部立体匹配算法SAD、SSD、NCC，并加以实现，调试运行。 ​​
  2. Opencv3.4提供了BM和半全局的SGBM方法。只用调用指针调节参数就可得到视差图，参数设置参考相关博客。
  3. 全局有动态规划等方法暂未作展开。
  4. 利用opencv3.4附带的相机标定样例函数，传入自己的棋盘图像，得出相机参数矩阵。
  5. 继续看有关计算机视觉相关视频。

本周目标：

  1. 利用SBGM（较高效）得到的视差图和相机参数矩阵获得稀疏图的三维重建。
  2. 了解orb-slam

 后期补充：部分视差图效果并不理想且用时较长。

附原始左右图：

左图
右图

 

 

 

 

 

 

koqural
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
立体视觉介绍
03-03
该文档对bumblebee双目立体摄像头的结构，原理，使用，注意事项等进行了简单介绍。
立体视觉（一 概述）
热门推荐
南国君的博客
09-01 1万+
何为立体视觉？ 立体视觉是一种计算机视觉技术，其目的是从两幅或两幅以上的图像中推理出图像中每个像素点的深度信息。   立体视觉的应用领域？ 机器人、辅助驾驶/无人驾驶、无人机等等。   立体视觉推理像素点深度的原理？        立体视觉借鉴了人类双眼的“视差”原理，即左、右眼对于真实世界中某一物体的观测是存在差异的，我们的大脑正是利用了左、右眼的差异，使得我们能够辨识物体的远近。...
立体视觉-双目系统
qq_40694323的博客
06-01 1971
立体视觉-双目系统，单目系统，双目系统原理公式刨析
立体视觉立体视觉立体视觉立体视觉
12-22
立体视觉，求取视差图，效果不错，可以使用
双目立体视觉.pdf
12-21
双目立体视觉.pdf
双目立体视觉汇报１.pptx
05-30
CVPR2018年关于双目立体视觉的神经网络的介绍 MC-CNN：Stereo Matching by Training a Convolutional Neural Network to Compare Image Patches（2015） LRCR：Left-Right Comparative Recurrent Model for Stereo ...
立体视觉概述
Dr.Monster小站
06-23 317
立体视觉是一种计算机视觉技术，其目的是从两幅或两幅以上的图像中推理出图像中每个像素点的深度信息。机器人、辅助驾驶/无人驾驶、无人机等等。立体视觉借鉴了人类双眼的“视差”原理，即左、右眼对于真实世界中某一物体的观测是存在差异的，我们的大脑正是利用了左、右眼的差异，使得我们能够辨识物体的远近。（视差）不是很理解?把一只眼睛捂住.P为空间中的点，P和P'是点P在左右像平面上的成像点，f是焦距，OR和OT是左右相机的光心。由下图可见左右两个相机的光轴是平行的。
双目立体视觉方法算法
02-27
获取脸部的三维数据是形成特定人脸模型的基础，根据三维数据的来源不同，国内外现有的三维人脸重建方法可分为2类：基于三维维数据的三维人脸重建方法和基于图像的三维人脸重建方法。
Stereo Match 立体视觉 基本算法！ＳＡＤ　SSD
02-12
Stereo Match 立体视觉 基本算法！包括　SSD SAD SSD NCC NSSD Census 等基本算法。用纯Ｃ／Ｃ＋＋语言编写。对于学习立体视觉　有很好的辅助理解作用，特别是作立体匹配的朋友。现在终于把它贡献出来了！
计算机视觉 — 立体视觉
weixin_45601168的博客
04-26 1330
文章目录一、原理二、实验分析三、实验代码 一、原理 介绍 立体视觉是计算机视觉领域的一个重要课题，它的目的在于重构场景的三维几何信息。立体视觉的研究具有重要的应用价值，其应用包括移动机器人的自主导航系统，航空及遥感测量，工业自动化系统等。 一般而言，立体视觉的研究有如下三类方法: (1) 直接利用测距器（如激光测距仪）获得程距（range data）信息，建立三维描述的方法; (2) 仅利...
（十五）立体视觉
m0_43609475的博客
01-28 717
立体视觉 立体视觉是双眼观察景物能分辨物体远近形态的感觉。因此实现立体视觉是要求我们根据相机的成像来计算出成像点到相机的距离。因此需要视觉测距算法 何为立体视觉： 立体视觉是一种计算机视觉技术，其目的是从两幅或两幅以上的图像中推理出图像中每个像素点的深 度信息。 立体视觉的应用领域： 机器人、辅助驾驶/无人驾驶、无人机等等。 立体视觉的原理： 立体视觉借鉴了人类双眼的“视差”原理，即左、右眼对于真实世界中某一物体的观测是存在差异的， 我们的大脑正是利用了左、右眼的差异，使得我们能够辨识物体的远近。（视差）
立体视觉的内容简介
WX_Chen的博客
10-18 1142
立体视觉（也称双目视觉）主要研究的两个相机的成像几何问题，研究内容主要包括：立体标定（Stereo Calibration）、立体校正（Stereo Rectification）和立体匹配（Stereo Matching）。目前，立体标定主要研究的已经比较完善，而立体匹配是立体视觉最核心的研究问题。 匹配图像对是OpenCV自带校正好的图像对 标准测试平台提供的标准图像对： MiddleBury KITTI 摄像机标定（包括内参和外参） 双目图像的校正（包括畸变校正和立体校正） 立体匹配算法获取视差.
计算机视觉 立体视觉极简一览
学以致用 知行合一
10-15 2781
客观世界在空间上是3-D的，所以对视觉的研究和应用从根本上说应该是3-D的。现有的大多数图像采集装置所获取的图像本身是在2-D平面上的，尽管其中可以含有3-D物体的空间信息。要从图像认识世界，就要从2-D图像中恢复3-D 空间信息，这里的关键是要测量出景物各个点与观察者（或任一个参考点）之间的距离，而立体视觉是解决这个问题的一种重要方法。立体视觉是从场景的多个 2D 视图中提取 3D 信息的过程。
立体视觉小项目
SeventhBlue
12-24 213
        工程链接         在windows7+vs2012+opencv2.4.9调通的。         README.txt ================================================================================ MICROSOFT 基础类库 : StereoVision 项目概述 ===...
【双目视觉探索路1】立体视觉的基本原理
JDeng的编程应用入门
12-12 1656
【双目视觉探索路】系列将在围绕双目立体视觉成像的基本原理上逐步对其涉及的单目标定、立体标定、立体矫正、立体匹配以及三维坐标映射进行逐级展开，并给出相应例子与实验测量结果。 第一篇文章内容涉及双目立体视觉的基本原理，对内部所涉及的一些基本步骤以及相关实现需要注意的细节进行展开；接下来的几篇文章将对双目立体视觉的实现逐步深挖。
关于一些立体视觉的总结
仓海之粟的专栏
12-06 3215
这两天一直在研究有关立体视觉方面的东西，用的是OpenCV2.0+VS2005的组合。OpenCV不愧是计算机视觉的一个相当强大的库，有了它，很多复杂的算法都可以通过简单的几句函数来实现。当然，前提是你要会配置好函数需要调用的各种变量和矩阵。调用一些复杂的OpenCV函数需要准备的变量太多了，很多时候占了程序的一半或者更多。在这里，我感到只是简单的学会调用函数是不够的，我们还需要研究透彻其中的原理，不求把函数源程序看懂（这个实在太大了，估计只有大牛们才看得懂），但至少要把算法看懂，OpenCV的很多函数都是
立体视觉测距python
最新发布
09-26
立体视觉测距是一种利用双目摄像机或多目摄像机来获取物体距离的技术。在Python中，可以使用OpenCV库来进行立体视觉测距的实现。OpenCV提供了一系列函数和算法，使得立体视觉测距的开发变得更加简单和高效。 首先，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值