多图像拼接---最佳缝合融合

最新推荐文章于 2024-06-06 09:54:29 发布
最新推荐文章于 2024-06-06 09:54:29 发布
阅读量1.8w 收藏 90
点赞数 7
分类专栏： 拼接全景图 opencv 文章标签： 图像拼接 opencv 最佳缝合线 多频段图像融合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/juebai123/article/details/79732731
版权

前面已经做了亮度调整，和权重融合

这个图融合处是有重影的

在一个博文《多分辨率拼接算法（继最佳缝合线之后）》中，有一个最佳缝合线的matlab的代码，

我把它改成opencv的一个函数bestlinefusion：

 

//《图像拼接的改进算法》最佳缝合线算法 图像融合
Mat_<Vec3f>  bestlinefusion(Mat_<Vec3f> & A,Mat_<Vec3f>& B,int rdata1)
//function D=bestlinefusion(A,B,rdata1)
{
	//先根据之前得到的H矩阵计算重叠区域Rect
	//[H,W,k]=size(A);
	int H,W;
	H=A.rows;W=A.cols;

	//rdata1=-118;
	//rdata1=fix(-rdata1);
	rdata1=-rdata1;
	//L=W+1+rdata1;
	int L=W+rdata1;
	//R=W;
	int R=W;
	//n=R-L+1;
	int n=R-L;
	//计算得到重叠区域的差值图像  其实我不懂计算差值图像干嘛  只要计算重叠区域的大小就好了 为什么还要计算差值图 后面又没用到
	//Rect=zeros(H,n);
	Mat_<float> Rectf=Mat_<float>::zeros(H,n);

#define A(x,y) A(x,y)[0]
#define B(x,y) B(x,y)[0]

	//for i=1:H
	for(int i=0;i<H;i++){
	//	for j=L:R
		for(int j=L;j<R;j++){
			Rectf(i,j-L+1)=A(i,j)-B(i,j-L+1);
			//Rectf(i,j-L)=A(i,j)[0]-B(i,j-L+1)[0];
	 	}//end
	}//end
	//Rectf=uint8(Rectf);//这句要不要呢？

			
	//最终融合图的大小
	//rdata1=-118;
	//rdata2=3;
	int Y=2*W+rdata1+1;
	Mat_<Vec3f> D=Mat_<Vec3f>::zeros(H,Y);
	//放路径的矩阵
	Mat_<float> path=Mat_<float>::zeros(H,n);
	//放强度值 每条路径的强度值strength=color^2+geometry
	Mat_<float> color=Mat_<float>::zeros(1,n);
	Mat_<float> geometry=Mat_<float>::zeros(1,n);
	Mat_<float> strength1=Mat_<float>::zeros(1,n);
	Mat_<float> strength2=Mat_<float>::zeros(1,n);

	float Bxdao;
	float Bydao;
	float Aydao;
	float Axdao;

	//计算第一行即初始化的强度值
	//for j=L:R
	for(int j=L;j<R;j++){
		int y=j-L+1;
		color(y)=A(1,j)-B(1,y);
		if(y==1){
			Bxdao=B(1,y+1)+2*B(2,y+1);
			Bydao=B(2,y)+2*B(2,y+1);
			Aydao=2*A(2,j-1)+A(2,j)+2*A(2,j+1);
			Axdao=A(1,j+1)+2*A(2,j+1)-A(1,j-1)-2*A(2,j-1);
			geometry(y)=(Axdao-Bxdao)*(Aydao-Bydao);
			strength1(y)=sqrt(color(y))+geometry(y);
			path(1,y)=y;
			continue;
		}//end
		if(j==R){
			Axdao=A(1,j-1)-2*A(2,j-1);
			Aydao=2*A(2,j-1)+A(2,j);
			Bxdao=B(1,y+1)+2*B(2,y+1)-B(1,y-1)-2*B(2,y-1);
			Bydao=2*B(2,y-1)+B(2,y)+2*B(2,y+1);
			geometry(y)=(Axdao-Bxdao)*(Aydao-Bydao);
			strength1(y)=sqrt(color(y))+geometry(y);
			path(1,y)=y;
			continue;
		}//end
		Axdao=A(1,j+1)+2*A(2,j+1)-A(1,j-1)-2*A(2,j-1);
		Bxdao=B(1,y+1)+2*B(2,y+1)-B(1,y-1)-2*B(2,y-1);
		Aydao=2*A(2,j-1)+A(2,j)+2*A(2,j+1);
		Bydao=2*B(2,y-1)+B(2,y)+2*B(2,y+1);
		geometry(y)=(Axdao-Bxdao)*(Aydao-Bydao);
		strength1(y)=sqrt(color(y))+geometry(y);
		path(1,y)=y;
	}//end
color=Mat_<float>::zeros(1,n);
geometry=Mat_<float>::zeros(1,n);
float small=0;

//开始扩展 向下一行 从第二行到倒数第二行 最后一行单独拿出来 像第一行一样 因为它的结构差值geometry不好算
//for i=2:H-1
for(int i=1;i<H-1;i++){
    //先把下一行的强度值全部计算出来 到时候需要比较哪三个就拿出哪三个
    //for j=L:R
	for(int j=L;j<R;j++){
        int x=i;
        int y=j-L+1;
        color(y)=A(i,j)-B(x,y);
		if(y==1){
            Axdao=2*A(i-1,j+1)+A(i,j+1)+2*A(i+1,j+1)-2*A(i-1,j-1)-A(i,j-1)-2*A(i+1,j-1);
            Bxdao=2*B(x-1,y+1)+B(x,y+1)+2*B(x+1,y+1);
            Aydao=-2*A(i-1,j-1)-A(i-1,j)-2*A(i-1,j+1)+2*A(i+1,j-1)+A(i+1,j)+2*A(i+1,j+1);
            Bydao=-B(x-1,y)-2*B(x-1,y+1)+B(x+1,y)+2*B(x+1,y+1);
            geometry(y)=(Axdao-Bxdao)*(Aydao-Bydao);
            strength2(y)=sqrt(color(y))+geometry(y);
            continue;
		}//end
		if(j==R){
            Axdao=-2*A(i-1,j-1)-A(i,j-1)-2*A(i+1,j-1);
            Bxdao=2*B(x-1,y+1)+B(x,y+1)+2*B(x+1,y+1)-2*B(x-1,y-1)-B(x,y-1)-2*B(x+1,y-1);
            Aydao=-2*A(i-1,j-1)-A(i-1,j)+2*A(i+1,j-1)+A(i+1,j);
            Bydao=-2*B(x-1,y-1)-B(x-1,y)-2*B(x-1,y+1)+2*B(x+1,y-1)+B(x+1,y)+2*B(x+1,y+1);
            geometry(y)=(Axdao-Bxdao)*(Aydao-Bydao);
            strength2(y)=sqrt(color(y))+geometry(y);
           continue;
		}//end
        Axdao=2*A(i-1,j+1)+A(i,j+1)+2*A(i+1,j+1)-2*A(i-1,j-1)-A(i,j-1)-2*A(i+1,j-1);
        Bxdao=2*B(x-1,y+1)+B(x,y+1)+2*B(x+1,y+1)-2*B(x-1,y-1)-B(x,y-1)-2*B(x+1,y-1);
        Aydao=-2*A(i-1,j-1)-A(i-1,j)-2*A(i-1,j+1)+2*A(i+1,j-1)+A(i+1,j)+2*A(i+1,j+1);
        Bydao=-2*B(x-1,y-1)-B(x-1,y)-2*B(x-1,y+1)+2*B(x+1,y-1)+B(x+1,y)+2*B(x+1,y+1);
        geometry(y)=(Axdao-Bxdao)*(Aydao-Bydao);
        strength2(y)=sqrt(color(y))+geometry(y);
	}//end
    //for j=1:n
	for(int j=0;j<n;j++){
		if(path(i-1,j)==1){
			if(strength2(1)<strength2(2)){
              strength1(j)=strength1(j)+strength2(1);
              path(i,j)=1;
			}else{
              strength1(j)=strength1(j)+strength2(2);
              path(i,j)=2;
			}//end
		}else{
			if(path(i-1,j)==n){
				if(strength2(n-1)<strength2(n)){
                strength1(j)=strength1(j)+strength2(n-1);
                path(i,j)=n-1;
				}else{
                strength1(j)=strength1(j)+strength2(n);
                path(i,j)=n;
				}//end
			}else{
				if(strength2(path(i-1,j)-1)<strength2(path(i-1,j))){
					if(strength2(path(i-1,j)-1)<strength2(path(i-1,j)+1)){
                        small=strength2(path(i-1,j)-1);
                        path(i,j)=path(i-1,j)-1;
                    }else{
                        small=strength2(path(i-1,j)+1);
                        path(i,j)=path(i-1,j)+1;
                    }//end
                }else{
					if(strength2(path(i-1,j))<strength2(path(i-1,j)+1)){
                        small=strength2(path(i-1,j));
                        path(i,j)=path(i-1,j);
                    }else{
                        small=strength2(path(i-1,j)+1);
                        path(i,j)=path(i-1,j)+1;
                    }//end
                }//end
                strength1(j)=strength1(j)+small;
            }//end
		}//end
        small=0;
	}//end
    strength2=Mat_<float>::zeros(1,n);
    color=Mat_<float>::zeros(1,n);
    geometry=Mat_<float>::zeros(1,n);
    //if (0==(i%10))cout<<i<<endl;//disp(i);end;
}//end
//cout<<"color:"<<color.rows<<"'"<<color.cols<<endl;

//单独计算最后一行
{
int i=H-1;
//for j=L:R
//cout<<"L,R:"<<L<<"'"<<R<<endl;

for(int j=L;j<R;j++){

        int x=i;
        int y=j-L+1;
	//cout<<"i:"<<i<<endl;
	//cout<<"j:"<<j<<endl;
	//cout<<"x:"<<x<<endl;
	//cout<<"y:"<<y<<endl;
		
        color(y)=A(i,j)-B(x,y);
		if(y==1){
            Axdao=2*A(i-1,j+1)+A(i,j+1)-2*A(i-1,j-1)-A(i,j-1);
            Aydao=-2*A(i-1,j-1)-A(i-1,j)-2*A(i-1,j+1);
            Bxdao=2*B(x-1,y+1)+B(x,y+1);
            Bydao=-B(x-1,y)-2*B(x-1,y+1);
            continue;
        }//end
		if(j==R){
            Bxdao=2*B(x-1,y+1)+B(x,y+1)-2*B(x-1,y-1)-B(x,y-1);
            Bydao=-2*B(x-1,y-1)-B(x-1,y)-2*B(x-1,y+1);
            Axdao=-2*A(i-1,j-1)-A(i,j-1);
            Aydao=-2*A(i-1,j-1)-A(i-1,j);
            continue;
        }//end 
        Axdao=2*A(i-1,j+1)+A(i,j+1)-2*A(i-1,j-1)-A(i,j-1);
        Bxdao=2*B(x-1,y+1)+B(x,y+1)-2*B(x-1,y-1)-B(x,y-1);
        Aydao=-2*A(i-1,j-1)-A(i-1,j)-2*A(i-1,j+1);
        Bydao=-2*B(x-1,y-1)-B(x-1,y)-2*B(x-1,y+1);
        geometry(y)=(Axdao-Bxdao)*(Aydao-Bydao);
        strength2(y)=sqrt(color(y))+geometry(y);
}//end

//for j=1:n
for(int j=0;j<n;j++){
	if(path(i-1,j)==1){
		if(strength2(1)<strength2(2)){
              strength1(j)=strength1(j)+strength2(1);
              path(i,j)=1;
           }else{
              strength1(j)=strength1(j)+strength2(2);
              path(i,j)=2;
           }//end
        }else{
			if(path(i-1,j)==n){
				if(strength2(n-1)<strength2(n)){
                strength1(j)=strength1(j)+strength2(n-1);
                path(i,j)=n-1;
              }else{
                strength1(j)=strength1(j)+strength2(n);
                path(i,j)=n;
              }//end
            }else{
				if(strength2(path(i-1,j)-1)<strength2(path(i-1,j))){
					if(strength2(path(i-1,j)-1)<strength2(path(i-1,j)+1)){
                        small=strength2(path(i-1,j)-1);
                        path(i,j)=path(i-1,j)-1;
                    }else{
                        small=strength2(path(i-1,j)+1);
                        path(i,j)=path(i-1,j)+1;
                    }//end
                }else{
					if(strength2(path(i-1,j))<strength2(path(i-1,j)+1)){
                        small=strength2(path(i-1,j));
                        path(i,j)=path(i-1,j);
                    }else{
                        small=strength2(path(i-1,j)+1);
                        path(i,j)=path(i-1,j)+1;
                    }//end
                }//end
                strength1(j)=strength1(j)+small;
            }//end
        }//end
        small=0;
}//end  
}
//比较strength1里放的每条路径的强度值的总和 谁最小 就选path中对应的那一列的路径
//[minzhi,minth]=min(strength1);
float minzhi=strength1(0);
int minth=0;
for(int i=1;i<n;i++){
	if(minzhi>strength1(i)){
		minzhi=strength1(i);
		minth=i;
	}
}
Mat_<float> mypath=Mat_<float>::zeros(H,1);
//mypath=path(:,minth);
mypath=path.colRange(n-1,n);
//朋友MR_Radish666 说上句应该是：mypath=path.colRange(minth-1,minth);

//cout<<"一条最小路径："<<endl<<mypath<<endl;

#undef A
#define A(x,y,i) A(x,y)[i-1]
#undef B
#define B(x,y,i) B(x,y)[i-1]
#define D(x,y,i) D(x,y)[i-1]

//mypath放的就是最佳缝合线选出的路径 这条路径坐标是参考图A 右边是目标图B
//for i=1:H
for(int i=0;i<H;i++){
	for(int j=0;j<mypath(i)+L;j++){
        D(i,j,1)=A(i,j,1);
        D(i,j,2)=A(i,j,2);
        D(i,j,3)=A(i,j,3);
    }//end
	for(int j=mypath(i)+L;j<Y;j++){
         int x=i;
         int y=j-L+1;
         //if( y>W || x>H )continue;//end
         D(i,j,1)=B(x,y,1);
         D(i,j,2)=B(x,y,2);
         D(i,j,3)=B(x,y,3);
    }//end
}//end

 //D=uint8(D);

// 画最佳缝合线
L=W+1+rdata1;
//figure;imshow(D)
//hold on;
for(int i=0;i<H;i++){
     D(i,L+mypath(i),1)=1.0;
     D(i,L+mypath(i),2)=1.0;
     D(i,L+mypath(i),3)=1.0;
}//end
//hold off;
//Mat roi2;
//D.convertTo(roi2,CV_8U,255);
//imwrite("line.jpg",roi2);
 return D;
#undef A
#undef B
#undef D

}

然后调用这个函数，调用前

 

先准备好，左、右图，（由于这个函数只能左向右拼，如果要向其它方向拼，可能要先翻转图像）：

 

//左图
Mat_<Vec3f> l; 
int x=p.x-(im.cols-w);

cout<<"x="<<x<<endl;
Mat l8u(dst, Rect(x, p.y, im.cols, im.rows));//左图

l8u2.convertTo(l,CV_32F,1.0/255.0);//Vec3f表示有三个通道，即 l[row][column][depth]

//imshow("l",l);


//右图
Mat_<Vec3f> r; 
im.convertTo(r,CV_32F,1.0/255.0);
//缝合图
Mat_<Vec3f> bm=bestlinefusion(l,r,w);

//imshow("最佳缝合线",bm);
Mat src;
bm.convertTo(src,CV_8U,255);
Mat dstroi(dst, Rect(p.x, p.y, im.cols, im.rows));//大图中的右图位置

Rect r0(im.cols-w,0,im.cols,im.rows);  // 只取右图位置

src(r0).convertTo(dstroi, dstroi.type(), 1,0); // 到大图


再把该文中的多分辨率拼接类保存为cpp放在我们的程序中

 

 

#include"v2.cpp"//多频段图像融合 类

和上面的函数类似，准备左、右、掩码图，调用

 

 

Mat_<Vec3f> blend = LaplacianBlend(l, r, m);//金字塔融合
blend.convertTo(dstroi,CV_8U,255);//到大图

效果图：

 



哪个重影已经没有了。

这个最佳缝合线好象不是很好，好多地方跑到重合区边界就成一条直线了，接缝就比较明显了

先这样吧。

 

juebai123
关注
  • 7
    点赞
  • 踩
  • 90
    收藏
    觉得还不错? 一键收藏
  • 44
    评论
专栏目录
一种改进的最佳缝合线算法
06-07
当待拼接的源图像之间存在较大色彩差异时，最佳缝合线算法的输出图像中会存在明显的接缝，影响图像质量。针对这一问题，引入多频段融合算法，提出了一种最佳缝合线的改进算法。算法采用多尺度分解方法，将图像扩展至不同尺度空间，在不同的尺度空间内采用不同权值进行图像融合，重构还原得到最终的拼接图像，并建立主客观两种评价体系，验证算法的有效性。实验表明，相较于传统最佳缝合线算法，本文提出的算法能过够有效地解决接缝问题，输出的拼接图像在质量上有着明显的提升。
Image-Stitching:OpenCV和Python程序来缝合两个输入图像
05-19
图像拼接 创建人：Pavan Kumar 概括 OpenCV和Python程序可缝合两个输入图像。 使用说明 使用命令 python stitch_images.py <FirstImage> <SecondImage> 输出图像将被写入“结果”文件夹中
图像缝合神器：ImageStitching
最新发布
gitblog_00014的博客
06-06 243
图像缝合神器：ImageStitching 项目地址:https://gitcode.com/AmazingZhen/ImageStitching 在数字时代，通过镜头捕捉世界的片段已成为我们记录生活的重要方式。然而，单张照片往往难以囊括眼前的壮阔美景。这时，一款强大的图像缝合工具——ImageStitching应运而生，它是一个基于SIFT特征检测、kd树匹配、RANSAC算法验证和多带融合技术...
Python-Multiple-Image-Stitching-master.zip（Python 多图像拼接源码）
08-22
python 下的多图像拼接源代码，供学习参考！ python 下的多图像拼接源代码，供学习参考！ python 下的多图像拼接源代码，供学习参考！
结合最佳缝合线和多分辨率融合的图像拼接
03-29
针对图像拼接过程中，缝合线通过运动物体或配准不准确区域等情况导致融合图像出现鬼影、重影的问题，提出了一种基于差异图像加权的改进最佳缝合线算法，采用基于多分辨率和加权平均的分区图像融合算法解决了拼接线问题。
图像最佳缝合线拼接算法 Matlab源代码
04-13
参考《图像拼接的改进算法_方贤勇》论文及《最佳缝合线算法（图像融合）》博客整理出的缝合线拼图算法Matlab源代码，内含论文、源代码、测试图像及博客地址，调试可用，需自行修改其中文件路径
最佳缝合线算法（图像融合）
热门推荐
wd1603926823的专栏
10-31 3万+
理论根据《图像拼接的改进算法》，据说这个算法可以消除重叠部分运动物体的重影和鬼影问题，所以就编下试试看，反正之前编的那种很老的取平均值法融合、渐入渐出（基于距离）融合、以及改进的三角函数权重融合都只是适合静态图像融合 有重影和鬼影问题  不适合有运动物体的图像融合，所以还是要最佳缝合线算法：看论文上就四步 很清晰也很好懂  结果自己写的时候才发现看起来很容易的也许编起来没那么容易  想得太简单了。
基于最佳缝合线的多图像拼接【附python代码】
m0_56363716的博客
06-21 3096
使用最佳缝合线进行多图像融合的完整思路和代码
python最佳缝合线(Image Stitching 2)
YMilton的专栏
12-20 9109
最佳缝合线能够有效的去除拼接中运动物体移动出现的鬼影，如何寻找最佳缝合线对于图像拼接去除鬼影比较的重要。寻找最佳缝合线涉及到比较重要的一个思想是动态规划，寻找强度值最优的路径。 关于强度值的计算，具体情况如下： 以上公式是重叠像素点的颜色值之差，是结构值之差。这里的结构值计算采用Sobel算子，也可以考虑其他的边缘检测算子，其中x,y方向的算子如下： ...
图像拼接——最佳seam 1
qq_44845723的博客
07-10 471
  假设有一组对齐图像：I0I_0I0​ 和I1I_1I1​，PPP为两幅图像的重叠区域。整幅图像(这里指的是拼接后的图像)的标签LLL={0,1}，其中0表示图像I0I_0I0​，1表示图像I1I_1I1​。给重叠区域的所有像素 p∈p\inp∈ PPP分配一个标签(0 or 1)，获得标签集：lll={l1l_1l1​, l2l_2l2​, …, lPl_PlP​}。我们要做的是找到一组lll，使能量函数E(l)E(l)E(l)最小： where：DpD_pDp​(lpl_plp​)是数据项，代表为像
ELA图像拼接算法-ELA
01-08
图像拼接是一种将多张图像融合成一个宽视野或全景图像的技术，广泛应用于摄影、无人机航拍、虚拟现实等领域。在本篇中，我们将深入探讨一种名为“Error Level Analysis”（错误级别分析，简称ELA）的图像拼接方法。 ...
多分辨率拼接算法（继最佳缝合线之后）
wd1603926823的专栏
11-02 1万+
根据《图像拼接的改进算法》在完成最佳缝合线算法之后，要进行多分辨率拼接，这些完成后不仅能消除 曝光差异还能消除鬼影重影问题，所以我重新选了两个曝光差异很大的图片： 曝光差异很大   经过最佳缝合线以后：可以清楚地看到这条选出的最佳缝合线 然后开始进行多分辨率拼接  理论就继续根据这篇论文   因为步骤写得很清楚： 1，将原图扩大到拼接图大小 并另外填充一幅图缝合线左边为白右边为黑色
pythonopencv图像拼接缝隙_OpenCV探索之路（二十四）图像拼接和图像融合技术
weixin_39543773的博客
11-29 2452
图像拼接在实际的应用场景很广，比如无人机航拍，遥感图像等等，图像拼接是进一步做图像理解基础步骤，拼接效果的好坏直接影响接下来的工作，所以一个好的图像拼接算法非常重要。再举一个身边的例子吧，你用你的手机对某一场景拍照，但是你没有办法一次将所有你要拍的景物全部拍下来，所以你对该场景从左往右依次拍了好几张图，来把你要拍的所有景物记录下来。那么我们能不能把这些图像拼接成一个大图呢？我们利用opencv就可...
Python计算机视觉（三）—图像拼接
summer_524的博客
05-09 1万+
图像拼接是计算机视觉中的重要分支,它是将两幅以上的具有部分重叠的图像进行拼接从而得到较高分辨率或宽视角的图像。本文将结合python+opencv实现两幅图像的拼接。1.根据给定图像/集，实现特征匹配2.通过匹配特征计算图像之间的变换结构3.利用图像变换结构，实现图像映射4.针对叠加后的图像，采用APAP之类的算法，对齐特征点5.通过图割方法，自动选取拼接缝6.根据multi-band blending策略实现融合。
车载环视拼接系统的设计与实现(五)：图像拼接缝融合
w77AYU的博客
03-11 8642
      对于拼接后得到的俯视图，在拼接相邻两图拼接处存在一条拼接缝，如果不作处理，在视频播放过程中在拼接缝处会有明显的跳跃情况。由于我们相邻的两幅图之间有重叠区域，我们可以利用重叠区进行平滑过渡处理来消除拼接缝。      消除拼接缝的方法有多种，主要的两种有：1、中值滤波法消除拼接缝。2、利用加权平均融合消除拼接缝。对于拼接缝的消除有两点要求：一是拼接区域过渡平滑，二是拼接区域亮度跳跃变化不...
动态规划搜索图像最佳拼接线
weixin_40531064的博客
09-27 436
图像能量函数、图像拼接、动态规划
opencv实践项目-图片拼接之缝合线算法
wyw0000的博客
05-18 1836
opencv 图片缝合线算法
最佳缝合线融合算法图像拼接python
03-14
对于最佳缝合线融合算法图像拼接的 Python 实现，我可以提供一些参考资料和代码示例，但具体实现细节需要根据具体情况进行调整和优化。以下是一个基于 OpenCV 库的 Python 实现示例： ```python import cv2 import numpy as np # 读取两张待拼接的图像 img1 = cv2.imread('image1.jpg') img2 = cv2.imread('image2.jpg') # 将两张图像转换为灰度图像 gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY) gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY) # 使用 SIFT 特征检测器和描述符提取器 sift = cv2.xfeatures2d.SIFT_create() kp1, des1 = sift.detectAndCompute(gray1, None) kp2, des2 = sift.detectAndCompute(gray2, None) # 使用 FLANN 匹配器进行特征点匹配 FLANN_INDEX_KDTREE = 0 index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5) search_params = dict(checks=50) flann = cv2.FlannBasedMatcher(index_params, search_params) matches = flann.knnMatch(des1, des2, k=2) # 筛选出最佳匹配点对 good_matches = [] for m, n in matches: if m.distance < 0.7 * n.distance: good_matches.append(m) # 计算图像间的变换矩阵 src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2) dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2) M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0) # 将第二张图像变换到第一张图像的坐标系中 h, w = gray1.shape warped_img2 = cv2.warpPerspective(img2, M, (w, h)) # 将两张图像进行融合 blend_img = cv2.addWeighted(img1, 0.5, warped_img2, 0.5, 0) # 显示拼接结果 cv2.imshow('Blend Image', blend_img) cv2.waitKey(0) cv2.destroyAllWindows() ``` 这段代码实现了基于 SIFT 特征点匹配和 RANSAC 算法的图像拼接，可以将两张图像进行无缝融合。如果需要更高效的实现，可以考虑使用 GPU 加速或者其他更高级的算法。
评论 44
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值