Matlab Process Images

Image Quality Assessment

Decision guidance for choosing and using image quality metrics: full-reference (PSNR, SSIM), no-reference (BRISQUE, NIQE, PIQE), and test chart measurements.

Often loaded with: filtering.md (measuring improvement after denoising/sharpening), deblurring.md (measuring restoration quality), registration.md (aligning a pair before any full-reference metric).

Choosing a Metric

Rule of thumb: Use ssim for full-reference comparisons. Use niqe when you have no reference image.

Full-Reference Metrics

Precondition: Pixel Correspondence

Every full-reference metric — psnr, ssim, immse, multissim — requires pixel correspondence: the two images must already be aligned pixel for pixel. Feed it a pair that is shifted, rotated, or scaled and you get a plausible "moderately degraded" score with no error and no warning, because the metric cannot tell misalignment from degradation.

I = im2gray(imread("peppers.png"));
shifted = imtranslate(I, [5 0]);      % 5-pixel shift, nothing else changed
[psnr(shifted, I) ssim(shifted, I)]   % 22.4730   0.7282  — reads as "degraded"

Those numbers look like ordinary noise or compression damage, but the images are identical — just misaligned. No denoising or sharpening will move the score.

If the pair may not be aligned, register first — see registration.md — then measure. To check alignment quickly, use imshowpair(A, B, "falsecolor") — misalignment appears as colored fringes rather than gray. Crops of the same scene at different offsets, frames from a handheld camera, and multi-sensor captures all need registration. Only use these metrics directly when one image is a known pixel-aligned processing result of the other.

psnr — Peak Signal-to-Noise Ratio

p = psnr(distorted, reference);  % Returns dB value

• Higher = better. Identical images → Inf

• Both inputs must match in class and range — mismatched types produce wrong peak values with no error

• Works with uint8, int16, uint16, or floating-point (auto-detects peak value)

• For RGB: computes overall PSNR across all channels

Limitation: PSNR correlates poorly with human perception — a high PSNR doesn't guarantee the image looks good.

ssim — Structural Similarity Index

[val, ssimMap] = ssim(distorted, reference);

• Range: typically [0, 1] (theoretically [-1, 1], but negatives are rare — only with anti-correlated structures). Value of 1 = identical. Typical good quality: > 0.95

• ssimMap shows per-pixel quality — useful for finding degraded regions

• For RGB: returns per-channel maps (size M×N×3)

• Decomposing components: Use Exponents=[1 0 0] etc. to isolate luminance/contrast/structural terms. To recombine, multiply the maps then average — do not multiply the scalar means (mean of products ≠ product of means).

% Visualize quality map
[~, smap] = ssim(distorted, reference);
imageshow(smap, DisplayRangeMode="data-range");  % Low values = degraded regions

immse — Mean Squared Error

err = immse(distorted, reference);  % Lower = better. 0 = identical

Both inputs must match in class and range — same rule as psnr and ssim.

multissim — Multi-Scale SSIM

ms = multissim(distorted, reference);

Range [0, 1], same interpretation as SSIM (1 = identical). Better than single-scale SSIM for images viewed at different distances/resolutions. Prefer over ssim when comparing images at multiple scales or when content may be viewed at varying zoom levels.

Comparing Multiple Algorithms

results = table();
for i = 1:numel(methods)
    processed = applyMethod(img, methods{i});
    results.Method(i) = methods(i);
    results.PSNR(i) = psnr(processed, reference);
    results.SSIM(i) = ssim(processed, reference);
end
sortrows(results, "SSIM", "descend")  % Rank by SSIM

No-Reference Metrics

These assess quality without a clean reference — essential for real-world images.

brisque — Blind/Referenceless Image Spatial Quality

score = brisque(img);  % Lower = better quality

• Typical scores: 0–20 (good), 20–40 (fair), 40–100 (poor)

• Trained on distorted images — detects common artifacts (blur, noise, compression)

• Accepts grayscale or RGB, uint8 or double

Domain warning: Default model is trained on natural photographs (LIVE IQA database). Scores are meaningless for medical, satellite, synthetic, or document images — use fitbrisque to train a domain-specific model (see Custom Domain Models below).

niqe — Natural Image Quality Evaluator

score = niqe(img);  % Lower = better (more "natural")

• Opinion-unaware: trained only on pristine natural images

• Good baseline when you don't know the distortion type

• Typical scores: 2–5 (good), 5–10 (fair), > 10 (poor)

• Accepts grayscale or RGB

Domain warning: Same limitation as brisque — trained on natural photos only. Use fitniqe for non-natural domains.

piqe — Perception-based Image Quality Evaluator

score = piqe(img);  % Lower = better

• Spatially adaptive — identifies high-activity blocks

• Good for images with localized distortion

• Typical scores: 0–20 (excellent), 21–35 (good), 36–50 (fair), 51–80 (poor), 81–100 (bad)

Comparing No-Reference Metrics

Custom Domain Models — fitbrisque / fitniqe

Default BRISQUE and NIQE models are trained on the LIVE IQA database of natural photographs only. PIQE is a purely algorithmic metric (no trained model), but its statistical assumptions are also calibrated for natural photographs. They produce meaningless scores for:

• Medical images (CT, MRI, ultrasound)

• Satellite / remote sensing imagery

• GAN-generated or synthetic content

• Document scans, text images

• Industrial inspection images

Solution: Train domain-specific models with fitbrisque or fitniqe.

fitbrisque — Train Custom BRISQUE Model

% Requires: labeled training set (images + DMOS scores)
% DMOS = Differential Mean Opinion Score — higher = more distortion
imds = imageDatastore("myDomainImages/");
scores = readmatrix("dmos_scores.csv");  % Numeric vector of DMOS values [0, 100]

model = fitbrisque(imds, scores);

% Use custom model
score = brisque(testImg, model);  % Lower = better

• Needs distorted images with human quality scores (higher DMOS = more distortion)

• Minimum ~100 images recommended for stable training

• Model captures domain-specific distortion characteristics

fitniqe — Train Custom NIQE Model

% Requires: pristine (high-quality) images from your domain only
imds = imageDatastore("myDomainPristine/");

model = fitniqe(imds);

% Use custom model
score = niqe(testImg, model);  % Lower = better

• Opinion-unaware: needs only pristine images (no scores)

• Learns statistical regularities of your specific domain

• Lower barrier than fitbrisque — no human labeling required

No fitpiqe

There is no fitpiqe function — PIQE cannot be retrained for custom domains. Use fitbrisque (if you have MOS/DMOS labels) or fitniqe (if you only have pristine examples).

When to Recommend Custom Models

Test Chart Measurements — esfrChart

For objective camera/lens quality evaluation using a physical test chart (Imatest eSFR):

% 1. Create chart object from captured image
chart = esfrChart(chartImage);

% 2. Measure specific properties
sharpnessTable = measureSharpness(chart);     % SFR (MTF) at slanted edges
noiseTable = measureNoise(chart);              % Signal-to-noise in gray patches
colorTable = measureColor(chart);              % Color accuracy (ΔE)
chromAbTable = measureChromaticAberration(chart);  % Lateral CA
illum = measureIlluminant(chart);              % Scene illuminant estimate

% 3. Visualize
plotSFR(sharpnessTable);  % Plot spatial frequency response curves

Chart styles: "Extended", "Enhanced", "WedgeExtended", "WedgeEnhanced"

Each measurement returns a table with per-ROI results. The chart has:

• 60 slanted edge ROIs (for sharpness and chromatic aberration)

• 20 gray ROIs (for noise)

• 16 color ROIs (for color accuracy)

Critical: Data Type Validation

The #1 silent failure in image quality metrics. Using double(img) instead of im2double(img) produces completely wrong results with no error or warning.

The Problem

ref = imread("pears.png");          % uint8, values 0–255

% WRONG — double() preserves raw values (0–255) but ssim/psnr assume [0,1]
wrong = double(ref);
psnr(wrong, wrong + 10)             % Returns -27.76 dB (nonsense)
ssim(wrong, wrong + 10)             % Returns 0.0006 (nonsense)

% CORRECT — im2double() rescales to [0,1]
correct = im2double(ref);
psnr(correct, correct + 10/255)     % Returns +20.38 dB (correct)
ssim(correct, correct + 10/255)     % Returns 0.6424 (correct)

Why It Happens

• psnr and ssim auto-detect peak value based on class:

  • uint8 → peak = 255

  • int16 → peak = 65535 (full range: 32767 − (−32768))

  • uint16 → peak = 65535

  • double/single → peak = 1.0 (assumes [0,1] range)

• double(img) keeps values as 0–255 but MATLAB now thinks peak is 1.0

• Result: MSE is enormous relative to assumed peak → garbage metrics

DynamicRange Workaround

If you must keep raw values, specify the peak explicitly:

p = psnr(imgA, imgB, 255);                          % Explicit peak
s = ssim(imgA, imgB, DynamicRange=255);               % Explicit range

Quick Checklist

Common Mistakes

Quick Reference: Score Interpretation

Copyright 2026 The MathWorks, Inc.