拉普拉斯金字塔图像融合MATLAB仿真程序

ghie90902026-03-22 11:04

拉普拉斯金字塔图像融合是一种多尺度图像融合技术，通过将图像分解为不同频率的子带，在不同尺度上选择性地融合图像特征，最终实现高质量的融合效果。

matlab 复制代码 
%% 拉普拉斯金字塔图像融合
% 描述: 实现基于拉普拉斯金字塔的多尺度图像融合

%% 主程序入口
function laplacianPyramidFusionDemo()
    % 清空环境
    clear; close all; clc;
    
    % 参数设置
    params = struct();
    params.levels = 5;             % 金字塔层数
    params.fusionRule = 'weighted'; % 融合规则: 'max', 'min', 'average', 'weighted'
    params.weightFactor = 0.7;      % 加权融合时的权重因子
    params.showSteps = true;        % 显示中间步骤
    params.saveResults = true;      % 保存结果
    
    % 读取测试图像
    img1 = imread('apple.jpg');     % 苹果图像
    img2 = imread('orange.jpg');    % 橙子图像
    
    % 转换为灰度图像（如果原始图像是彩色的）
    if size(img1, 3) == 3
        img1_gray = rgb2gray(img1);
        img2_gray = rgb2gray(img2);
    else
        img1_gray = img1;
        img2_gray = img2;
    end
    
    % 调整图像大小一致
    [h, w] = size(img1_gray);
    img2_gray = imresize(img2_gray, [h, w]);
    
    % 执行图像融合
    [fusedImg, pyramid1, pyramid2, fusedPyramid] = laplacianPyramidFusion(...
        img1_gray, img2_gray, params);
    
    % 显示结果
    displayResults(img1_gray, img2_gray, fusedImg, pyramid1, pyramid2, fusedPyramid, params);
    
    % 保存结果
    if params.saveResults
        imwrite(fusedImg, 'fused_image.jpg');
        fprintf('融合结果已保存为 fused_image.jpg\n');
    end
end

%% 拉普拉斯金字塔图像融合核心函数
function [fusedImg, pyramid1, pyramid2, fusedPyramid] = laplacianPyramidFusion(img1, img2, params)
    % 参数解析
    levels = params.levels;
    fusionRule = params.fusionRule;
    weightFactor = params.weightFactor;
    
    % 构建高斯金字塔
    gaussianPyramid1 = buildGaussianPyramid(img1, levels);
    gaussianPyramid2 = buildGaussianPyramid(img2, levels);
    
    % 构建拉普拉斯金字塔
    laplacianPyramid1 = buildLaplacianPyramid(gaussianPyramid1);
    laplacianPyramid2 = buildLaplacianPyramid(gaussianPyramid2);
    
    % 融合拉普拉斯金字塔
    fusedPyramid = cell(1, levels);
    for i = 1:levels
        if i == levels % 最高层使用高斯金字塔
            if strcmp(fusionRule, 'weighted')
                fusedPyramid{i} = weightFactor * gaussianPyramid1{i} + ...
                                 (1-weightFactor) * gaussianPyramid2{i};
            else
                fusedPyramid{i} = fuseLayers(gaussianPyramid1{i}, gaussianPyramid2{i}, fusionRule);
            end
        else % 其他层使用拉普拉斯金字塔
            if strcmp(fusionRule, 'weighted')
                fusedPyramid{i} = weightFactor * laplacianPyramid1{i} + ...
                                 (1-weightFactor) * laplacianPyramid2{i};
            else
                fusedPyramid{i} = fuseLayers(laplacianPyramid1{i}, laplacianPyramid2{i}, fusionRule);
            end
        end
    end
    
    % 从融合金字塔重建图像
    fusedImg = reconstructFromPyramid(fusedPyramid);
    
    % 返回中间结果
    pyramid1 = laplacianPyramid1;
    pyramid2 = laplacianPyramid2;
end

%% 构建高斯金字塔
function pyramid = buildGaussianPyramid(img, levels)
    pyramid = cell(1, levels);
    pyramid{1} = im2double(img); % 第一层为原始图像
    
    for i = 2:levels
        % 高斯平滑
        smoothed = imgaussfilt(pyramid{i-1}, 1);
        
        % 下采样（尺寸减半）
        [h, w] = size(smoothed);
        pyramid{i} = imresize(smoothed, [floor(h/2), floor(w/2)]);
    end
end

%% 构建拉普拉斯金字塔
function pyramid = buildLaplacianPyramid(gaussianPyramid)
    levels = length(gaussianPyramid);
    pyramid = cell(1, levels);
    
    % 最高层直接复制高斯金字塔的最高层
    pyramid{levels} = gaussianPyramid{levels};
    
    % 构建其他层
    for i = levels-1:-1:1
        % 上采样低层图像
        expanded = imresize(gaussianPyramid{i+1}, size(gaussianPyramid{i}), 'bicubic');
        
        % 计算拉普拉斯层 = 当前高斯层 - 上采样的低层
        pyramid{i} = gaussianPyramid{i} - expanded;
    end
end

%% 融合金字塔层
function fusedLayer = fuseLayers(layer1, layer2, rule)
    switch lower(rule)
        case 'max'
            % 取绝对值较大的像素
            fusedLayer = max(abs(layer1), abs(layer2)) .* sign(layer1 + layer2);
            
        case 'min'
            % 取绝对值较小的像素
            fusedLayer = min(abs(layer1), abs(layer2)) .* sign(layer1 + layer2);
            
        case 'average'
            % 取平均值
            fusedLayer = (layer1 + layer2) / 2;
            
        otherwise
            error('未知的融合规则: %s', rule);
    end
end

%% 从金字塔重建图像
function img = reconstructFromPyramid(pyramid)
    levels = length(pyramid);
    img = pyramid{levels}; % 从最高层开始
    
    for i = levels-1:-1:1
        % 上采样当前图像
        upsampled = imresize(img, size(pyramid{i}), 'bicubic');
        
        % 加上拉普拉斯层
        img = upsampled + pyramid{i};
    end
    
    % 裁剪到有效范围
    img = max(min(img, 1), 0);
end

%% 显示结果
function displayResults(img1, img2, fusedImg, pyramid1, pyramid2, fusedPyramid, params)
    % 创建显示窗口
    fig = figure('Name', '拉普拉斯金字塔图像融合', 'NumberTitle', 'off', ...
        'Position', [50, 50, 1400, 800]);
    
    % 显示原始图像
    subplot(3, 4, 1); imshow(img1, []); title('图像1 (苹果)');
    subplot(3, 4, 2); imshow(img2, []); title('图像2 (橙子)');
    subplot(3, 4, 3); imshow(fusedImg, []); title('融合结果');
    
    % 显示差异图
    diff1 = imabsdiff(fusedImg, img1);
    diff2 = imabsdiff(fusedImg, img2);
    subplot(3, 4, 4); imshow(diff1, []); title('融合图与图像1差异');
    subplot(3, 4, 5); imshow(diff2, []); title('融合图与图像2差异');
    
    % 显示金字塔层（如果启用）
    if params.showSteps
        % 显示高斯金字塔
        subplot(3, 4, 6); imshow(pyramid1{end}, []); title('高斯金字塔顶层 (图像1)');
        subplot(3, 4, 7); imshow(pyramid2{end}, []); title('高斯金字塔顶层 (图像2)');
        
        % 显示拉普拉斯金字塔各层
        for i = 1:min(4, params.levels)
            subplot(3, 4, 8+i-1); 
            imshow(mat2gray(pyramid1{i})); 
            title(sprintf('拉普拉斯层%d (图像1)', i));
            
            subplot(3, 4, 12+i-1); 
            imshow(mat2gray(pyramid2{i})); 
            title(sprintf('拉普拉斯层%d (图像2)', i));
        end
        
        % 显示融合金字塔
        subplot(3, 4, 11); imshow(fusedPyramid{end}, []); title('融合金字塔顶层');
        for i = 1:min(3, params.levels-1)
            subplot(3, 4, 15+i-1); 
            imshow(mat2gray(fusedPyramid{i})); 
            title(sprintf('融合层%d', i));
        end
    end
    
    % 添加说明文本
    annotation(fig, 'textbox', [0.1, 0.01, 0.8, 0.05], 'String', ...
        sprintf('融合规则: %s | 金字塔层数: %d | 权重因子: %.1f', ...
        params.fusionRule, params.levels, params.weightFactor), ...
        'FitBoxToText', 'on', 'BackgroundColor', 'white', 'FontSize', 10);
end

%% 创建测试图像
function createTestImages()
    % 创建苹果图像
    apple = zeros(300, 300, 'uint8');
    [x, y] = meshgrid(1:300, 1:300);
    circle = (x-150).^2 + (y-150).^2 <= 100^2;
    apple(circle) = 200; % 红色部分
    stem = (x-150).^2 + (y-80).^2 <= 20^2;
    apple(stem) = 100;  % 棕色茎
    leaf = ((x-180).^2 + (y-100).^2 <= 30^2) & (y < 100);
    apple(leaf) = 50;   % 绿色叶子
    
    % 创建橙子图像
    orange = zeros(300, 300, 'uint8');
    circle = (x-150).^2 + (y-150).^2 <= 110^2;
    orange(circle) = 220; % 橙色部分
    highlight = ((x-120).^2 + (y-130).^2 <= 40^2) & ((x-120).^2 + (y-130).^2 > 20^2);
    orange(highlight) = 255; % 高光
    
    % 保存图像
    imwrite(apple, 'apple.jpg');
    imwrite(orange, 'orange.jpg');
    fprintf('测试图像已创建: apple.jpg 和 orange.jpg\n');
end

%% 高级融合规则示例：基于梯度的融合
function fusedLayer = gradientBasedFusion(layer1, layer2, img1, img2)
    % 计算梯度幅值
    [gx1, gy1] = gradient(layer1);
    [gx2, gy2] = gradient(layer2);
    gradMag1 = sqrt(gx1.^2 + gy1.^2);
    gradMag2 = sqrt(gx2.^2 + gy2.^2);
    
    % 选择梯度较大的区域
    mask = gradMag1 > gradMag2;
    fusedLayer = layer1 .* mask + layer2 .* (~mask);
end

%% 多焦点图像融合示例
function multifocusFusionDemo()
    % 创建测试图像（清晰前景+模糊背景）
    fg = imread('peppers.png');
    bg = imgaussfilt(fg, 5); % 模糊背景
    
    % 创建多焦点图像
    height = size(fg, 1);
    width = size(fg, 2);
    focusRegion = zeros(height, width);
    focusRegion(100:200, 100:200) = 1; % 中心区域聚焦
    
    img1 = fg .* focusRegion + bg .* (1-focusRegion);
    img2 = bg .* focusRegion + fg .* (1-focusRegion);
    
    % 融合参数
    params = struct();
    params.levels = 5;
    params.fusionRule = 'weighted';
    params.weightFactor = 0.5;
    params.showSteps = true;
    
    % 执行融合
    [fusedImg, ~, ~, ~] = laplacianPyramidFusion(img1, img2, params);
    
    % 显示结果
    figure('Name', '多焦点图像融合', 'NumberTitle', 'off');
    subplot(2,2,1); imshow(img1); title('图像1 (前景聚焦)');
    subplot(2,2,2); imshow(img2); title('图像2 (背景聚焦)');
    subplot(2,2,3); imshow(fusedImg); title('融合结果 (全清晰)');
    subplot(2,2,4); imshowpair(img1, img2, 'montage'); title('原始图像对比');
end

%% 红外与可见光图像融合示例
function infraredVisibleFusionDemo()
    % 读取红外和可见光图像
    irImg = imread('IR.jpg');       % 红外图像
    visImg = imread('VIS.jpg');     % 可见光图像
    
    % 转换为灰度
    if size(irImg, 3) == 3
        irImg = rgb2gray(irImg);
    end
    if size(visImg, 3) == 3
        visImg = rgb2gray(visImg);
    end
    
    % 调整大小一致
    [h, w] = size(irImg);
    visImg = imresize(visImg, [h, w]);
    
    % 融合参数
    params = struct();
    params.levels = 6;
    params.fusionRule = 'weighted';
    params.weightFactor = 0.6; % 更重视红外图像
    params.showSteps = true;
    
    % 执行融合
    [fusedImg, ~, ~, ~] = laplacianPyramidFusion(irImg, visImg, params);
    
    % 显示结果
    figure('Name', '红外与可见光图像融合', 'NumberTitle', 'off');
    subplot(2,2,1); imshow(irImg); title('红外图像');
    subplot(2,2,2); imshow(visImg); title('可见光图像');
    subplot(2,2,3); imshow(fusedImg); title('融合结果');
    subplot(2,2,4); imshowpair(irImg, visImg, 'blend'); title('图像叠加对比');
end

%% 运行演示
function runDemos()
    % 创建测试图像
    createTestImages();
    
    % 运行基本融合演示
    laplacianPyramidFusionDemo();
    
    % 运行多焦点融合演示
    multifocusFusionDemo();
    
    % 运行红外与可见光融合演示
    infraredVisibleFusionDemo();
end

程序功能说明

1. 核心算法模块

  • 高斯金字塔构建：使用高斯滤波和下采样创建多尺度表示
  • 拉普拉斯金字塔构建：通过高斯金字塔差分获得高频细节
  • 金字塔融合：在不同尺度上应用融合规则
  • 图像重建：从融合金字塔恢复最终图像

2. 融合规则实现

  • 最大值规则：保留两幅图像中绝对值较大的细节
  • 最小值规则：保留两幅图像中绝对值较小的细节
  • 平均值规则：取两幅图像的平均值
  • 加权融合：根据权重因子混合两幅图像

3. 可视化与分析

  • 原始图像与融合结果对比
  • 差异图显示融合效果
  • 金字塔各层可视化
  • 融合质量评估

4. 应用演示

  • 多焦点图像融合：结合不同焦平面的图像
  • 红外与可见光融合：结合热辐射与纹理信息
  • 医学图像融合：CT与MRI等多模态融合

关键技术实现

1. 高斯金字塔构建

matlab 复制代码 
function pyramid = buildGaussianPyramid(img, levels)
    pyramid = cell(1, levels);
    pyramid{1} = im2double(img); % 第一层为原始图像
    
    for i = 2:levels
        % 高斯平滑
        smoothed = imgaussfilt(pyramid{i-1}, 1);
        
        % 下采样（尺寸减半）
        [h, w] = size(smoothed);
        pyramid{i} = imresize(smoothed, [floor(h/2), floor(w/2)]);
    end
end

2. 拉普拉斯金字塔构建

matlab 复制代码 
function pyramid = buildLaplacianPyramid(gaussianPyramid)
    levels = length(gaussianPyramid);
    pyramid = cell(1, levels);
    
    % 最高层直接复制高斯金字塔的最高层
    pyramid{levels} = gaussianPyramid{levels};
    
    % 构建其他层
    for i = levels-1:-1:1
        % 上采样低层图像
        expanded = imresize(gaussianPyramid{i+1}, size(gaussianPyramid{i}), 'bicubic');
        
        % 计算拉普拉斯层 = 当前高斯层 - 上采样的低层
        pyramid{i} = gaussianPyramid{i} - expanded;
    end
end

3. 金字塔融合与重建

matlab 复制代码 
function [fusedImg, pyramid1, pyramid2, fusedPyramid] = laplacianPyramidFusion(img1, img2, params)
    % 构建高斯金字塔
    gaussianPyramid1 = buildGaussianPyramid(img1, params.levels);
    gaussianPyramid2 = buildGaussianPyramid(img2, params.levels);
    
    % 构建拉普拉斯金字塔
    laplacianPyramid1 = buildLaplacianPyramid(gaussianPyramid1);
    laplacianPyramid2 = buildLaplacianPyramid(gaussianPyramid2);
    
    % 融合金字塔
    fusedPyramid = cell(1, params.levels);
    for i = 1:params.levels
        if i == params.levels
            % 最高层使用高斯金字塔
            if strcmp(params.fusionRule, 'weighted')
                fusedPyramid{i} = params.weightFactor * gaussianPyramid1{i} + ...
                                 (1-params.weightFactor) * gaussianPyramid2{i};
            else
                fusedPyramid{i} = fuseLayers(gaussianPyramid1{i}, gaussianPyramid2{i}, params.fusionRule);
            end
        else
            % 其他层使用拉普拉斯金字塔
            if strcmp(params.fusionRule, 'weighted')
                fusedPyramid{i} = params.weightFactor * laplacianPyramid1{i} + ...
                                 (1-params.weightFactor) * laplacianPyramid2{i};
            else
                fusedPyramid{i} = fuseLayers(laplacianPyramid1{i}, laplacianPyramid2{i}, params.fusionRule);
            end
        end
    end
    
    % 重建图像
    fusedImg = reconstructFromPyramid(fusedPyramid);
end

算法原理与数学基础

1. 拉普拉斯金字塔表示

拉普拉斯金字塔 LiL_iLi由高斯金字塔 GiG_iGi推导而来：

Li=Gi−↑(Gi+1)L_i=G_i−↑(G_{i+1})Li=Gi−↑(Gi+1)

其中 ↑(⋅)↑(⋅)↑(⋅)表示上采样操作。

2. 图像融合公式

融合后的拉普拉斯金字塔 Fi由各层融合规则决定：

Fi=α⋅L1,i+(1−α)⋅L2,iF_i=α⋅L_{1,i}+(1−α)⋅L_{2,i}Fi=α⋅L1,i+(1−α)⋅L2,i

其中 ααα是权重因子。

3. 图像重建

从融合金字塔重建图像：

Ri=↑(Ri+1)+FiR_i=↑(R_{i+1})+F_iRi=↑(Ri+1)+Fi

从最高层 RN=FNR_N=F_NRN=FN开始迭代重建。

参考代码 拉普拉斯金字塔图像融合的具体Matlab仿真程序 www.youwenfan.com/contentcss/96534.html

使用说明

1. 基本使用

matlab 复制代码 
% 读取图像
img1 = imread('image1.jpg');
img2 = imread('image2.jpg');

% 设置参数
params = struct();
params.levels = 5;             % 金字塔层数
params.fusionRule = 'weighted'; % 融合规则
params.weightFactor = 0.6;      % 权重因子

% 执行融合
[fusedImg, ~, ~, ~] = laplacianPyramidFusion(img1, img2, params);

% 显示结果
imshow(fusedImg);

2. 参数调整指南

  • 金字塔层数：通常3-6层，图像越大层数越多
  • 融合规则 ：
    • max：保留更多细节（适合多焦点融合）
    • average：平衡融合（通用场景）
    • weighted：强调特定图像（红外融合）
  • 权重因子：0.5为均等融合，>0.5强调第一幅图像

3. 处理不同尺寸图像

matlab 复制代码 
% 调整图像大小一致
[h, w] = size(img1);
img2 = imresize(img2, [h, w]);

扩展功能与应用

1. 基于梯度的融合规则

matlab 复制代码 
function fusedLayer = gradientBasedFusion(layer1, layer2)
    % 计算梯度幅值
    [gx1, gy1] = gradient(layer1);
    [gx2, gy2] = gradient(layer2);
    gradMag1 = sqrt(gx1.^2 + gy1.^2);
    gradMag2 = sqrt(gx2.^2 + gy2.^2);
    
    % 选择梯度较大的区域
    mask = gradMag1 > gradMag2;
    fusedLayer = layer1 .* mask + layer2 .* (~mask);
end

2. 多波段图像融合

matlab 复制代码 
function fusedImg = multispectralFusion(msImg, panImg)
    % 多光谱与全色图像融合
    % msImg: 多光谱图像 (低分辨率)
    % panImg: 全色图像 (高分辨率)
    
    % 上采样多光谱图像
    msUp = imresize(msImg, size(panImg), 'bicubic');
    
    % 分解全色图像到多光谱空间
    panDecomp = decomposePanchromatic(panImg, size(msImg, 3));
    
    % 融合
    fused = cell(1, size(msImg, 3));
    for i = 1:size(msImg, 3)
        fused{i} = 0.5*msUp(:,:,i) + 0.5*panDecomp(:,:,i);
    end
    
    % 重建融合图像
    fusedImg = cat(3, fused{:});
end

3. 3D医学图像融合

matlab 复制代码 
function fusedVol = medicalImageFusion(ctVol, mriVol)
    % CT与MRI体积数据融合
    [h, w, d] = size(ctVol);
    fusedVol = zeros(h, w, d);
    
    for z = 1:d
        sliceCT = ctVol(:,:,z);
        sliceMRI = mriVol(:,:,z);
        
        % 应用拉普拉斯金字塔融合
        params = struct('levels', 4, 'fusionRule', 'weighted', 'weightFactor', 0.4);
        fusedSlice = laplacianPyramidFusion(sliceCT, sliceMRI, params);
        
        fusedVol(:,:,z) = fusedSlice;
    end
end

常见问题解决方案

  1. 融合结果出现伪影
    • 增加金字塔层数
    • 使用更精细的融合规则（如基于梯度）
    • 调整权重因子
  2. 处理大图像内存不足
    • 降低金字塔层数
    • 使用分块处理
    • 转换为单精度浮点
  3. 融合结果过暗或过亮
    • 调整权重因子
    • 应用直方图均衡化
    • 使用自适应融合规则
  4. 边缘模糊
    • 增加高频成分权重
    • 使用边缘保持滤波器
    • 在高层金字塔使用较小权重

实际应用建议

  1. 多传感器融合 ：
    • 红外与可见光融合（夜视系统）
    • SAR与光学图像融合（遥感）
    • CT与PET融合（医学诊断）
  2. 图像增强 ：
    • 多曝光融合（HDR成像）
    • 多焦点融合（显微镜图像）
    • 去雾与增强融合
  3. 计算机视觉 ：
    • 目标检测与识别
    • 图像分割
    • 三维重建
  4. 视频处理 ：
    • 多帧融合降噪
    • 视频稳定
    • 背景建模

总结

本程序实现了基于拉普拉斯金字塔的图像融合算法，通过多尺度分解和选择性融合，能够有效结合不同图像的互补信息。程序具有以下特点：

  1. 模块化设计：各功能模块分离，便于扩展和维护
  2. 多种融合规则：支持最大值、最小值、平均值和加权融合
  3. 可视化分析：提供丰富的可视化工具评估融合效果
  4. 应用导向：包含多焦点、红外与可见光等典型应用场景
相关推荐
GIS数据转换器2 小时前
洪水时空大数据分析与评估系统
大数据·人工智能·机器学习·数据挖掘·数据分析·无人机·宠物
rainbow7242442 小时前
企业AI学习体系选型与构建：内部培训、外部引进与实战项目的深度结合方案
大数据·人工智能
zhensherlock2 小时前
Protocol Launcher 系列：Trae AI 编辑器的深度集成
javascript·人工智能·vscode·ai·typescript·编辑器·ai编程
ghie90902 小时前
基于HHT与神经网络结合的故障诊断系统
人工智能·深度学习·神经网络
Zender Han2 小时前
从 0 到 1：如何设计与编写高质量 Skills（AI Agent 技能开发指南）
人工智能·ai
格林威2 小时前
C++ 工业视觉实战：Bayer 图转 RGB 的 3 种核心算法（邻域平均、双线性、OpenCV 源码级优化）
开发语言·c++·人工智能·opencv·算法·计算机视觉·工业相机
AY呀2 小时前
# 用 NestJS + LangChain + RxJS 打造可扩展的 AI 流式 Agent（含工具调用）
人工智能
Web3_Daisy2 小时前
Token 分红机制详解：实现逻辑、激励结构与风险分析
大数据·人工智能·物联网·web3·区块链
何政@2 小时前
通过python 快速完成ai 构建
人工智能·python·ai·大模型·love l
热门推荐
01GitHub 镜像站点02Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南03班级宠物园部署指南04小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）05OpenClaw 使用和管理 MCP 完全指南06UV安装并设置国内源07Labelme从安装到标注：零基础完整指南08“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）09OpenClaw Control UI安全上下文访问配置10围棋-html版本