如何在MATLAB中用滑动窗口实现BSE算法及带条件中值滤波

Hey there! Let's break down how to get your BSE algorithm working correctly, building on the sliding window median logic you're already experimenting with. First, let's align on the core rules of your algorithm to make sure we're on the same page:

• Use an N×N centered sliding window (N should be odd to keep the target pixel in the middle)
• For each pixel:
  • If it’s an absolute extreme (0 or 255), replace it with the median value of its N×N neighborhood
  • If it’s a normal pixel, leave its value untouched
• Slide the window across the entire image to process every pixel

Issues in Your Current Code #

Looking at your existing code, there are a few key problems that will stop it from behaving as intended:

1. Redundant Median Overwrite: After your if/else block, you’re re-applying the median replacement to every pixel—this completely negates your conditional check for extreme values!
2. Unvalidated Window Size: Your code assumes sz is an odd number (since pad/2 needs to be an integer), but there’s no check for this. Passing an even sz will throw an error.
3. Hardcoded Channel Selection: You’re only processing the green channel, which limits the function to color images. It should handle grayscale inputs too.
4. Manual Padding Limitations: Your manual zero-padding can introduce edge artifacts; MATLAB’s built-in padding tools are more robust for edge cases.

Corrected BSE Algorithm Code #

Here’s a revised version that fixes these issues and strictly follows your BSE rules:

function [outimg] = bse_filter(img, sz)
    % Make sure window size is odd (required for centered window)
    if mod(sz, 2) == 0
        error('Window size sz must be an odd integer');
    end
    
    % Handle both grayscale and color images
    if size(img, 3) == 3
        % Process each color channel separately
        outimg = zeros(size(img), class(img));
        for chan = 1:3
            outimg(:,:,chan) = bse_single_channel(img(:,:,chan), sz);
        end
    else
        % Grayscale image processing
        outimg = bse_single_channel(img, sz);
    end
    
    % Optional: Display the filtered result
    imshow(outimg, []);
end

function [out_chan] = bse_single_channel(chan_img, sz)
    [rows, cols] = size(chan_img);
    pad_size = floor(sz/2); % Calculate padding for centered window
    
    % Use replicate padding to avoid edge artifacts (better than zero-padding)
    padded_img = padarray(chan_img, [pad_size pad_size], 'replicate');
    
    out_chan = zeros(rows, cols, class(chan_img));
    
    % Slide the window across every pixel in the original image
    for y = 1:rows
        for x = 1:cols
            current_val = chan_img(y, x);
            
            % Check if pixel is an extreme value
            if current_val == 0 || current_val == 255
                % Extract the N×N neighborhood from padded image
                window = padded_img(y:y+sz-1, x:x+sz-1);
                % Replace with median of the window
                out_chan(y, x) = median(window(:));
            else
                % Keep original pixel value
                out_chan(y, x) = current_val;
            end
        end
    end
end

Key Improvements Explained #

• Window Size Validation: The function now checks that sz is odd, preventing errors from invalid window shapes.
• Dual Image Type Support: Works seamlessly with both grayscale and color images by processing each color channel independently.
• Robust Padding: Uses padarray with 'replicate' mode to extend edge pixel values into the padding, avoiding unnatural artifacts at image borders.
• Fixed Conditional Logic: Median replacement only happens when the pixel is an extreme value—no more overwriting valid pixels.
• Class Preservation: The output image maintains the same data type as the input (e.g., uint8), which is important for proper image display.

How to Use This Function #

• For a grayscale image: filtered_img = bse_filter(gray_img, 5); (uses a 5×5 window)
• For a color image: filtered_img = bse_filter(rgb_img, 7); (uses a 7×7 window)

This implementation stays true to your BSE algorithm goals while fixing the gaps in your initial code. It also mirrors the core sliding window logic of MATLAB’s medfilt2—the only difference is we apply the median replacement conditionally, exactly as you described.

内容的提问来源于stack exchange，提问作者rmstringhini