Matlab Process Images

Filtering

Diagnostic decision guide for choosing and applying image filters: smoothing, denoising, sharpening, and edge-preserving operations. Start from the noise model or artifact, not the function name.

Often loaded with: preprocessing.md (contrast/normalization/type conversion), quality-assessment.md (measuring improvement), morphological-ops.md (post-filtering cleanup).

Routes to other references: color-aware filtering → color-processing.md; volumetric data → 3d-volume-processing.md; motion-blur restoration / deconvolution → deblurring.md; texture characterization → texture-transforms.md.

Diagnose Before Filtering

Before selecting a filter, characterize the input:

1. Storage class and range — integer inputs clip negative/overflow results silently (see Output Class and Clipping)

2. Noise/artifact type — drives filter selection (see table below)

3. Downstream task — segmentation needs edge-preserving; display needs visual smoothing; measurement needs bias-free

Noise/Artifact → Filter Selection

Choosing a Smoothing Method

Grayscale-Only Functions on RGB Images

medfilt2 and wiener2 error on RGB input. imdiffusefilt does not error but warns and treats the RGB image as a 3-D volume, diffusing across color channels — this is a different operation that produces plausible but incorrect results. Convert to a luminance-chrominance color space, filter the luminance channel only, and convert back — this avoids the color shifts that per-channel RGB filtering can introduce:

lab = rgb2lab(img);
lab(:,:,1) = medfilt2(lab(:,:,1), [5 5]);
img_filtered = lab2rgb(lab, OutputType="uint8");

See color-processing.md for color space conversion details.

Non-Local Means Denoising — imnlmfilt

Exploits self-similarity to denoise — preserves strong edges but can smooth textured regions and reduce fine detail. Best when the image has repeated structure that the algorithm can match across patches:

[denoised, estimatedDoS] = imnlmfilt(img);                          % Auto parameters; returns estimated DegreeOfSmoothing

% Tune relative to the auto estimate — avoids hardcoding a class-dependent value
lighter = imnlmfilt(img, DegreeOfSmoothing=0.75*estimatedDoS);      % Less smoothing
stronger = imnlmfilt(img, DegreeOfSmoothing=1.25*estimatedDoS);     % More smoothing

Key parameters:

• DegreeOfSmoothing — auto value is based on estimated noise standard deviation, not a universally optimal setting. The appropriate value depends on the input class and data range — do not hardcode a single number across different images. Increase for stronger denoising; decrease to preserve more detail

• SearchWindowSize — runtime scales linearly with search-window size. Default 21 is a good balance; reduce for speed on large images

When to prefer over other denoisers:

• Over medfilt2: when noise is not impulse (salt & pepper)

• Over imgaussfilt: when strong edges must be preserved

• Over imbilatfilt: when image has repeated structure the algorithm can exploit for patch matching

Limitations: preserves strong edges but smooths texture — MathWorks examples show grass texture and fine detail being visibly reduced. Runtime scales linearly with search-window area; has a minimum image size requirement. Always inspect results on a representative region before committing, consider imgaussfilt or imbilatfilt as alternatives.

Boundary Padding — Choose Before Filtering

Different functions have different padding defaults. Always decide intentionally:

Zero padding is not always wrong — the effect depends on the kernel (sign, sum), data values near the border, and output class. For smoothing kernels on typical images, zeros pull border values down, producing a visible dark band. For zero-sum kernels (derivatives) or data where zero is a plausible continuation, zero padding may be appropriate.

Padding options for imfilter:

h = fspecial("gaussian", 11, 2);
filtered = imfilter(img, h);              % Zero padding — may cause dark borders with smoothing kernels
filtered = imfilter(img, h, "replicate"); % Replicate padding — avoids border pull-down

imgaussfilt uses replicate padding by default, which is one reason it is preferred over fspecial+imfilter for Gaussian smoothing.

Explicit Padding — padarray

For custom convolution, DL preprocessing, or frequency-domain filtering, pad explicitly:

padded = padarray(img, [m n], "replicate");   % Replicate m rows, n cols on each side
padded = padarray(img, [m n], "symmetric");    % Mirror at borders
padded = padarray(img, [m n], "circular");     % Wrap around (periodic)
padded = padarray(img, [m n], 0);              % Zero-pad (any numeric scalar)
padded = padarray(img, [m n], "replicate", "pre");  % Pad only top/left

Default direction is "both" (pad before and after). Also accepts "pre" (top/left only) or "post" (bottom/right only). The padsize argument is [rows cols].

Output Class and Clipping

imfilter returns the same class as the input and performs double-precision accumulation internally before rounding and clipping to the output range. This matters for derivative and high-pass kernels:

% Sobel edge kernel — response is signed
h = fspecial("sobel");
edges_clipped = imfilter(uint8(img), h);            % WRONG — negatives clip to 0
edges = imfilter(im2single(img), h, "replicate");   % RIGHT — preserves sign
edges_display = uint8(edges * 128 + 128);            % Offset only for visualization

Rules:

• Derivative/high-pass kernels produce negative values — filter in floating point, then offset only for display

• Integer output rounds fractions and clips to [0, intmax] — decide whether clipping is wanted

• When combining filter responses (e.g., gradient magnitude), compute in float first, then convert at the end

Correlation vs Convolution

imfilter uses correlation by default, not convolution. For symmetric kernels this makes no difference. For asymmetric kernels (directional derivatives, motion blur):

% Correlation (default) — kernel applied as-is
result = imfilter(img, h);

% Convolution — kernel flipped before applying
result = imfilter(img, h, "conv");

• Most fspecial kernels are symmetric (correlation = convolution); the "motion" kernel is asymmetric — use "conv" if convolution semantics are needed

• Custom asymmetric kernels: decide whether you want correlation or convolution and specify explicitly

• Even-sized kernels have an anchor at floor((size(h)+1)/2) — for a 4-by-4 kernel this is (2,2)

Prefer Dedicated Functions Over fspecial + imfilter

fspecial is still useful for motion blur PSFs ("motion"), Laplacian ("laplacian"), and LoG ("log") kernels where no dedicated function exists.

Sharpening

sharpened = imsharpen(img, "Radius", 2, "Amount", 1.5, "Threshold", 0.1);

• Radius: size of blur for unsharp mask (default 1)

• Amount: strength of sharpening (default 0.8)

• Threshold: minimum contrast to sharpen — set this on noisy images to prevent noise amplification

Edge-Preserving Filters — When to Use Which

Benchmark on representative data and hardware before choosing between these — relative performance depends on image size, parameter values, and platform.

imdiffuseest — Parameter Estimation for Anisotropic Diffusion

Use imdiffuseest to estimate parameters rather than guessing:

[gradThresh, numIter] = imdiffuseest(img);
filtered = imdiffusefilt(img, GradientThreshold=gradThresh, NumberOfIterations=numIter);

imguidedfilter — Guidance Image Channel Rules

DegreeOfSmoothing is a variance threshold: neighborhoods with variance well below it get smoothed; those well above it are left mostly unchanged.

The guidance image G can differ from input A in number of channels:

locallapfilt — Parameters and Type Restriction

locallapfilt and localcontrast do NOT accept double. Convert first:

% WRONG — errors on double input
result = locallapfilt(im2double(img), 0.4, 0.5);

% CORRECT — use single
result = locallapfilt(im2single(img), 0.4, 0.5);

Parameters:

• sigma — amplitude threshold separating "edges" from "details" (larger = more treated as detail)

• alpha — < 1 enhances details, > 1 smooths details (1 = no change). This is the opposite of what you might expect

• beta — dynamic range compression/expansion (< 1 compresses, > 1 expands; default 1)

• NumIntensityLevels — speed/quality tradeoff; lower = faster but coarser approximation

• ColorMode — "luminance" (default) processes only brightness; "separate" processes each channel

Frequency-Domain Filtering

Use frequency-domain approaches when the requirement is naturally spectral (e.g., remove a periodic pattern) or when the spatial kernel is very large:

When frequency-domain makes sense:

• Removing periodic noise (banding, moiré) — design a notch filter in the frequency domain

• Very large filter kernels — FFT-based filtering can be faster than spatial convolution

• Custom frequency-selective operations not available as built-in spatial filters

Pitfalls:

• Sharp ideal cutoffs (brick-wall filters) cause ringing — use smooth transitions or windowed designs

• Direct FFT multiplication is circular convolution — pad the image to avoid wraparound artifacts

• Preserve phase unless you specifically want phase modification

• Frequency-sampling design can produce ripple; larger kernels reduce spatial extent but not height

For most denoising and smoothing tasks, spatial-domain filters are simpler and sufficient.

Designing 2-D FIR Filters

Three approaches, all producing a spatial-domain kernel for use with imfilter:

1. Frequency sampling (fsamp2) — specify the desired frequency response on a grid, get a kernel whose response passes through those points:

% Define desired response on an 11x11 frequency grid
Hd = zeros(11, 11);
Hd(4:8, 4:8) = 1;                        % Ideal low-pass in frequency domain
[f1, f2] = freqspace(11, "meshgrid");     % Normalized frequency grid [-1, 1]

% Design filter and inspect
h = fsamp2(Hd);
freqz2(h, [32 32]);                       % Visualize actual frequency response

% Apply
filtered = imfilter(img, h, "replicate");

Sharp transitions in Hd produce ripple in the spatial kernel. Increasing the grid size reduces the spatial extent of ripple but not its amplitude.

2. Windowed design (fwind1) — applies a 1-D window to reduce ripple from frequency sampling:

h = fwind1(Hd, hamming(11));              % Circularly symmetric window via Huang's method
h = fwind1(Hd, win1, win2);              % Separable window from two 1-D windows

3. Frequency transformation (ftrans2) — transforms a 1-D FIR filter into a 2-D filter using the McClellan transform. Requires firpm from Signal Processing Toolbox for optimal 1-D design:

b = firpm(10, [0 0.4 0.6 1], [1 1 0 0]);  % 1-D equiripple lowpass (Signal Processing Toolbox)
h = ftrans2(b);                             % 2-D filter via McClellan transform
filtered = imfilter(img, h, "replicate");

Inspecting Filter Frequency Response

Use freqz2 to visualize the actual frequency response of any 2-D FIR kernel:

freqz2(h, [64 64]);                        % Mesh plot of magnitude response
[H, fx, fy] = freqz2(h, [64 64]);          % Return response for custom analysis

Local Entropy Filtering — entropyfilt

entropyfilt computes local entropy in a sliding neighborhood — higher values indicate more complex local texture. Useful for segmenting textured regions from smooth backgrounds or as a feature for classification:

E = entropyfilt(img);              % Default 9×9 neighborhood
E = entropyfilt(img, true(15));    % Custom 15×15 neighborhood

% Segment textured vs smooth regions
mask = imbinarize(E);

• Input must be grayscale (2-D). For RGB, convert to grayscale first.

• Default neighborhood is 9×9 — increase for coarser texture discrimination, decrease for finer.

• Output is double regardless of input class — rescale or threshold as needed.

• For texture classification with multiple features, combine entropyfilt with stdfilt and rangefilt. See also texture-transforms.md for Gabor and GLCM alternatives.

Interpreting Filter Outputs — Not All Outputs Are Images

Some filtering operations produce feature representations, not enhanced images. The output is a measurement of local image structure, not a visually improved version of the input:

For Gabor filter response interpretation (magnitude, phase, normalization, real vs complex formulations), see the Gabor section in texture-transforms.md.

Choosing an Implementation

Prefer the simplest approach that covers the operation. Benchmark on representative data and hardware before making performance claims:

1. Dedicated function — imgaussfilt, medfilt2, imboxfilt, imsharpen, etc. (fewest gotchas, internally optimized)

2. imfilter with a designed kernel — for custom linear filters (specify padding explicitly)

3. ordfilt2 — for order-statistic / rank filters (generalized median)

4. Vectorized / blockproc — for non-overlapping tiled operations

5. nlfilter — arbitrary sliding-window function (per-pixel function call overhead — use only when no better option exists)

Neighborhood Processing

For custom sliding-window operations not covered by built-in filters:

% ordfilt2 — order-statistic filter (fast generalized median)
result = ordfilt2(img, 5, ones(3,3));  % 5th smallest in 3x3 = median

% blockproc — non-overlapping blocks (faster, for tiled operations)
fun = @(block_struct) std2(block_struct.data) * ones(size(block_struct.data));
result = blockproc(img, [32 32], fun);

% roifilt2 — filter only within a mask, leave the rest unchanged (grayscale)
% vertices of the mask polygon.
c = [222 272 300 270 221 194];
r = [21 21 75 121 121 75];
mask = roipoly(img,c,r);
h = fspecial("gaussian", 7, 2);
result = roifilt2(h, img, mask);              % Linear filter inside mask
result = roifilt2(img, mask, @(x) medfilt2(x));  % Custom function inside mask

% integralImage + integralBoxFilter — constant-time subregion summation
intImg = integralImage(img);               % Zero-padded on top and left
smoothed = integralBoxFilter(intImg, 11);  % Box filter via integral image

% nlfilter — arbitrary function on sliding neighborhood (slow, last resort)
result = nlfilter(img, [3 3], @(x) max(x(:)));

Common Mistakes

Copyright 2026 The MathWorks, Inc.