Python+OpenCV实现图像融合的原理及代码-6ren

Python+OpenCV实现图像融合的原理及代码

转载作者：qq735679552 更新时间：2022-09-27 22:32:09

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Python+OpenCV实现图像融合的原理及代码由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

根据导师作业安排，在学习数字图像处理（刚萨雷斯版）第六章彩色图像处理中的彩色模型后，导师安排了一个比较有趣的作业:

Python+OpenCV实现图像融合的原理及代码

融合原理为:

1 注意：遥感原rgb图image和灰度图grayimage为测试用的输入图像；。

2 步骤：（1）将rgb转换为hsv空间（h：色调，s：饱和度，v：明度）；。

（2）用gray图像诶换掉hsv中的v；。

（3）替换后的hsv转换回rgb空间即可得到结果.

书上只介绍了hsi彩色模型，并没有说到hsv，所以需要网上查找资料.

python代码如下:

 
    ? 
   
 
     
       
       
         import 
         cv2 
        
 
         import 
         numpy as np 
        
 
         import 
         math 
        
 
         from 
         matplotlib  
         import 
         pyplot as plt 
        
 
         def 
         caijian(img): 
         #裁剪图像与否根据选择图像大小而定，调用了opencv函数 
        
 
         weight 
         = 
         img.shape[ 
         0 
         ] 
        
 
         height 
         = 
         img.shape[ 
         1 
         ] 
        
 
         print 
         (“图像大小为： 
         % 
         d 
         * 
         % 
         d” 
         % 
         (weight,height)) 
        
 
         img 
         = 
         cv2.resize(img,( 
         int 
         (weight 
         / 
         2 
         ), 
         int 
         (height 
         / 
         2 
         )),interpolation 
         = 
         cv2.inter_cubic) 
        
 
         return 
         (img) 
        
 
         def 
         graytograyimg(img): 
        
 
         grayimg 
         = 
         img1 
        
 
         weight 
         = 
         img.shape[ 
         0 
         ] 
        
 
         height 
         = 
         img.shape[ 
         1 
         ] 
        
 
         for 
         i  
         in 
         range 
         (weight): 
        
 
         for 
         j  
         in 
         range 
         (height): 
        
 
         grayimg[i,j] 
         = 
         0.299img 
         [i,j, 
         0 
         ] 
         + 
         0.587img 
         [i,j, 
         1 
         ] 
         + 
         0.114img 
         [i,j, 
         2 
         ] 
        
 
         return 
         (grayimg) 
        
 
         def 
         rgbtohsv(img): 
        
 
         b,g,r 
         = 
         cv2.split(img) 
        
 
         rows,cols 
         = 
         b.shape 
        
 
         h 
         = 
         np.ones([rows,cols],“ 
         float 
         ”) 
        
 
         s 
         = 
         np.ones([rows,cols],“ 
         float 
         ”) 
        
 
         v 
         = 
         np.ones([rows,cols],“ 
         float 
         ”) 
        
 
         print 
         (“rgb图像大小： 
         % 
         d 
         * 
         % 
         d” 
         % 
         (rows,cols)) 
        
 
         for 
         i  
         in 
         range 
         ( 
         0 
         , rows): 
        
 
         for 
         j  
         in 
         range 
         ( 
         0 
         , cols): 
        
 
         max 
         = 
         max 
         ((b[i,j],g[i,j],r[i,j])) 
        
 
         min 
         = 
         min 
         ((b[i,j],g[i,j],r[i,j])) 
        
 
         v[i,j] 
         = 
         max 
        
 
         if 
         v[i,j] 
         0 
         : 
        
 
         s[i,j] 
         = 
         0 
        
 
         else 
         : 
        
 
         s[i,j] 
         = 
         (v[i,j] 
         - 
         min 
         ) 
         / 
         v[i,j] 
        
 
         if 
         maxmin: 
        
 
         h[i,j] 
         = 
         0 
         # 如果rgb三向量相同，色调为黑 
        
 
         elif 
         v[i,j] 
         = 
         = 
         r[i,j]: 
        
 
         h[i,j] 
         = 
         ( 
         60 
         * 
         ( 
         float 
         (g[i,j]) 
         - 
         b[i,j]) 
         / 
         (v[i,j] 
         - 
         min 
         )) 
        
 
         elif 
         v[i,j] 
         = 
         = 
         g[i,j]: 
        
 
         h[i,j] 
         = 
         60 
         * 
         ( 
         float 
         (b[i,j]) 
         - 
         r[i,j]) 
         / 
         (v[i,j] 
         - 
         min 
         ) 
         + 
         120 
        
 
         elif 
         v[i,j] 
         = 
         = 
         b[i,j]: 
        
 
         h[i,j] 
         = 
         60 
         * 
         ( 
         float 
         (r[i,j]) 
         - 
         g[i,j]) 
         / 
         (v[i,j] 
         - 
         min 
         ) 
         + 
         240 
        
 
         if 
         h[i,j]< 
         0 
         : 
        
 
         h[i,j] 
         = 
         h[i,j] 
         + 
         360 
        
 
         h[i,j] 
         = 
         h[i,j] 
         / 
         2 
        
 
         s[i,j] 
         = 
         255 
         * 
         s[i,j] 
        
 
         result 
         = 
         cv2.merge((h,s,v))  
         # cv2.merge函数是合并单通道成多通道 
        
 
         result 
         = 
         np.uint8(result) 
        
 
         return 
         (result) 
        
 
         def 
         graytohsgry(grayimg,hsvimg): 
        
 
         h,s,v 
         = 
         cv2.split(hsvimg) 
        
 
         rows,cols 
         = 
         v.shape 
        
 
         for 
         i  
         in 
         range 
         (rows): 
        
 
         for 
         j  
         in 
         range 
         (cols): 
        
 
         v[i,j] 
         = 
         grayimg[i][j][ 
         0 
         ] 
        
 
         newimg 
         = 
         cv2.merge([h,s,v]) 
        
 
         newimg 
         = 
         np.uint8(newimg) 
        
 
         return 
         newimg 
        
 
         def 
         hsvtorgb(img,rgb): 
        
 
         h1,s1,v1 
         = 
         cv2.split(img) 
        
 
         rg  
         = 
         rgb.copy() 
        
 
         rows,cols 
         = 
         h1.shape 
        
 
         r,g,b 
         = 
         0.0 
         , 
         0.0 
         , 
         0.0 
        
 
         b1,g1,r1  
         = 
         cv2.split(rg) 
        
 
         print 
         (“hsv图像大小为： 
         % 
         d 
         * 
         % 
         d” 
         % 
         (rows,cols)) 
        
 
         for 
         i  
         in 
         range 
         (rows): 
        
 
         for 
         j  
         in 
         range 
         (cols): 
        
 
         h 
         = 
         h1[i][j] 
        
 
         v 
         = 
         v1[i][j] 
         / 
         255 
        
 
         s 
         = 
         s1[i][j] 
         / 
         255 
        
 
         h 
         = 
         h2 
        
 
         hx 
         = 
         int 
         (h 
         / 
         60.0 
         ) 
        
 
         hi 
         = 
         hx 
         % 
         6 
        
 
         f 
         = 
         hx 
         - 
         hi 
        
 
         p 
         = 
         v( 
         1 
         - 
         s) 
        
 
         q 
         = 
         v 
         * 
         ( 
         1 
         - 
         fs) 
        
 
         t 
         = 
         v( 
         1 
         - 
         ( 
         1 
         - 
         f)s) 
        
 
         if 
         hi0: 
        
 
         r,g,b 
         = 
         v,t,p 
        
 
         elif 
         hi1: 
        
 
         r,g,b 
         = 
         q,v,p 
        
 
         elif 
         hi2: 
        
 
         r,g,b 
         = 
         p,v,t 
        
 
         elif 
         hi3: 
        
 
         r,g,b 
         = 
         p,q,v 
        
 
         elif 
         hi4: 
        
 
         r,g,b 
         = 
         t,p,v 
        
 
         elif 
         hi5: 
        
 
         r,g,b 
         = 
         v,p,q 
        
 
         r,g,b 
         = 
         (r255),(g255),(b255) 
        
 
         r1[i][j] 
         = 
         int 
         ® 
        
 
         g1[i][j] 
         = 
         int 
         (g) 
        
 
         b1[i][j] 
         = 
         int 
         (b) 
        
 
         rg 
         = 
         cv2.merge([b1,g1,r1]) 
        
 
         return 
         rg 
        
 
         img 
         = 
         cv2.imread(“d: 
         / 
         rgb.bmp”) 
        
 
         gray 
         = 
         cv2.imread(“d: 
         / 
         gray.bmp”) 
        
 
         img 
         = 
         caijian(img) 
        
 
         gray 
         = 
         caijian(gray) 
        
 
         grayimg 
         = 
         graytograyimg(gray) 
        
 
         hsvimg 
         = 
         rgbtohsv(img) 
        
 
         hsgray 
         = 
         graytohsgry(grayimg,hsvimg) 
        
 
         rgbimg 
         = 
         hsvtorgb(hsgray,img) 
        
 
         cv2.imshow(“image”,img) 
        
 
         cv2.imshow(“grayimage”,grayimg) 
        
 
         cv2.imshow(“hsvimage”,hsvimg) 
        
 
         cv2.imshow(“hsgrayimage”,hsgray) 
        
 
         cv2.imshow(“rgbimage”,rgbimg) 
        
 
         cv2.waitkey( 
         0 
         ) 
        
 
         cv2.destroyallwindows() 
        
 
     
 
   

以上代码是在尽量不调用opencv函数的情况下编写，其目的是熟悉图像处理原理和python编程，注释很少，其中rgb转hsv原理，hsv转rgb原理，在csdn中都能找到，灰度图替换hsv中的v原理其实很简单，看代码就能明白，不用再找资料.

总结。

以上所述是小编给大家介绍的python+opencv实现图像融合的原理及代码，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对我网站的支持！。

原文链接：https://blog.csdn.net/Skymelu/article/details/84767689 。

最后此篇关于Python+OpenCV实现图像融合的原理及代码的文章就讲到这里了,如果你想了解更多关于Python+OpenCV实现图像融合的原理及代码的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： python 接收处理外带的参数方法

文章推荐： EditPlus中的正则表达式实战(5)

文章推荐： EditPlus中的正则表达式实战(1)

文章推荐：浅谈python脚本设置运行参数的方法

Docker通信全视角：原理、实践与技术洞察
本文全面深入地探讨了Docker容器通信技术，从基础概念、网络模型、核心组件到实战应用。详细介绍了不同网络模式及其实现，提供了容器通信的技术细节和实用案例，旨在为专业从业者提供深入的技术洞见和实
Dubbo快速上手 -- 带你了解Dubbo使用、原理
📒博客首页：崇尚学技术的科班人 🍣今天给大家带来的文章是《Dubbo快速上手 -- 带你了解Dubbo使用、原理》🍣 🍣希望各位小伙伴们能够耐心的读完这篇文章🍣 🙏博主也在学习阶段，如若发
npm install 原理
一、写在前面我们经常使用npm install ，但是你是否思考过它内部的原理是什么？ 1、执行npm install 它背后帮助我们完成了什么操作？ 2、我们会发现还有一个成为package-lo
一篇带你了解 Base64 原理
Base64 Base64 是什么?是将字节流转换成可打印字符、将可打印字符转换为字节流的一种算法。Base64 使用 64 个可打印字符来表示转换后的数据。准确的来说，Base64 不算
详细解读tornado协程(coroutine)原理
目录协程定义生成器和yield语义 Future类 IOLoop类 coroutine函数装饰器总结 tornado中的
golang常用手册之切片(Slice)原理
切片，这是一个在go语言中引入的新的理念。它有一些特征如下：对数组抽象数组长度不固定可追加元素切片容量可增大容量大小成片增加我们先把上面的理念整理在这
100 行代码透彻解析 RPC 原理
文章来源：https://sourl.cn/HpZHvy 引言本文主要论述的是“RPC 实现原理”，那么首先明确一个问题什么是 RPC 呢？RPC 是 Remote Procedure Call
原理：WebMvcConfigurer 与 WebMvcConfigurationSupport避坑指南
源码地址（包含所有与springmvc相关的，静态文件路径设置，request请求入参接受，返回值处理converter设置等等）： spring-framework/WebMvcConfigurat
java - 关于简单java类中的依赖注入(inject)原理
请通过简单的java类向我展示一个依赖注入(inject)原理的小例子虽然我已经了解了spring，但是如果我需要用简单的java类术语来解释它，那么你能通过一个简单的例子向我展示一下吗？提前致谢。
简单聊聊内网穿透（背景-概念-原理-工具对比）
1、背景我们平常使用手机和电脑上网，需要访问公网上的网络资源，如逛淘宝和刷视频，那么手机和电脑是怎么知道去哪里去拿到这个网络资源来下载到本地的呢？就比如我去食堂拿吃的，我需要
来，今天飞哥带你理解 Iptables 原理！
大家好，我是飞哥! 现在 iptables 这个工具的应用似乎是越来越广了。不仅仅是在传统的防火墙、NAT 等功能出现，在今天流行的的 Docker、Kubernets、Istio 项目中也经
CesiumJS 2022^ 原理[5] - 着色器相关的封装设计
本篇涉及到的所有接口在公开文档中均无，需要下载 GitHub 上的源码，自己创建私有类的文档。 npm run generateDocumentation -- --private yarn gene
solid-principles - SOLID 原理，以及类内的硬编码配置
我最近在很多代码中注意到人们将硬编码的配置(如端口号等)值放在类/方法的深处，使其难以找到，也无法配置。这是否违反了 SOLID 原则？如果不是，我是否可以向我的团队成员引用另一个“原则”来说明为什
mvvm - 命令和 MVVM 原理 - RelayCommands
我是 C#、WPF 和 MVVM 模式的新手。很抱歉这篇很长的帖子，我试图设定我所有的理解点(或不理解点)。在研究了很多关于 WPF 提供的命令机制和 MVVM 模式的文本之后，我在弄清楚如何使用这
javascript - Angularjs $http.post 原理
可比较的 jQuery 函数 $.post("/example/handler", {foo: 1, bar: 2}); 将创建一个带有 post 参数 foo=1&bar=2 的请求。鉴于 $htt
Django "lazy query execution"原理
如果Django不使用“延迟查询执行”原则，主要问题是什么？ q = Entry.objects.filter(headline__startswith="What") q = q.filter(
c# - .NET 中的 BODMAS 原理
我今天发现.NET框架在做计算时遵循BODMAS操作顺序。即计算按以下顺序进行: 括号订单部门乘法添加减法但是我四处搜索并找不到任何文档确认 .NET 绝对遵循此原则，是否有此类文档？如
c++ - 库方便使用 "design by contract"原理
已结束。此问题不符合 Stack Overflow guidelines .它目前不接受答案。我们不允许提出有关书籍、工具、软件库等方面的建议的问题。您可以编辑问题，以便用事实和引用来回答它。关闭
CesiumJS 2022^ 原理[4] - 最复杂的地球皮肤影像与地形的渲染与下载过程
API 回顾在创建 Viewer 时可以直接指定影像供给器（ImageryProvider），官方提供了一个非常简单的例子，即离屏例子（搜 offline）： new Cesium.Viewer(
compiler-construction - self 学习编译器的最佳方法:原理，技术和工具
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be

qq735679552

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

Python+OpenCV实现图像融合的原理及代码