Learning of image enhancement evaluation index -- structural similarity SSIM

SSIM(structural similarity index), Structural similarity , It's a measure of the similarity between two images . The index was first developed by the image and video Engineering Laboratory of the University of Texas at Austin (Laboratory for Image and Video Engineering) Put forward .SSIM Of the two images used , An uncompressed, undistorted image , The other is the distorted image .

As the realization of structural similarity theory , The structure similarity index defines the structure information as unique to brightness from the perspective of image composition 、 Contrast , Attributes that reflect the structure of objects in the scene , The distortion is modeled as brightness 、 A combination of three different factors of contrast and structure . The mean value is used as the estimation of brightness , The standard deviation is used as an estimate of contrast , Covariance as a measure of structural similarity .

The above is the explanation of Baidu Encyclopedia , There are also encyclopedias of corresponding formulas .

SSIM It belongs to the full reference image quality evaluation index . It's very embarrassing that at first I always took the reference image as the original .

Then a want to , Theoretically SSIM The closer it is to 1 The better i, But if you use the original low illumination image , No processing yes 1, The more processing, the lower , This is definitely wrong , I took a detailed look at the comments on people's official code .

Originally, this reference image refers to a picture that is considered perfect , It means doing image enhancement , We need a set of images in the database , A low illumination image that needs to be processed and a perfect normal image , Then we use the processed image and the perfect image to calculate .

The code and usage are shared with you , What if some beginners make a mistake .

function [mssim, ssim_map] = ssim(img1, img2, K, window, L)
if (nargin < 2 || nargin > 5)
   mssim = -Inf;
   ssim_map = -Inf;
   return;
end

if (size(img1) ~= size(img2))
   mssim = -Inf;
   ssim_map = -Inf;
   return;
end

[M N] = size(img1);

if (nargin == 2)
   if ((M < 11) || (N < 11))
	   mssim = -Inf;
	   ssim_map = -Inf;
      return
   end
   window = fspecial('gaussian', 11, 1.5);	%
   K(1) = 0.01;					% default settings
   K(2) = 0.03;					%
   L = 255;                                     %
end

if (nargin == 3)
   if ((M < 11) || (N < 11))
	   mssim = -Inf;
	   ssim_map = -Inf;
      return
   end
   window = fspecial('gaussian', 11, 1.5);
   L = 255;
   if (length(K) == 2)
      if (K(1) < 0 || K(2) < 0)
		   mssim = -Inf;
   		ssim_map = -Inf;
	   	return;
      end
   else
	   mssim = -Inf;
   	ssim_map = -Inf;
	   return;
   end
end

if (nargin == 4)
   [H W] = size(window);
   if ((H*W) < 4 || (H > M) || (W > N))
	   mssim = -Inf;
	   ssim_map = -Inf;
      return
   end
   L = 255;
   if (length(K) == 2)
      if (K(1) < 0 || K(2) < 0)
		   mssim = -Inf;
   		ssim_map = -Inf;
	   	return;
      end
   else
	   mssim = -Inf;
   	ssim_map = -Inf;
	   return;
   end
end

if (nargin == 5)
   [H W] = size(window);
   if ((H*W) < 4 || (H > M) || (W > N))
	   mssim = -Inf;
	   ssim_map = -Inf;
      return
   end
   if (length(K) == 2)
      if (K(1) < 0 || K(2) < 0)
		   mssim = -Inf;
   		ssim_map = -Inf;
	   	return;
      end
   else
	   mssim = -Inf;
   	ssim_map = -Inf;
	   return;
   end
end


img1 = double(img1);
img2 = double(img2);

% automatic downsampling
f = max(1,round(min(M,N)/256));
%downsampling by f
%use a simple low-pass filter 
if(f>1)
    lpf = ones(f,f);
    lpf = lpf/sum(lpf(:));
    img1 = imfilter(img1,lpf,'symmetric','same');
    img2 = imfilter(img2,lpf,'symmetric','same');

    img1 = img1(1:f:end,1:f:end);
    img2 = img2(1:f:end,1:f:end);
end

C1 = (K(1)*L)^2;
C2 = (K(2)*L)^2;
window = window/sum(sum(window));

mu1   = filter2(window, img1, 'valid');
mu2   = filter2(window, img2, 'valid');
mu1_sq = mu1.*mu1;
mu2_sq = mu2.*mu2;
mu1_mu2 = mu1.*mu2;
sigma1_sq = filter2(window, img1.*img1, 'valid') - mu1_sq;
sigma2_sq = filter2(window, img2.*img2, 'valid') - mu2_sq;
sigma12 = filter2(window, img1.*img2, 'valid') - mu1_mu2;

if (C1 > 0 && C2 > 0)
   ssim_map = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))./((mu1_sq + mu2_sq + C1).*(sigma1_sq + sigma2_sq + C2));
else
   numerator1 = 2*mu1_mu2 + C1;
   numerator2 = 2*sigma12 + C2;
	denominator1 = mu1_sq + mu2_sq + C1;
   denominator2 = sigma1_sq + sigma2_sq + C2;
   ssim_map = ones(size(mu1));
   index = (denominator1.*denominator2 > 0);
   ssim_map(index) = (numerator1(index).*numerator2(index))./(denominator1(index).*denominator2(index));
   index = (denominator1 ~= 0) & (denominator2 == 0);
   ssim_map(index) = numerator1(index)./denominator1(index);
end

mssim = mean2(ssim_map);

return

This is the calculation SSIM The subroutine of .

About its use , Just write the following code directly into the main program .

K = [0.05 0.05];
window = ones(8);
L = 100;
[mssim, ssim_map] = ssim(img1, img2, K, window, L);
mssim                       

The official annotation ：

input:(1) img1: The first image being compared 
      (2) img2: The second image being compared 
      (3) K:SSIM Constant in exponential formula . The default value is :K = [0.01 0.03]
      (4) window: Local statistics window . Default widnow Gauss , Given by the following formula 
          window = fspecial('gaussian ',11,1.5);
      (5) L: The dynamic range of the image . The default value is :L = 255

output:(1) mssim: Average between two images ssim Index value .
            If one of the images being compared is considered to be of perfect quality , that mssim It can be considered as another measure of image quality .
            If img1 = img2, be mssim = 1.
       (2) ssim_map: Test the image of ssim Index diagram .
           map The size of depends on the input image , The actual size depends on the window size and the down sampling factor .