基于模板的图像拼接，用拼接原图后拼接热力图

于 2024-06-28 16:38:04 发布
阅读量144 收藏
点赞数 2
分类专栏： 机器视觉与图形图像 Opencv/Halcon 文章标签： opencv 人工智能 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moonlightpeng/article/details/140047402
版权 

import glob
import time
import numpy as np
import matplotlib.pyplot as plt
import cv2
import os
import threading

def stitch(index, images, outResult, outResult1, images_output):
    result = images[0]  # 将第一张图像作为初始结果
    number = len(images)
    result1 = images_output[index*number]  # 将第一张图像作为初始结果
    for i in range(1, len(images)):  # 从第二张图像开始遍历

        imageLeft = result
        imageRight = images[i]

        imageLeft1 = result1
        imageRight1 = images_output[index*number + i]

        if imageLeft is None or imageRight is None:
            print("NOTICE: No images")
        else:
            ImageLeft_gray = cv2.cvtColor(imageLeft, cv2.COLOR_BGR2GRAY)
            ImageRight_gray = cv2.cvtColor(imageRight, cv2.COLOR_BGR2GRAY)

            # 获取图像长宽
            height_Left, width_left = ImageLeft_gray.shape[:2]
            height_Right, width_Right = ImageRight_gray.shape[:2]
            beishu = height_Left / 5120
            height = int(1000 * beishu)

            # 模板区域
            left_width_begin = int(width_left - int(2000 * beishu))
            left_height_begin = height
            template_left = imageLeft[int(left_height_begin):int(2 * height_Left / 3),
                            int(left_width_begin): int(width_left - int(100 * beishu))]

            # 右边匹配区域
            match_right = imageRight[0:height_Right, 0: int(2 * width_Right / 3)]

            # 执行模板匹配，采用的匹配方式cv2.TM_CCOEFF_NORMED
            matchResult = cv2.matchTemplate(match_right, template_left, cv2.TM_CCOEFF_NORMED)
            # 归一化处理
            cv2.normalize(matchResult, matchResult, 0, 1, cv2.NORM_MINMAX, -1)
            # 寻找矩阵（一维数组当做向量，用Mat定义）中的最大值和最小值的匹配结果及其位置
            min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(matchResult)

            # 设置最终图片大小
            dstStitch = np.zeros((height_Left, width_Right + left_width_begin - max_loc[0], 3), imageLeft.dtype)
            dstStitch1 = np.zeros((height_Left, width_Right + left_width_begin - max_loc[0], 3), imageLeft1.dtype)
            height_dst, width_dst = dstStitch.shape[:2]

            # copy left image
            dstStitch[0:height_Left, 0:width_left] = imageLeft.copy()

            dstStitch1[0:height_Left, 0:width_left] = imageLeft.copy()

            # 匹配右图的高要能和目标区域一样
            matchRight_H = height_Right - max_loc[1] + left_height_begin

            if height_dst == matchRight_H:
                matchRight = imageRight[int(max_loc[1] - left_height_begin): int(height_Right),
                             int(max_loc[0]):int(width_Right)]
                matchRight = matchRight[:, int(1000 * beishu):]

                matchRight1 = imageRight1[int(max_loc[1] - left_height_begin): int(height_Right),
                             int(max_loc[0]):int(width_Right)]
                matchRight1 = matchRight1[:, int(1000 * beishu):]

            elif height_dst < matchRight_H:
                dst_y_start = (left_height_begin - max_loc[1])
                # 定义平移矩阵
                M = np.float32([[1, 0, 0], [0, 1, dst_y_start]])  # 向上平移 dst_y_start个像素
                # 应用平移矩阵
                rows, cols, _ = imageRight.shape
                matchRight = cv2.warpAffine(imageRight, M, (cols, rows))
                matchRight = matchRight[0: height_Right, max_loc[0]:width_Right]
                matchRight = matchRight[:, int(1000 * beishu):]

                matchRight1 = cv2.warpAffine(imageRight1, M, (cols, rows))
                matchRight1 = matchRight1[0: height_Right, max_loc[0]:width_Right]
                matchRight1 = matchRight1[:, int(1000 * beishu):]
            else:
                dst_y_start = (left_height_begin - max_loc[1])
                # 定义平移矩阵
                M = np.float32([[1, 0, 0], [0, 1, dst_y_start]])  # 向下平移 dst_y_start个像素
                # 应用平移矩阵
                rows, cols, _ = imageRight.shape
                matchRight = cv2.warpAffine(imageRight, M, (cols, rows))
                matchRight = matchRight[0: height_Right, max_loc[0]:width_Right]
                matchRight = matchRight[:, int(1000 * beishu):]

                matchRight1 = cv2.warpAffine(imageRight1, M, (cols, rows))
                matchRight1 = matchRight1[0: height_Right, max_loc[0]:width_Right]
                matchRight1 = matchRight1[:, int(1000 * beishu):]

            drawRightRect = imageRight.copy()
            drawRightRect1 = imageRight1.copy()

            h, w = template_left.shape[:2]
            cv2.rectangle(drawRightRect, (max_loc[0], max_loc[1]), (max_loc[0] + w, max_loc[1] + h), (0, 0, 255), 1)
            cv2.rectangle(drawRightRect1, (max_loc[0], max_loc[1]), (max_loc[0] + w, max_loc[1] + h), (0, 0, 255), 1)

            height_mr, width_mr = matchRight.shape[:2]
            dstStitch[0:height_dst,
            left_width_begin + int(1000 * beishu):width_mr + int(1000 * beishu) + left_width_begin] = matchRight.copy()

            dstStitch1[0:height_dst,
            left_width_begin + int(1000 * beishu):width_mr + int(1000 * beishu) + left_width_begin] = matchRight1.copy()
            result = dstStitch
            result1 = dstStitch1
        # file_name = f'E:/camera/pailei/{i}.jpg'  # 使用f-string创建不同的文件名
        # plt.imsave(file_name, cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
    result = cv2.rotate(result, cv2.ROTATE_90_COUNTERCLOCKWISE)
    result1 = cv2.rotate(result1, cv2.ROTATE_90_COUNTERCLOCKWISE)

    outResult.update({str(index): result})
    outResult1.update({str(index): result1})

def stitch_start(input, output , number):
    if "\\" in input[0]:
        input = sorted(input, key=lambda x: int(x.split("\\")[-1][:-4]))
    else:
        input = sorted(input, key=lambda x: int(x.split("/")[-1][:-4]))

    if "\\" in output[0]:
        output = sorted(output, key=lambda x: int(x.split("\\")[-1][:-4]))
    else:
        output = sorted(output, key=lambda x: int(x.split("/")[-1][:-4]))

    images_output = []
    for filename1 in output:

        image = cv2.imread(filename1)  # 使用OpenCV库读取图像文件

        images_output.append(image)  # 将图像添加到列表中



    images = []  # 用来存储读取的图像
    for filename in input:

        image = cv2.imread(filename)  # 使用OpenCV库读取图像文件
        images.append(image)  # 将图像添加到列表中
    beishu = images[1].shape[0] / 5120


    imgs = {}
    row_imgs = []
    size = len(images)//number
    for i in range(size):
        for j in range(number):
            row_imgs.append(images[i*number+j])
        imgs.update({str(i): row_imgs})
        row_imgs = []
    # images2 = []  # 用来存储读取的图像

    row_stitch_img = {}
    row_stitch_img1 = {}
    thread_list = []
    for i in range(size):
        images = imgs[str(i)]

        th = threading.Thread(target = stitch, args=(i, images, row_stitch_img, row_stitch_img1,images_output,))
        thread_list.append(th)
        th.start()


    for th in  thread_list:
        th.join()

        # result = stitch(images,)
        # images2.append(result)


    if len(row_stitch_img) != 0 :
        result = row_stitch_img[str(0)]  # 将第一张图像作为初始结果
        result1 = row_stitch_img1[str(0)]  # 将第一张图像作为初始结果
    n = 0
    if len(row_stitch_img) != 0:
        for i in range(1, len(row_stitch_img)):  # 从第二张图像开始遍历
            imageLeft = result
            imageRight = row_stitch_img[str(i)]

            imageLeft1 = result1
            imageRight1 = row_stitch_img1[str(i)]

            # 获取图像长宽
            height_Left, width_left = imageLeft.shape[:2]
            height_Right, width_Right = imageRight.shape[:2]
            # min_width = min(width_left,width_Right)
            min_height = min(height_Left,height_Right)

            # 裁剪图像
            imageLeft = imageLeft[:min_height, :]
            imageRight = imageRight[:min_height, :]
            # # 将第二张图调整为和第一张图一样的高度
            # imageRight = cv2.resize(imageRight, (imageRight.shape[1], height),interpolation=cv2.INTER_LINEAR)

            # if i==2:
            #     break
            if imageLeft is None or imageRight is None:
                print("NOTICE: No images")
            else:
                ImageLeft_gray = cv2.cvtColor(imageLeft, cv2.COLOR_BGR2GRAY)
                ImageRight_gray = cv2.cvtColor(imageRight, cv2.COLOR_BGR2GRAY)

                # cv2.imshow("gray", ImageLeft_gray)
                # cv2.waitKey()

                # 获取图像长宽
                height_Left, width_left = ImageLeft_gray.shape[:2]
                height_Right, width_Right = ImageRight_gray.shape[:2]
                height = int(1000 * beishu)

                # 模板区域
                left_width_begin = int(width_left - int(2000 * beishu))
                left_height_begin = height
                template_left = imageLeft[int(left_height_begin):int(height_Left-int(1000*beishu)),
                                int(left_width_begin): int(width_left - int(200 * beishu))]
                # drawLeftRect = imageLeft.copy()
                # cv2.rectangle(drawLeftRect, (left_width_begin, left_height_begin), (width_left, int(4 * height_Left / 5)),
                #               (0, 0, 255),
                #               1)

                # cv2.imshow("template_left", drawLeftRect)
                # cv2.waitKey()
                # plt.imsave('Left_rect.jpg', cv2.cvtColor(drawLeftRect, cv2.COLOR_BGR2RGB))

                # 右边匹配区域
                match_right = imageRight[0:height_Right, 0: int(1* width_Right / 2)]
                # cv2.imshow("match_right", match_right)
                # cv2.waitKey()

                # 执行模板匹配，采用的匹配方式cv2.TM_CCOEFF_NORMED
                matchResult = cv2.matchTemplate(match_right, template_left, cv2.TM_CCOEFF_NORMED)
                # cv2.imwrite('2.jpg', matchResult)
                # 归一化处理
                cv2.normalize(matchResult, matchResult, 0, 1, cv2.NORM_MINMAX, -1)
                # 寻找矩阵（一维数组当做向量，用Mat定义）中的最大值和最小值的匹配结果及其位置
                min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(matchResult)
                # print(max_loc)
                # cv2.rectangle(imageRight, (max_loc[0], max_loc[1]), (width_left-left_width_begin + max_loc[0],  max_loc[1] + int(height_Left / 2)), (0, 0, 255),
                #               1)
                # plt.imsave('Right_rect.jpg', cv2.cvtColor(imageRight, cv2.COLOR_BGR2RGB))

                # 设置最终图片大小
                dstStitch = np.zeros((height_Left, width_Right + left_width_begin - max_loc[0], 3), imageLeft.dtype)
                dstStitch1 = np.zeros((height_Left, width_Right + left_width_begin - max_loc[0], 3), imageLeft1.dtype)
                height_dst, width_dst = dstStitch.shape[:2]

                # copy left image
                dstStitch[0:height_Left, 0:width_left] = imageLeft.copy()

                dstStitch1[0:height_Left, 0:width_left] = imageLeft.copy()

                # 匹配右图的高要能和目标区域一样
                matchRight_H = height_Right - max_loc[1] + left_height_begin

                if height_dst == matchRight_H:
                    matchRight = imageRight[int(max_loc[1] - left_height_begin): int(height_Right),
                                 int(max_loc[0]):int(width_Right)]
                    matchRight = matchRight[:, int(1000 * beishu):]

                    matchRight1 = imageRight1[int(max_loc[1] - left_height_begin): int(height_Right),
                                  int(max_loc[0]):int(width_Right)]
                    matchRight1 = matchRight1[:, int(1000 * beishu):]

                elif height_dst < matchRight_H:
                    dst_y_start = (left_height_begin - max_loc[1])
                    # 定义平移矩阵
                    M = np.float32([[1, 0, 0], [0, 1, dst_y_start]])  # 向上平移 dst_y_start个像素
                    # 应用平移矩阵
                    rows, cols, _ = imageRight.shape
                    matchRight = cv2.warpAffine(imageRight, M, (cols, rows))
                    matchRight = matchRight[0: height_Right, max_loc[0]:width_Right]
                    matchRight = matchRight[:, int(1000 * beishu):]

                    matchRight1 = cv2.warpAffine(imageRight1, M, (cols, rows))
                    matchRight1 = matchRight1[0: height_Right, max_loc[0]:width_Right]
                    matchRight1 = matchRight1[:, int(1000 * beishu):]
                else:
                    dst_y_start = (left_height_begin - max_loc[1])
                    # 定义平移矩阵
                    M = np.float32([[1, 0, 0], [0, 1, dst_y_start]])  # 向下平移 dst_y_start个像素
                    # 应用平移矩阵
                    rows, cols, _ = imageRight.shape
                    matchRight = cv2.warpAffine(imageRight, M, (cols, rows))
                    matchRight = matchRight[0: height_Right, max_loc[0]:width_Right]
                    matchRight = matchRight[:, int(1000 * beishu):]

                    matchRight1 = cv2.warpAffine(imageRight1, M, (cols, rows))
                    matchRight1 = matchRight1[0: height_Right, max_loc[0]:width_Right]
                    matchRight1 = matchRight1[:, int(1000 * beishu):]

                drawRightRect = imageRight.copy()
                drawRightRect1 = imageRight1.copy()

                h, w = template_left.shape[:2]
                cv2.rectangle(drawRightRect, (max_loc[0], max_loc[1]), (max_loc[0] + w, max_loc[1] + h), (0, 0, 255), 1)
                cv2.rectangle(drawRightRect1, (max_loc[0], max_loc[1]), (max_loc[0] + w, max_loc[1] + h), (0, 0, 255),
                              1)

                height_mr, width_mr = matchRight.shape[:2]
                dstStitch[0:height_dst,
                left_width_begin + int(1000 * beishu):width_mr + int(
                    1000 * beishu) + left_width_begin] = matchRight.copy()

                dstStitch1[0:height_dst,
                left_width_begin + int(1000 * beishu):width_mr + int(
                    1000 * beishu) + left_width_begin] = matchRight1.copy()
                result = dstStitch
                result1 = dstStitch1
        # file_name = f'E:/camera/pailei/{i}.jpg'  # 使用f-string创建不同的文件名
        # plt.imsave(file_name, cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
    if len(row_stitch_img) != 0:
        # file_name = f"{i}.jpg"
        dstStitch = cv2.rotate(dstStitch, cv2.ROTATE_90_CLOCKWISE)
        dstStitch1 = cv2.rotate(dstStitch1, cv2.ROTATE_90_CLOCKWISE)
        # # 进行水平镜像翻转
        # dstStitch = cv2.flip(dstStitch, 1)
        # dstStitch = cv2.flip(dstStitch, 0)

    if len(row_stitch_img) == 1:
        dstStitch = row_stitch_img[str(0)]
        dstStitch1 = row_stitch_img1[str(0)]
        # # 进行水平镜像翻转
        # dstStitch = cv2.flip(dstStitch, 1)
        # dstStitch = cv2.flip(dstStitch, 0)

    if len(row_stitch_img) == 1:
        dstStitch = row_stitch_img[str(0)]
        dstStitch = cv2.rotate(dstStitch, cv2.ROTATE_90_CLOCKWISE)

        dstStitch1 = row_stitch_img1[str(0)]
        dstStitch1 = cv2.rotate(dstStitch1, cv2.ROTATE_90_CLOCKWISE)
        # # 进行水平镜像翻转
        # dstStitch = cv2.flip(dstStitch, 1)
        # dstStitch = cv2.flip(dstStitch, 0)

    save_path = './/results//stitch//stitch.jpg'
    cv2.imwrite(save_path, dstStitch)
    cv2.imwrite("result.jpg",dstStitch)
    cv2.imwrite("result1.jpg",dstStitch1)

    return 1, os.path.abspath(save_path)


if __name__ == "__main__":
    input = glob.glob(r"A1A2A3_V1/UP/*.jpg")
    images_output = glob.glob(r"A1A2A3_V1/UP/*.jpg")
    stitch_start(input, images_output, 4)

天人合一peng
关注
专栏目录
大屏展示100个原型模板图，接入数据就能用
12-23
大屏展示中的可视化元素包括柱状图、折线图、饼图、地图、热力图等，每种图表都有其特定的适用场景和解读方式。 5. **交互性**：虽然大屏展示往往用于静态展示，但现代大屏设计通常也包含一定的交互功能。用户可以...
基于模板的图像拼接02
moonlightpeng的博客
05-01 330
之前的代码在计算模板位置后，高度方向上的值调整时不对。
基于模板的图形拼接多线程
最新发布
moonlightpeng的博客
06-28 170
【代码】基于模板的图形拼接多线程。
基于百度LBS的卫星图
05-06
6. **覆盖物与标注**：开发者可以向卫星图上添加自定义覆盖物，如图标、标记、热力图等，用于呈现特定数据或提供互动功能。例如，在房地产应用中，可以显示房源位置并附带详细信息。 7. **实时交通信息**：百度地图...
高德地图数据源（AutoNavi.rar）
02-25
5. **热力图**：通过颜色深浅表示数据密度，揭示高活动区域。 6. **信息窗口**：点击地图上的点或区域，显示相关详细信息。 7. **交互式查询**：用户可以通过选择地图上的元素来过滤或聚合其他数据。 总之，"高德...
《人工智能项目实习》 z作业 爬取链家网站中列出的兰州 并.形成热力图
02-16
4.形成热力图 （1）打开 http://lbsyun.baidu.com/进入百度地图开放平台，注册并登录账号（若 已申请百度账号，可直接登录），滚动至首页底部点击“申请秘钥”，注册称为 开发者（申请秘钥时，填写的应用名称为...
世界地图版块全景地图PPT模板.ppt
11-20
在全景地图PPT中，可能会用到柱状图、饼图、热力图等形式，以展示不同国家或地区的统计数据，如人口、GDP、资源分布等。通过有效的视觉设计，观众可以快速把握全球趋势和对比。 2. **地理信息系统（GIS）**：GIS...
basler工业相机使用经验小记
热门推荐
moonlightpeng的博客
05-22 2万+
1，windows10的系统，要用５以上的ｓｄｋ不然打不开相机。 ２，如果用ｏｐｅｎｃｖ或ｖｓ程序打开忘记没有关，则下次会找不开，这时可以通过禁用和启用调好。 如果打开后连不上，并且后找不到如上图所示的本地连接2，3，4，5的端口，则在设备管理器里设置一下，网络适配器选右键：扫描硬件设备，之后再看情况，如果出来了还是显示不能用则先禁用，再启用，可能会要求重启，重启电脑后就好了。 ...
Opencv官方文档和学习资料
moonlightpeng的博客
06-08 1万+
1 ， Opencv 3.0官方帮助文档。 2,OpenCV各版本官方文档。 https://docs.opencv.org/4.1.0/ https://docs.opencv.org/*.*.*/ 3，安装完opencv后里面自带很好的学习资料。 4opencv各版本链接及opencv_contrib库各版本链接 contrib库：https://github.com/op...
halcon13永久破解dll，亲测可用
moonlightpeng的博客
07-28 9743
下载地址： 链接：https://pan.baidu.com/s/1_CXRuXp6K07_fyAv9S8f2w 提取码：lb32
opencv 打开视频或摄像头并按格式保存图片，读取图片
moonlightpeng的博客
07-05 8287
#include &lt;opencv2/imgproc/imgproc.hpp&gt; #include &lt;opencv2/highgui/highgui.hpp&gt; #include &lt;opencv.hpp&gt; #include &lt;iostream&gt; #include &lt;stdio.h&gt; using namespace cv; using names...
opencv打开工业相机并保存视频
moonlightpeng的博客
05-14 6871
#include &lt;pylon\PylonIncludes.h&gt; #include &lt;pylon\PylonGUIIncludes.h&gt; #include &lt;opencv2/core/core.hpp&gt; #include &lt;opencv2/highgui/highgui.hpp&gt; using namespace Pylon; usi...
机器视觉表面缺陷检测综述
moonlightpeng的博客
10-28 6748
检测
halcon自带的案例学习
moonlightpeng的博客
07-28 6422
1 案例程序的位置 C:\Users\Public\Documents\MVTec\HALCON-13.0\examples 默认案例文件安装在C盘，实在找不到就 搜索以关键字 hdevelop 或 halcon 2 找到自带的简单使用说明文件 F:\Program Files\MVTec\HALCON-13.0\doc\pdf\solution_guide 3 打开对应C盘的examp...
opencv相机标定和计算外参四元数
moonlightpeng的博客
05-17 6278
#include "opencv2/core/core.hpp" #include "opencv2/imgproc/imgproc.hpp" #include "opencv2/calib3d/calib3d.hpp" #include "opencv2/highgui/highgui.hpp" #include &lt;cctype&gt; #include &lt;stdio.h&gt;
Opencv split函数 把图片分成rgb三通道
moonlightpeng的博客
05-08 5048
#include &lt;opencv2\opencv.hpp&gt; #include &lt;iostream&gt; using namespace std; using namespace cv; int main() { Mat image = imread("../composeTwo/1.jpg"); if (!image.data) { cout &lt;&lt; ...
C++ opencv imread读不进来图片
moonlightpeng的博客
05-01 3760
我问题是图片在工程目录下，或放其他在地方，用绝对或相对路径都加载不进来，都会疯了。 下面是我的"链接器"--》“输入”----》附加依赖项 运行错误，目录下有图片 按照网上说的把有d的放前面 仍然不行 尝试直接将release版的lib删除 再次运行OK 不知为什么Debug修改时Release也会变，两个是一样的，不应该是不同的吗》 不明白为什么 ...
python opencv 检测圆
moonlightpeng的博客
04-06 3610
放大 中心的三个没检测到 import cv2 import numpy as np import matplotlib.pyplot as plt w = 20 h = 5 params = cv2.SimpleBlobDetector_Params() # Setup SimpleBlobDetector parameters. print('params') print(params) print(type(params)) # Filter by Area. params...
如何通过小波变换实现热力图matlab代码
05-24
以下是一个通过小波变换实现热力图的 MATLAB 代码示例： ```matlab % 读取图像并转换成灰度图像 img = imread('example.jpg'...最后，将平均滤波后的低频、高频系数图像拼接在一起，并使用 `imagesc` 函数绘制热力图。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值