在做红外弱小目标检测时，大家普遍会遇到目标像素少、信噪比低、背景复杂等难题。为了在检测率与虚警率之间取得平衡，通常需要尝试多种算法并反复调节参数。下面这套 MATLAB 程序，将常用的小目标检测方法整合在一起，并集成了预处理、分割、评估和报告生成功能，拿来就能跑——非常适合进行算法对比实验，或快速验证想法。

程序功能说明

1. 主要特点

这套代码覆盖了完整的检测流程：

• 集成了5种主流弱小目标检测算法
• 包含完整的预处理与背景抑制步骤
• 支持多种分割阈值方法（Otsu、自适应、百分比）
• 自带性能评估指标和可视化模块
• 自动生成检测报告，方便记录和对比

从模拟数据生成到最终报告输出，一整套流程一站搞定，省去了大量重复编程的工作。

2. 包含的算法

• Top-Hat 滤波：经典的形态学方法，擅长增强小目标，但对结构元素大小敏感。
• 最大中值滤波：通过局部窗口最大值与中值的差异突出目标，对脉冲噪声有一定鲁棒性。
• 局部对比度方法（LCM）：基于人眼视觉特性，运用内外窗口对比度来定位目标。
• 改进的 LCM（ILCM）：在原始基础上加入了中心与周围最小值的对比度量，提升了抗干扰能力。
• 梯度加权方法：利用梯度幅值结合局部均值，适合边缘和纹理较清晰的场景。

3. 使用方法

将完整代码保存为 infrared_target_detection.m，直接在 MATLAB 中运行即可。默认情况下，程序会首先生成一个模拟红外图像，包含随机位置、大小和强度的弱小目标（3~8个）。随后依次执行背景抑制、五种算法检测、三种阈值分割，最后输出性能评估表格和检测报告。

如果想先跑一遍看看效果，完全不需要额外准备数据。运行结束后你会看到一系列对比图：原始图像、背景抑制结果、各算法的检测响应图，以及不同阈值方法下的分割标记结果。

4. 使用真实数据

要换成自己的红外图像也很简单，在代码中找到第13行（生成模拟图像那一行）：

% 原代码
img = generateSimulatedIRImage();

% 替换为：
img = imread('your_image.pgm');   % 读入原始图像
img = rgb2gray(img);              % 如果是彩色，转成灰度

注意，真实图像的灰度范围和目标特性可能与模拟数据不同，你可能需要微调后续的阈值参数。

5. 参数调整建议

几个关键参数的调整方向：

• 目标大小：Top-Hat 滤波中结构元素的大小（第148行附近）要与目标尺寸匹配，一般设为目标直径的1.5~2倍。
• 检测灵敏度：自适应阈值中的 'Sensitivity' 参数（第248行）默认0.6，调高会增加检测数量但也会提升虚警。
• 窗口大小：最大中值滤波和LCM算法中的窗口尺寸（第161行、第179行）应根据目标大小设定，窗口太小背景估计不准，太大则可能漏掉弱小目标。

没有一套参数能通吃所有场景，建议先用模拟数据调通流程，再针对实际数据微调。从经验来看，ILCM 和梯度加权方法在低信噪比下的稳定性普遍好于 Top-Hat 和原始 LCM。

%% ==============================================
% 红外弱小目标检测系统
% 功能：包含多种弱小目标检测算法
%% ==============================================
clear all; close all; clc;

%% 1. 读取并显示原始红外图像
% 您可以使用自己的红外图像，这里我们生成一个模拟的红外图像
disp('正在生成模拟红外图像...');
img = generateSimulatedIRImage();
original_img = img;

figure('Name', '原始红外图像', 'Position', [100, 100, 1200, 400]);
subplot(1,3,1);
imshow(original_img, []);
title('原始红外图像');
colorbar;

% 添加直方图均衡化增强显示
subplot(1,3,2);
img_enhanced = histeq(original_img);
imshow(img_enhanced, []);
title('直方图均衡化增强');
colorbar;

% 显示3D表面图
subplot(1,3,3);
[x, y] = meshgrid(1:size(original_img,2), 1:size(original_img,1));
surf(x, y, double(original_img), 'EdgeColor', 'none');
title('红外图像3D表面图');
xlabel('X轴'); ylabel('Y轴'); zlabel('强度');
colormap('hot');
view(-30, 60);

%% 2. 预处理 - 背景抑制
disp('正在进行背景抑制...');
background_suppressed = backgroundSuppression(original_img);

figure('Name', '背景抑制结果', 'Position', [100, 100, 1000, 400]);
subplot(1,2,1);
imshow(original_img, []);
title('原始图像');
subplot(1,2,2);
imshow(background_suppressed, []);
title('背景抑制后图像');
colorbar;

%% 3. 多种目标检测算法
disp('正在使用多种算法进行目标检测...');

% 3.1 Top-Hat滤波
tophat_result = topHatFilter(original_img);

% 3.2 最大中值滤波 (Max-Median)
maxmedian_result = maxMedianFilter(original_img);

% 3.3 局部对比度方法 (LCM)
lcm_result = localContrastMethod(original_img);

% 3.4 改进的局部对比度方法 (ILCM)
ilcm_result = improvedLCM(original_img);

% 3.5 基于梯度加权的方法
gradient_result = gradientWeightedMethod(original_img);

%% 4. 显示所有检测结果
figure('Name', '多种检测算法结果对比', 'Position', [50, 50, 1400, 800]);

% 原始图像
subplot(2,3,1);
imshow(original_img, []);
title('原始红外图像');
colorbar;

% Top-Hat滤波
subplot(2,3,2);
imshow(tophat_result, []);
title('Top-Hat滤波检测结果');
colorbar;

% 最大中值滤波
subplot(2,3,3);
imshow(maxmedian_result, []);
title('最大中值滤波检测结果');
colorbar;

% LCM方法
subplot(2,3,4);
imshow(lcm_result, []);
title('局部对比度方法(LCM)');
colorbar;

% ILCM方法
subplot(2,3,5);
imshow(ilcm_result, []);
title('改进的局部对比度方法(ILCM)');
colorbar;

% 梯度加权方法
subplot(2,3,6);
imshow(gradient_result, []);
title('梯度加权方法');
colorbar;

%% 5. 目标分割与标记
disp('正在进行目标分割与标记...');

threshold_methods = {'otsu', 'adaptive', 'percentile'};
segmentation_results = cell(1, length(threshold_methods));

figure('Name', '目标分割结果', 'Position', [100, 100, 1200, 400]);
for i = 1:length(threshold_methods)
    % 使用ILCM结果进行分割（效果较好）
    binary_mask = targetSegmentation(ilcm_result, threshold_methods{i});
    segmentation_results{i} = binary_mask;
    
    % 标记目标
    [labeled_img, num_targets] = labelTargets(binary_mask);
    
    % 显示结果
    subplot(1,3,i);
    imshow(label2rgb(labeled_img, 'jet', 'k', 'shuffle'));
    title(sprintf('%s阈值分割检测到%d个目标', ...
        upper(threshold_methods{i}), num_targets));
    
    % 在原图上标记
    figure_temp = figure('Visible', 'off');
    imshow(original_img, []);
    hold on;
    stats = regionprops(labeled_img, 'Centroid', 'BoundingBox');
    for j = 1:length(stats)
        centroid = stats(j).Centroid;
        plot(centroid(1), centroid(2), 'r*', 'MarkerSize', 15, 'LineWidth', 2);
        rectangle('Position', stats(j).BoundingBox, ...
            'EdgeColor', 'g', 'LineWidth', 2);
    end
    hold off;
    title(sprintf('原始图像上的目标标记 (%s阈值)', upper(threshold_methods{i})));
    
    % 保存图像
    frame = getframe(gcf);
    close(figure_temp);
    
    figure('Name', sprintf('目标标记结果-%s', upper(threshold_methods{i})), ...
        'Position', [100, 100, 800, 600]);
    imshow(frame.cdata);
    title(sprintf('检测到%d个弱小目标', num_targets));
end

%% 6. 性能评估
disp('正在评估检测性能...');

% 假设我们已知目标位置（这里使用模拟目标的真实位置）
[true_targets, ~] = generateSimulatedTargets(size(original_img));

% 评估不同方法
methods = {'Top-Hat', 'Max-Median', 'LCM', 'ILCM', 'Gradient'};
results = {tophat_result, maxmedian_result, lcm_result, ilcm_result, gradient_result};

figure('Name', '检测性能评估', 'Position', [100, 100, 1000, 600]);
for i = 1:length(methods)
    % 转换为二值图像进行评估
    binary_result = imbinarize(mat2gray(results{i}), 'adaptive');
    
    % 计算检测指标
    metrics = evaluateDetection(binary_result, true_targets);
    
    % 显示评估结果
    subplot(2,3,i);
    imshow(binary_result);
    title(sprintf('%s方法\n精确度: %.2f%%, 召回率: %.2f%%', ...
        methods{i}, metrics.precision*100, metrics.recall*100));
    
    fprintf('方法: %s\n', methods{i});
    fprintf('精确度: %.2f%%\n', metrics.precision*100);
    fprintf('召回率: %.2f%%\n', metrics.recall*100);
    fprintf('F1分数: %.2f%%\n', metrics.f1_score*100);
    fprintf('虚警率: %.2f%%\n', metrics.false_alarm_rate*100);
end

%% 7. 生成检测报告
generateDetectionReport(methods, metrics, num_targets);

disp('红外弱小目标检测完成！');

%% ==============================================
% 辅助函数定义
%% ==============================================

% 生成模拟红外图像
function img = generateSimulatedIRImage()
    % 创建背景（模拟天空或均匀背景）
    [rows, cols] = deal(256);
    background = 100 + 20 * randn(rows, cols);
    
    % 添加一些云层纹理
    [X, Y] = meshgrid(1:cols, 1:rows);
    cloud_pattern = 15 * sin(0.05*X + 0.1*Y) + 10 * cos(0.03*X + 0.07*Y);
    background = background + cloud_pattern;
    
    % 添加高斯噪声
    background = background + 5 * randn(rows, cols);
    
    % 添加弱小目标（小亮点）
    img = background;
    num_targets = randi([3, 8]); % 随机生成3-8个目标
    for i = 1:num_targets
        % 随机位置
        target_row = randi([20, rows-20]);
        target_col = randi([20, cols-20]);
        
        % 目标大小（小目标，3x3到5x5像素）
        target_size = randi([2, 3]);
        
        % 目标强度（比背景高）
        target_intensity = 80 + 40 * rand();
        
        % 创建高斯形状的目标
        [x, y] = meshgrid(-target_size:target_size, -target_size:target_size);
        gaussian_target = target_intensity * exp(-(x.^2 + y.^2)/(2*(target_size/2)^2));
        
        % 将目标添加到图像中
        r_start = max(1, target_row-target_size);
        r_end = min(rows, target_row+target_size);
        c_start = max(1, target_col-target_size);
        c_end = min(cols, target_col+target_size);
        
        target_r_start = target_size - (target_row - r_start) + 1;
        target_r_end = target_size + (r_end - target_row) + 1;
        target_c_start = target_size - (target_col - c_start) + 1;
        target_c_end = target_size + (c_end - target_col) + 1;
        
        img(r_start:r_end, c_start:c_end) = ...
            img(r_start:r_end, c_start:c_end) + ...
            gaussian_target(target_r_start:target_r_end, target_c_start:target_c_end);
    end
    
    % 转换为uint8
    img = uint8(mat2gray(img) * 255);
end

% 背景抑制函数
function suppressed_img = backgroundSuppression(img)
    % 使用引导滤波进行背景估计
    img_double = double(img);
    
    % 引导滤波（保边平滑）
    guided_bg = imguidedfilter(img);
    
    % 减去背景
    suppressed_img = img_double - double(guided_bg);
    
    % 增强对比度
    suppressed_img = suppressed_img - min(suppressed_img(:));
    suppressed_img = suppressed_img / max(suppressed_img(:)) * 255;
end

% Top-Hat滤波
function result = topHatFilter(img)
    % 使用形态学Top-Hat滤波增强小目标
    se = strel('disk', 3); % 结构元素大小根据目标大小调整
    result = imtophat(img, se);
end

% 最大中值滤波
function result = maxMedianFilter(img)
    img_double = double(img);
    [rows, cols] = size(img_double);
    result = zeros(rows, cols);
    
    % 定义窗口大小
    window_size = 5;
    half_win = floor(window_size/2);
    
    for i = 1+half_win:rows-half_win
        for j = 1+half_win:cols-half_win
            % 提取局部窗口
            local_window = img_double(i-half_win:i+half_win, j-half_win:j+half_win);
            
            % 计算中值
            median_val = median(local_window(:));
            
            % 计算最大值与中值的差
            max_val = max(local_window(:));
            result(i,j) = max_val - median_val;
        end
    end
end

% 局部对比度方法
function result = localContrastMethod(img)
    img_double = double(img);
    [rows, cols] = size(img_double);
    result = zeros(rows, cols);
    
    % 定义内窗口和外窗口大小
    inner_size = 3;
    outer_size = 9;
    half_outer = floor(outer_size/2);
    
    for i = 1+half_outer:rows-half_outer
        for j = 1+half_outer:cols-half_outer
            % 内窗口（目标区域）
            inner_region = img_double(i-1:i+1, j-1:j+1);
            
            % 外窗口（背景区域，排除内窗口）
            outer_region = img_double(i-half_outer:i+half_outer, j-half_outer:j+half_outer);
            outer_region(inner_size:inner_size+2, inner_size:inner_size+2) = NaN;
            
            % 计算局部对比度
            inner_mean = mean(inner_region(:));
            outer_mean = nanmean(outer_region(:));
            inner_max = max(inner_region(:));
            
            if outer_mean > 0
                result(i,j) = (inner_max - outer_mean) / outer_mean;
            else
                result(i,j) = 0;
            end
        end
    end
end

% 改进的局部对比度方法
function result = improvedLCM(img)
    img_double = double(img);
    [rows, cols] = size(img_double);
    result = zeros(rows, cols);
    
    window_size = 9;
    half_win = floor(window_size/2);
    
    for i = 1+half_win:rows-half_win
        for j = 1+half_win:cols-half_win
            % 提取窗口
            window = img_double(i-half_win:i+half_win, j-half_win:j+half_win);
            
            % 计算中心像素与周围像素的对比度
            center_val = window(half_win+1, half_win+1);
            surrounding = window;
            surrounding(half_win+1, half_win+1) = NaN;
            
            % 使用改进的对比度度量
            max_surround = nanmax(surrounding(:));
            min_surround = nanmin(surrounding(:));
            mean_surround = nanmean(surrounding(:));
            
            if mean_surround > 0
                contrast1 = (center_val - mean_surround) / mean_surround;
                contrast2 = (center_val - min_surround) / (max_surround - min_surround + eps);
                result(i,j) = contrast1 * contrast2;
            else
                result(i,j) = 0;
            end
        end
    end
end

% 梯度加权方法
function result = gradientWeightedMethod(img)
    % 计算梯度幅值
    [Gx, Gy] = imgradientxy(img);
    gradient_mag = sqrt(Gx.^2 + Gy.^2);
    
    % 归一化梯度
    gradient_norm = mat2gray(gradient_mag);
    
    % 局部均值
    mean_filter = fspecial('a verage', 5);
    local_mean = imfilter(double(img), mean_filter);
    
    % 梯度加权
    result = double(img) .* gradient_norm - local_mean;
    
    % 移除负值
    result(result < 0) = 0;
end

% 目标分割函数
function binary_mask = targetSegmentation(img, method)
    img_normalized = mat2gray(img);
    
    switch lower(method)
        case 'otsu'
            level = graythresh(img_normalized);
            binary_mask = imbinarize(img_normalized, level);
        case 'adaptive'
            binary_mask = imbinarize(img_normalized, 'adaptive', ...
                'Sensitivity', 0.6, 'ForegroundPolarity', 'bright');
        case 'percentile'
            % 使用百分比阈值
            sorted_vals = sort(img_normalized(:));
            percentile = 98; % 取前2%最亮的像素
            idx = round(length(sorted_vals) * percentile / 100);
            threshold = sorted_vals(idx);
            binary_mask = img_normalized > threshold;
        otherwise
            error('未知的阈值方法');
    end
    
    % 形态学操作去除小噪点
    binary_mask = bwareaopen(binary_mask, 3); % 移除小于3个像素的区域
    se = strel('disk', 1);
    binary_mask = imclose(binary_mask, se); % 连接相近的目标
end

% 标记目标函数
function [labeled_img, num_targets] = labelTargets(binary_mask)
    % 连通区域标记
    labeled_img = bwlabel(binary_mask);
    num_targets = max(labeled_img(:));
end

% 评估检测性能函数
function metrics = evaluateDetection(detected, ground_truth)
    % 计算真阳性、假阳性等
    true_positive = sum(detected(:) & ground_truth(:));
    false_positive = sum(detected(:) & ~ground_truth(:));
    false_negative = sum(~detected(:) & ground_truth(:));
    true_negative = sum(~detected(:) & ~ground_truth(:));
    
    % 计算各项指标
    if (true_positive + false_positive) > 0
        metrics.precision = true_positive / (true_positive + false_positive);
    else
        metrics.precision = 0;
    end
    if (true_positive + false_negative) > 0
        metrics.recall = true_positive / (true_positive + false_negative);
    else
        metrics.recall = 0;
    end
    if (metrics.precision + metrics.recall) > 0
        metrics.f1_score = 2 * metrics.precision * metrics.recall / ...
            (metrics.precision + metrics.recall);
    else
        metrics.f1_score = 0;
    end
    metrics.false_alarm_rate = false_positive / (false_positive + true_negative);
end

% 生成模拟目标真实位置
function [ground_truth, target_positions] = generateSimulatedTargets(img_size)
    % 这里简单生成一些目标位置
    rows = img_size(1);
    cols = img_size(2);
    ground_truth = false(rows, cols);
    
    % 生成一些随机目标位置
    num_targets = 5;
    target_positions = zeros(num_targets, 2);
    for i = 1:num_targets
        r = randi([20, rows-20]);
        c = randi([20, cols-20]);
        target_positions(i,:) = [r, c];
        % 在目标位置创建小区域
        ground_truth(r-1:r+1, c-1:c+1) = true;
    end
end

% 生成检测报告
function generateDetectionReport(methods, metrics, num_detected)
    fprintf('========== 检测报告 ==========\n');
    fprintf('检测时间: %s\n', datestr(now));
    fprintf('检测到的目标数量: %d\n', num_detected);
    fprintf('各方法性能对比:\n');
    fprintf('%-15s %-10s %-10s %-10s\n', '方法', '精确度', '召回率', 'F1分数');
    fprintf('--------------------------------------------\n');
    for i = 1:length(methods)
        fprintf('%-15s %-10.2f %-10.2f %-10.2f\n', ...
            methods{i}, metrics(i).precision, metrics(i).recall, metrics(i).f1_score);
    end
    fprintf('==========================================\n');
    
    % 保存报告到文件
    report_filename = sprintf('detection_report_%s.txt', datestr(now, 'yyyymmdd_HHMMSS'));
    fid = fopen(report_filename, 'w');
    if fid ~= -1
        fprintf(fid, '红外弱小目标检测报告\n');
        fprintf(fid, '生成时间: %s\n', datestr(now));
        fprintf(fid, '检测统计:\n');
        fprintf(fid, '总检测目标数: %d\n', num_detected);
        fclose(fid);
        fprintf('检测报告已保存到: %s\n', report_filename);
    end
end