基于深度学习的传统图像增强方法

引言

很多时候，拍出来的照片总是不尽人意：环境光线暗了，图像发灰；曝光过了，细节又全部埋没在亮部里。说白了，就是对比度不够，主体不突出。图像增强要做的，就是通过一番处理，让图像里的人物或事物轮廓更清晰、视觉上更舒服，为后续的识别、分类等任务打好基础。传统的增强方法有不少经典路子，像直方图均衡、Gamma变换、拉普拉斯锐化、Retinex算法，各有各的脾气。当然，这几年深度学习也杀进这个领域了，思路跟传统方法不太一样。下面逐个来看，并附上Matlab的实现，直观感受一下效果差异。

1. 直方图均衡

直方图是啥？简单说，就是统计图像里每个灰度级上有多少个像素。如果大部分像素挤在灰度级的低端，那图像就偏暗；如果挤在高端，图像就偏亮。问题在于，两端挤得太厉害，中间的细节就被压缩了，谁也看不清。一个好办法是将原始灰度分布强制“拉平”——让每个灰度级上的像素数量差不多一样多，这样图像的动态范围就最大化了，亮部和暗部的细节都得以保留。这就是直方图均衡的核心思想。

变换关系可以用下面的公式描述：

Matlab实现不算复杂，核心就在两步：先统计原始直方图，再求出累计分布，最后用映射关系重写像素值。

function histogramEqual
    imgData=imread('../data/img0.jpg');
    gray=rgb2gray(imgData);
    imshow(gray);
    imwrite(gray, '../data/gray0.jpg');
    %calculate histogram
    histgramData=linspace(0, 0, 256);
    [grayRow, grayColumn]=size(gray);
    grayPixelNumber=grayRow*grayColumn;
    for i=1:grayRow
        for j=1:grayColumn
            histgramData(gray(i, j)+1)=histgramData(gray(i, j)+1)+1;
        end
    end
    %histogram equalization
    histogramIntegral=linspace(0, 0, 256);
    for i=1:256
        for j=1:i
            histogramIntegral(i)=histogramIntegral(i)+histgramData(j);
        end
    end
    for i=1:grayRow
        for j=1:grayColumn
            gray(i, j)=round(255*histogramIntegral(gray(i, j)+1)/grayPixelNumber);
        end
    end
    imshow(gray);
    imwrite(gray, '../output/histogramEqual.jpg');
end

处理结果如下：

图1.1 直方图均衡化结果（左）原图像（右）结果

2. Gamma变换

Gamma变换干的是另一件事：它通过一个简单的幂指函数，把过度集中到某一端（亮端或暗端）的灰阶拉开。公式很直接：对每个像素值做一次幂运算。

从gamma曲线的形状就能看出门道：当r大于1，它会拉伸高灰度区域（亮部），压缩低灰度区域（暗部）；当r小于1，则反过来，对暗部进行拉伸，亮部被压缩。通过调整r值，可以灵活地调整图像的对比度偏向。

图2.1 图像gamma变换

Matlab代码同样简单直接，核心就是对图像矩阵整体执行幂函数映射。

function imageGamma(r)
    imgData=imread('../data/img0.jpg');
    gray=rgb2gray(imgData);
    [grayRow, grayColumn]=size(gray);
    gray=double(gray);
    for i=1:grayRow
        for j=1:grayColumn
            gray(i, j)=255*((gray(i, j)/255)^r);
            gray(i, j)=round(gray(i, j));
        end
    end
    gray=uint8(gray);
    fileName='../output/gamma';
    fileSuf='.jpg';
    gammaStr=num2str(r);
    file=[fileName, gammaStr, fileSuf];
    imshow(gray);
    imwrite(gray, file);
end

出来的结果对比很明显：

图2.2 gamma变换（左）r=0.5（右）r=1.5

3. Laplace变换

有时候我们需要的不只是拉伸对比度，而是要把图像中物体的边缘“勾”出来，让细节更锐利、更突出。这时二阶微分算子就派上用场了，而Laplace算子是最经典的一个。它的定义是对图像进行二阶导数求和，本质上是一个同性滤波器——对各个方向的边缘都有相同的响应。

实际使用中，通常用一个小模板（比如3×3的邻域）来近似这个二阶微分，然后与原始图像相加，就能起到边缘增强的效果。具体公式为：g(x, y)=f(x, y)+c·∇²f(x, y)，其中c控制增强强度。

% g(x, y)=f(x, y)+c*delta2 f(x, y)
function laplace(c)
    imgData=imread('../data/img0.jpg');
    gray=rgb2gray(imgData);
    [grayRow, grayColumn]=size(gray);
    gray=double(gray);
    %laplace
    laplacePlate=[0, 1, 0; 1, -4, 1; 0, 1, 0];
    laplaceResult=zeros(grayRow, grayColumn);
    laplaceGray=zeros(grayRow, grayColumn);
    laplaceGray=double(laplaceGray);
    for i=1:grayRow
        for j=1:grayColumn
            for k=-1:1
                for n=-1:1
                    if (i+k>=1) && (i+k<=grayRow) && (j+n>=1) && (j+n<=grayColumn)
                        grayValue=gray(i+k, j+n);
                    else
                        grayValue=0;
                    end
                    laplaceResult(i, j)=laplaceResult(i, j)+laplacePlate(k+2, n+2)*grayValue;
                end
            end
            laplaceGray(i, j)=round(gray(i, j)+c*laplaceResult(i, j));
        end
    end
    maxLaplaceGray=max(max(laplaceGray));
    minLaplaceGray=min(min(laplaceGray));
    laplaceGray=((laplaceGray-minLaplaceGray) .* 255) ./(maxLaplaceGray-minLaplaceGray);
    laplaceGray=uint8(laplaceGray);
    fileName='../output/laplace';
    fileSuf='.jpg';
    gammaStr=num2str(c);
    file=[fileName, gammaStr, fileSuf];
    figure('name', 'gray');
    imshow(laplaceGray);
    figure('name', 'laplace');
    imshow(laplaceResult);
    imwrite(laplaceGray, file);
    imwrite(laplaceResult, '../output/laplaceResult.jpg');
end

结果示例如下：

图3.1 laplace算子增强（上左）laplace变换结果（上右）C=0.5（下）C=0.8

4. Retix算法

Retinex算法走的是仿生路子，它假设人眼看到的图像强度S(x, y)等于入射光L(x, y)乘以物体反射率R(x, y)：

算法要做的，就是想办法把入射光L给估计出来并去除，从而得到纯的反射分量R，后者才是物体的真实颜色和纹理信息。通常需要用高斯核去卷积图像来估计L，为降低运算量，这里采用了一个7x7的高斯模板。

function singleRetix(c)
    imgData=imread('../data/img0.jpg');
    gray=rgb2gray(imgData);
    [grayRow, grayColumn]=size(gray);
    gray=double(gray);
    gaussConv=zeros(grayRow, grayColumn);
    for i=1:grayRow
        for j=1:grayColumn
            for k=-3:3
                for n=-3:3
                    gaussValue=two_d_gauss(k, n, c);
                    if (i+k>=1) && (i+k<=grayRow) && (j+n>=1) && (j+n<=grayColumn)
                        grayValue=gray(i+k, j+n);
                    else
                        grayValue=0;
                    end
                    gaussConv(i, j)=gaussConv(i, j)+grayValue*gaussValue;
                end
            end
        end
    end
    gray=log(gray);
    gaussConv=log(gaussConv);
    reflectGray=exp(gray-gaussConv);
    maxReflectGray=max(max(reflectGray));
    minReflectGray=min(min(reflectGray));
    reflectGray=((reflectGray-minReflectGray) .* 255) ./ (maxReflectGray-minReflectGray);
    reflectGray=uint8(reflectGray);
    fileName='../output/retix';
    fileSuf='.jpg';
    gammaStr=num2str(c);
    file=[fileName, gammaStr, fileSuf];
    figure('name', 'processed');
    imshow(reflectGray);
    imwrite(reflectGray, file);
end

function res=two_d_gauss(x, y, c)
    res=(1/sqrt(2*pi*c))*(-(x^2+y^2)/c^2);
end

不同sigma值下的处理效果如下：

图4.1 Retix结果（左）sigma=90（右）sigma=150

5. 基于深度学习的图像增强

传统方法固然经典，但深度学习来了之后，玩法就变了。LL-NET是较早用深度学习来做低光图像增强的工作之一，它的思路很直接：用自动编码器从表示学习的角度去解决问题。网络经过大量低光/正常光图像的训练，学会理解低光图像中的基础信号特征，然后自动完成增亮和去噪。有意思的是，它还借鉴了SSDA网络的稀疏特性，有助于抑制噪声，提升泛化能力。简单说，喂给它一张低照度的测试图，它就能输出一张对比度正常、噪声很少的结果。

网络结构如下：

图5.1 LL-NET网络结构

结果如下：

图5.2 结果

结论

本文介绍了四种经典的图像增强算法——直方图均衡、Gamma变换、Laplace锐化、Retinex算法，同时也简单介绍了一种基于深度学习的低光增强方法。从实现上看，传统方法计算简单、效果可控，适合快速部署和对效率要求高的场景；深度学习方法则在复杂光照和噪声条件下表现更优，但要依赖大量数据和计算资源。

你是一名 AI 行业编辑，请围绕下面这条热点输出一份资讯解读：
热点：基于深度学习的传统图像增强方法要求：
1. 先用一句话解释这条热点在讲什么
2. 再总结它为什么重要
3. 说明会影响哪些 AI 产品或内容方向
4. 最后给出 3 个适合资讯站使用的标题