转自：http://blog.csdn.net/u014088052/article/details/50531675
最近做了一个关于全景拼接的，觉得这是一个比较简单地项目吧，但是真正做起来还是有很多问题，期间也再网上看大家做的，基本上都只拼接了两张图，当我拼接全景的时候，畸变就会指数式的增长，后来发现大家通常用的方法有点问题，在这里我说一下我的思路。
- 柱面投影
- 特征点的提取和匹配
- 图像融合
柱面投影
具体的原理和推导过程百度百科就有，这里就不说了。
这是柱面投影公式：
⎧ ⎩ ⎨ ⎪ ⎪ x ′ =r∗W2 −r(arctan(W2 −xr ))y ′ =H2 −r(H2 −y)d
其中，
⎧ ⎩ ⎨ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ r=W2tana2 w=2arctan(W2r )d=H2 +(W2 −x) 2 − − − − − − − − − − − − √
但是在使用整个投影公式的时候回出现一个问题，因为经过数值计算以后，对应的坐标是小数，做近似处理后，投影后的图片会有锯齿现象。所以可以使用柱面反投影，遍历柱面图像中的每一个像素点，得到每一点在原始图像中的采样点的像素坐标值，虽然得到的采样点的坐标也是小数值，但是可以根据双线性插值运算来近似求得该小数位置的颜色值。
反投影公式:
⎧ ⎩ ⎨ x=W2 +r∗tan(x ′ r −w2 )y=H2 +d∗(y ′ −H2 )r
Mat cyP(Mat imageIn, int n){
const float PI = 3.1415926;
int w = imageIn.cols;
int h = imageIn.rows;
Mat imageOut(imageIn.rows, imageIn.cols, imageIn.type());//新建一张与imagIn相同尺寸类型的图片
double sita = 2 * PI / n;
double f = w / 2 / tan(sita / 2);
for (int i = 0; i < h; i++){
for (int j = 0; j < w; j++){
double x = f*tan(j / f - sita / 2) + w / 2;
double y = (i - h / 2)*sqrt((x - w / 2)*(x - w / 2) + f*f) / f + h / 2;//柱面反投影（i，j为柱面图上坐标；x,y为原图上坐标）
if (x > 0 && x < w - 1 && y > 0 && y < h - 1){
double u, v;
u = x - int(x);
v = y - int(y);
Vec3b s0, s1, s2, s3, s4;
s1 = imageIn.at<Vec3b>(int(y), int(x));
s2 = imageIn.at<Vec3b>(int(y), int(x) + 1);
s3 = imageIn.at<Vec3b>(int(y) + 1, int(x));
s4 = imageIn.at<Vec3b>(int(y) + 1, int(x) + 1);
s0 = (1 - u)*(1 - v)*s1 + (1 - u)*v*s2 + u*(1 - v)*s2 + u*v*s3;//使用双线性插值计算对应点的像素值
imageOut.at<Vec3b>(i, j) = s0;
}
if (x == w - 1 || y == h - 1)
{
imageOut.at<Vec3b>(i, j) = imageIn.at<Vec3b>(x, y);
}
}
}
return imageOut;
}特征点的匹配和筛选
这里就直接使用了 SURF 特征点提取，先通过两个特征向量之间的欧氏距离进行一次筛选，接着用 RANSAC方法计算这些关键点之间的变换矩阵，计算出内点和野点。
initModule_nonfree();//初始化模块，使用SIFT或SURF时用到
Ptr<FeatureDetector> detector = FeatureDetector::create("SURF");//创建SIFT特征检测器，可改成SURF/ORB
Ptr<DescriptorExtractor> descriptor_extractor = DescriptorExtractor::create("SURF");//创建特征向量生成器，可改成SURF/ORB
Ptr<DescriptorMatcher> descriptor_matcher = DescriptorMatcher::create("BruteForce");//创建特征匹配器
Mat img2ROI = img2(Rect(0, 0, img1.cols, img1.rows));//对image2提取感兴趣区域，为了减少计算量和避免最后一张计算矩阵出错
//特征点检测
vector<KeyPoint> m_LeftKey, m_RightKey;
detector->detect(img1, m_LeftKey);
detector->detect(img2ROI, m_RightKey);
//根据特征点计算特征描述子矩阵，即特征向量矩阵
Mat descriptors1, descriptors2;
descriptor_extractor->compute(img1, m_LeftKey, descriptors1);
descriptor_extractor->compute(img2ROI, m_RightKey, descriptors2);
//特征匹配
vector<DMatch> matches;//匹配结果
descriptor_matcher->match(descriptors1, descriptors2, matches);
//计算匹配结果中距离的最大和最小值，距离是指两个特征向量间的欧式距离，表明两个特征的差异，值越小表明两个特征点越接近
double max_dist = 0;
double min_dist = 100;
for (int i = 0; i<matches.size(); i++)
{
double dist = matches[i].distance;
if (dist < min_dist) min_dist = dist;
if (dist > max_dist) max_dist = dist;
}
//筛选出较好的匹配点
vector<DMatch> goodMatches;
for (int i = 0; i<matches.size(); i++)
{
if (matches[i].distance < 0.2 * max_dist)//0.2这个阈值可以调整
{
goodMatches.push_back(matches[i]);
}
}
//RANSAC匹配过程
vector<DMatch> m_Matches = goodMatches;
// 分配空间
int ptCount = (int)m_Matches.size();
Mat p1(ptCount, 2, CV_32F);
Mat p2(ptCount, 2, CV_32F);
// 把Keypoint转换为Mat
Point2f pt;
for (int i = 0; i<ptCount; i++)
{
pt = m_LeftKey[m_Matches[i].queryIdx].pt;
p1.at<float>(i, 0) = pt.x;
p1.at<float>(i, 1) = pt.y;
pt = m_RightKey[m_Matches[i].trainIdx].pt;
p2.at<float>(i, 0) = pt.x;
p2.at<float>(i, 1) = pt.y;
}
// 用RANSAC方法计算F
Mat m_Fundamental;
vector<uchar> m_RANSACStatus; // 这个变量用于存储RANSAC后每个点的状态，0表示野点，1表示内点
findFundamentalMat(p1, p2, m_RANSACStatus, FM_RANSAC);
// 计算野点个数
int OutlinerCount = 0;
for (int i = 0; i<ptCount; i++)
{
if (m_RANSACStatus[i] == 0) // 状态为0表示野点
{
OutlinerCount++;
}
}
int InlinerCount = ptCount - OutlinerCount; // 计算内点个数
图像的融合
这里就是比较重要的部分，之前大家都会计算一个单映性矩阵，H=findHomography, 我们会使用这个来筛选匹配点是没有问题的，就像上面的标准矩阵是一样的功能，但是后来大家在融合的时候用这个矩阵去变换整个图片就不正确了，因为这个矩阵式适合在平面上的计算，而我们这边是360柱面的，在计算矩阵之前我们已经进行了柱面投影，不再适用这个变换矩阵了。
其实我们接下来需要做的更简单，只要求出对应匹配点之间的平移向量，然后通过平移，将图片融合就可以了
融合的时候，采用以下的公式，让融合部分更加平滑一点：
d1d1+d2 ∗img1+d2d1+d2 ∗img2
vector<float> m_DiffX;//用来储存对应匹配点之间X的距离
vector<float> m_DiffY;//用来储存对应匹配点之间Y的距离
m_DiffX.resize(InlinerCount);
m_DiffY.resize(InlinerCount);
InlinerCount = 0;
for (int i = 0; i<ptCount; i++)
{
if (m_RANSACStatus[i] != 0)
{
float x1 = p1.at<float>(i, 0);
float y1 = p1.at<float>(i, 1);
float x2 = p2.at<float>(i, 0);
float y2 = p2.at<float>(i, 1);
m_DiffX[InlinerCount] = img1.cols - x1 + x2;
m_DiffY[InlinerCount] = y1 - y2;
//冒泡排序对应匹配点X和Y的距离
for (int k = 0; k < InlinerCount; k++){
if (m_DiffX[InlinerCount - k] < m_DiffX[InlinerCount - k -1]){ //判断所取点是否在图片范围内
float t1 = m_DiffX[InlinerCount - k];
m_DiffX[InlinerCount - k] = m_DiffX[InlinerCount - k -1];
m_DiffX[InlinerCount - k -1] = t1;
}
if (m_DiffY[InlinerCount - k] < m_DiffY[InlinerCount - k - 1]){
float t2 = m_DiffY[InlinerCount - k];
m_DiffY[InlinerCount - k] = m_DiffY[InlinerCount - k - 1];
m_DiffY[InlinerCount - k - 1] = t2;
}
}
InlinerCount++;
}
}
//取中值作为平移的向量
int diffX = m_DiffX[int(InlinerCount/2)];
int diffY = m_DiffY[int(InlinerCount / 2)];
//cout << "diffY=" << diffY << endl;
int h = img1.rows;
int w = img2.cols + img1.cols - diffX;
Mat img_result = Mat::zeros(h, w, img1.type());//新建融合效果图空间
int nc = w*img_result.channels();
int nc_lift = (img1.cols - diffX)*img1.channels();//左边部分的宽
int nc_right = img1.cols*img1.channels();//右边比分的宽
for (int i = 0; i < h; i++){
for (int j = 0; j < nc; j++){
if (j < nc_lift){
img_result.at<uchar>(i, j) = img1.at<uchar>(i, j);//左边部分直接取img1的点
}
else if (j >= nc_right){
if (i - diffY >= 0 && i - diffY < img_result.rows){
img_result.at<uchar>(i, j) = img2.at<uchar>(i - diffY, j - nc_lift);//右边部分直接取img2的点
}
}
else {
if (i - diffY >= 0 && i - diffY < img_result.rows){
float percentRight = (j - nc_lift) / (float)(diffX*img1.channels());
//中间融合部分的点两张图进行融合处理
img_result.at<uchar>(i, j) = img1.at<uchar>(i, j)*(1 - percentRight) + img2.at<uchar>(i - diffY, j - nc_lift)*percentRight;
}
}
}
}
扫一扫
760
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
