Retinex去照度算法

Retinex理论

Retinex理论始于Land和McCann于20世纪60年代作出的一系列贡献,其基本思想是人感知到某点的颜色和亮度并不仅仅取决于该点进入人眼的绝对光线，还和其周围的颜色和亮度有关。Retinex这个词是由视网膜(Retina)和大脑皮层(Cortex)两个词组合构成的.Land之所以设计这个词，是为了表明他不清楚视觉系统的特性究竟取决于此两个生理结构中的哪一个，抑或是与两者都有关系。

Land的Retinex模型是建立在以下的基础之上的：

一、真实世界是无颜色的，我们所感知的颜色是光与物质的相互作用的结果。我们见到的水是无色的，但是水膜—肥皂膜却是显现五彩缤纷，那是薄膜表面光干涉的结果；

二、每一颜色区域由给定波长的红、绿、蓝三原色构成的；

三、三原色决定了每个单位区域的颜色。

Retinex 理论的基本内容是物体的颜色是由物体对长波（红）、中波（绿）和短波（蓝）光线的反射能力决定的，而不是由反射光强度的绝对值决定的；物体的色彩不受光照非均性的影响，具有一致性，即Retinex理论是以色感一致性（颜色恒常性）为基础的。如下图所示，观察者所看到的物体的图像S是由物体表面对入射光L反射得到的，反射率R由物体本身决定，不受入射光L变化。

图1.Retinex理论中图像的构成

Retinex理论的基本假设是原始图像S是光照图像L和反射率图像R的乘积,即可表示为下式的形式：

基于Retinex的图像增强的目的就是从原始图像S中估计出光照L，从而分解出R，消除光照不均的影响，以改善图像的视觉效果,正如人类视觉系统那样。在处理中，通常将图像转至对数域，即，从而将乘积关系转换为和的关系：

Retinex方法的核心就是估测照度L，从图像S中估测L分量，并去除L分量，得到原始反射分量R，即：

函数实现对照度L的估计（可以去这么理解，实际很多都是直接估计r分量）。

Retinex理论的理解

如果大家看论文，那么在接下去的篇幅当中，肯定会介绍两个经典的Retinex算法：基于路径的Retinex以及基于中心/环绕Retinex。在介绍两个经典的Retinex算法之前，我先来讲一点个人的理解，以便第一次接触该理论的朋友能够更快速地理解。当然，如果我的理解有问题，也请大家帮忙指出。

Retinex理论就我理解，与降噪类似，该理论的关键就是合理地假设了图像的构成。如果将观察者看到的图像看成是一幅带有乘性噪声的图像，那么入射光的分量就是一种乘性的，相对均匀，且变换缓慢的噪声。Retinex算法所做的就是合理地估计图像中各个位置的噪声，并除去它。

在极端情况下，我们大可以认为整幅图像中的分量都是均匀的，那么最简单的估计照度L的方式就是在将图像变换到对数域后对整幅图像求均值。因此，我设计了以下算法来验证自己的猜想，流程如下：

（1） 将图像变换到对数域 ；

（2） 归一化去除加性分量 ；

（3） 对步骤3得到的结果求指数，反变换到实数域。

这里为了简化描述，省略了对图像本身格式的变换，算法用Matlab实现：

% ImOriginal:原始图像
% type:‘add‘表示分量是加性的，如雾天图像；‘mult‘表示分量是乘性的，如对照度的估计
[m,n,z] = size(ImOriginal);
ImOut = uint8(zeros(m,n,z));
for i = 1:z
    if strcmp(type,‘add‘)
        ImChannel = double(ImOriginal(:,:,i))+eps;
    elseif strcmp(type,‘mult‘)
        ImChannel = log(double(ImOriginal(:,:,i))+eps);
    else
        error(‘type must be ‘‘add‘‘ or ‘‘mult‘‘‘);
    end
    ImOut(:,:,i) = EnhanceOneChannel(ImChannel);
end
ImOut = max(min(ImOut,255), 0);
end

function ImOut = EnhanceOneChannel(ImChannel)
% 计算计算单个通道的反射分量
% 1.对全图进行照射分量估计
% 2.减去照射分量
% 3.灰度拉伸
ImChannel = ImChannel./max(ImChannel(:));
ImRetinex = round(exp(ImChannel.*5.54));
ImOut = uint8(ImRetinex);
end

为了验证算法的有效性，这里使用经典的Retinex算法与我所用的算法进行对比试验，效果如下：

图2.测试原图

图3.经典Retinex算法结果

图4.上述方法结果

从对比中可以看到，对于去除照度，还原图像本身来讲，效果还可以，并且不会在边缘位置产生光晕现象。缺点就是在去除照度分量L过程中，保留的反射分量R我在上述算法中使用归一化后直接进行反变换。这一步的作用可以近似看成去除一个均匀的直流分量，即均匀的照度分量。由于操作都是全局的，这里默认假设了所有位置的照射分量都是相同的，因此在灰度拉伸的时候没有照顾到局部的特性，图像整体亮度偏暗。当然，全局的照度估计对于图像的增强肯定有相当的局限性，其增强效果在色彩的还原和亮度处理等方面还是有一定缺陷的。

个人认为，Retinex算法的关键还是正确的分析了噪声的性质。相信很多人都看到利用基于Retinex的图像水下增强、基于Retinex的图像去雾等等，我也好奇，那就试试吧。大雾图片嘛谁没有，前一阵子大雾天，没事拍了几张照片，终于用上了，请看对比图：

图5.有雾原图

图6.经典Retinex去雾效果

图7.上述方法去雾效果

还是老规矩，这时候对比试验还是最能说明效果的，为此选了一幅干扰很大的图像。基本上各位要是显示器比较差一点，从原图当中是很难看出大雾后面的东西。从去雾效果来看，上述方法的效果并不比经典算法要差，至少在去雾的效果上，本实验结果从主观上给人的感觉还是不错的。

在上述案例中，最重要的就是正确分析有雾图像的结构，与Retinex理论一开始的核心思想有区别的是，在针对这种加性的干扰时，经典的Retinex算法在处理过程中，其实仅仅是利用其估计加性的干扰分量；当然，抛开Retinex理论对照度、反射率对最终图像形成的核心思想（如图1），后续最重要的就是对这个加性的干扰的估计了。

对于有雾的图像，我们大可以看作透过一块磨砂玻璃去看一幅清晰的图像，这样大家就能很好理解为什么认为在这个案例中，将雾的干扰认为是一个加性的了。诸如后面两个经典的算法，所有的这类算法归根结底就是更好地利用原图像中的像素点去估计原始照度。从上面例程上可以看出，使用一个全局估计对局部的增强是比较差的，如果存在照度不均匀（雾的浓度不均匀），或者背景颜色亮度很高等情况时，处理结果会趋向恶劣，效果比较差。

当然，经典也不是完美，从图3中可以看到，经典的算法容易出现光晕效果（蓝色书本文字周围一圈白色），因此后续对于照度估计和去除光晕等问题又有很多基于Retinex理论的变体算法，这里暂不进行介绍。下面开始介绍两个经典的算法，查看Matlab代码下载点击：

http://www.cs.sfu.ca/~colour/publications/IST-2000/

McCann Retinex算法

McCann Retinex 算法是McCann和Frankle一起提出的一种Retinex算法，该算法是一种基于多重迭代策略的Retinex算法，单个点的像素值取决于一条特定路径的环绕的结果，经过多次迭代逼近理想值。通过比较螺旋式路径上的各像素点的灰度值来估计和去除图像的照度分量。

图8.McCann Retinex算法路径选择示意图

这个图是参照人家论文的，不过我准备像论文那样讲，因为太复杂了，不容易懂。从图中我们可以看到，算法沿着这个螺旋式的路径选取用于估计的点，并且越靠近预测的中心点选取的点数越多。这个从实际物理上也解释的通，靠的近的像素点与中心像素点的相关性肯定要要比远处的点要高。

该算法估测图像经过以下几个步骤：

1. 将原图像变换到对数域，彩色图像对各通道都进行对数变换；

2. 初始化常数图像矩阵，该矩阵作为进行迭代运算的初始值；

3. 计算路径，如上图8所示，这里令为路径上的点，从远到近排列；

4. 对路径上的像素点按照如下公式运算：

公式所表示的大致意思为：从远到近，中心点像素值减去路径上的像素值得到的差值的一半与前一时刻的估计值之间的和。最终，中心像素点的像素大致的形式为

其中表示中心位置最终的反射率估计，为常数值为转换后的图像中的最大值，在步骤2中被确定。从这里将按照Retinex理论进行分解，最终公式中可以看到，最终照度分量被去除了，而中心位置的反射率由路径上各点的反射率之间的差值进行估计，并且从轨迹上可以看到，靠的越近的在最终估计的时候所占比重越大。

就我个人理解，这类估计算法，实质是将中心位置和周围亮度之间的差异作为最终中心位置的反射率的估计。如果中心位置亮度本身高，那么最终的结果还是高亮度的；如果中心位置亮度低，那么中心与其它点的差肯定是负值，最终的结果就比较小，亮度就比较低。这就要求路径上的点需要能够很好地代表整幅图像的特性，如果图像本身很规则，那么可能中央与周围计算的结果无法估测该点像素本身的灰度特性，结果就与预期的可能不一样了。如下图9可以看到，算法实质是估计中心和周边的差值，因此图中原本黑色区域的图像由于与周边差别很小，因此呈现高亮度；而在小型的矩形周围随着距离的增大，差别渐渐变小，因此亮度逐渐升高，无法体现原本黑色像素点处原本的亮度特性。

图9.算法的测试图（来自Retinex in Matlab）

从原始算法中可以看到，还有一个重要的步骤，就是迭代。迭代的作用是尽可能保留中央周边差的分量，原本每次只保留中央周边差的一半（见步骤4中最后的除2的处理），迭代次数越多，保留的分量就越多，迭代n次保留的分量就是，这样局部的信息就更多，相当于降低动态范围的压缩。这样的操作可以使图像更加自然，但是会增加运算量，下图可以更加明显地看出迭代次数的影响：

图10.迭代次数的影响

为了方便各位自己研究，下面我给出该算法源码供大家参考：

function Retinex = retinex_frankle_mccann(L, nIterations)

% RETINEX_FRANKLE_McCANN:
%         Computes the raw Retinex output from an intensity image, based on the
%         original model described in:
%         Frankle, J. and McCann, J., "Method and Apparatus for Lightness Imaging"
%         US Patent #4,384,336, May 17, 1983
%
% INPUT:  L           - logarithmic single-channel intensity image to be processed
%         nIterations - number of Retinex iterations
%
% OUTPUT: Retinex     - raw Retinex output
%
% NOTES:  - The input image is assumed to be logarithmic and in the range [0..1]
%         - To obtain the retinex "sensation" prediction, a look-up-table needs to
%         be applied to the raw retinex output
%         - For colour images, apply the algorithm individually for each channel
%
% AUTHORS: Florian Ciurea, Brian Funt and John McCann.
%          Code developed at Simon Fraser University.
%
% For information about the code see: Brian Funt, Florian Ciurea, and John McCann
% "Retinex in Matlab," by Proceedings of the IS&T/SID Eighth Color Imaging
% Conference: Color Science, Systems and Applications, 2000, pp 112-121.
%
% paper available online at http://www.cs.sfu.ca/~colour/publications/IST-2000/
%
% Copyright 2000. Permission granted to use and copy the code for research and
% educational purposes only.  Sale of the code is not permitted. The code may be
% redistributed so long as the original source and authors are cited.

global RR IP OP NP Maximum
RR = L;
Maximum = max(L(:));                                 % maximum color value in the image
[nrows, ncols] = size(L);

shift = 2^(fix(log2(min(nrows, ncols)))-1);          % initial shift
OP = Maximum*ones(nrows, ncols);                     % initialize Old Product

while (abs(shift) >= 1)
   for i = 1:nIterations
      CompareWith(0, shift);                         % horizontal step
      CompareWith(shift, 0);                         % vertical step
   end
   shift = -shift/2;                                 % update the shift
end
Retinex = NP;

function CompareWith(s_row, s_col)
global RR IP OP NP Maximum
IP = OP;
if (s_row + s_col > 0)
   IP((s_row+1):end, (s_col+1):end) = OP(1:(end-s_row), 1:(end-s_col)) + ...
   RR((s_row+1):end, (s_col+1):end) - RR(1:(end-s_row), 1:(end-s_col));
else
   IP(1:(end+s_row), 1:(end+s_col)) = OP((1-s_row):end, (1-s_col):end) + ...
   RR(1:(end+s_row),1:(end+s_col)) - RR((1-s_row):end, (1-s_col):end);
end
IP(IP > Maximum) = Maximum;                          % The Reset operation
NP = (IP + OP)/2;                                    % average with the previous Old Product
OP = NP;                                             % get ready for the next comparison

McCann99 Retinex算法

McCann99 Retinex算法本质上与McCann Retinex算法没有区别，两者不同的就是在McCann99算法中，不再是使用螺旋式的路径来选取估计像素点，而是使用图像金字塔的方式逐层选取像素。算法同样经取点、比较、平均这几步进行迭代运算。

图像金字塔的概念很简单，就是对图像进行下采样，以多分辨率的形式表示图像。最顶层的图像分辨率最低，底层的最高（一般为原图）。

图11.图像金字塔示意图（来自网络）

如上图所示，McCann99算法就是从顶层开始让每一个像素点与其8个相邻的像素进行比较，估计反射率分量；前一层计算结束之后对估计的反射率分类进行插值运算，使上一层估计的结果的图像与金字塔下一层图像尺寸相同，并再一次进行相同的比较运算；最终，对原始图像进行8邻域的比较结束后就能得到最终的结果，即增强后的图像了。其中，比较操作与McCann算法相同，都是相减后求平均，见上一节步骤4中描述。

因此，McCann99算法，此处简化描述为以下几步：

1. 将原图像变换到对数域，彩色图像对各通道都进行对数变换；

2. 初始化（计算图像金字塔层数；初始化常数图像矩阵，该矩阵作为进行迭代运算的初始值）；

3. 从顶层开始，到最后一层进行8邻域比较运算，运算规则与MccCann Retinex算法相同，见上一节步骤4；

4. 第n层运算结束后对第n层的运算结果进行插值，变成原来的两倍，与n+1层大小相同（此处默认n越大越靠近底层）；

5. 当最底层计算完毕得到的即最终增强后的图像。

为了方便各位自己研究，下面我给出该算法源码供大家参考：

function Retinex = retinex_mccann99(L, nIterations)

global OPE RRE Maximum

[nrows ncols] = size(L);                             % get size of the input image

nLayers = ComputeLayers(nrows, ncols);               % compute the number of pyramid layers

nrows = nrows/(2^nLayers);                           % size of
image to process for layer 0

ncols = ncols/(2^nLayers);

if (nrows*ncols > 25)                                % not processing images of area > 25

error(‘invalid image size.‘)                      
% at first layer

end

Maximum = max(L(:));                                 % maximum color value in the image

OP = Maximum*ones([nrows ncols]);                    % initialize Old Product

for layer = 0:nLayers

RR = ImageDownResolution(L, 2^(nLayers-layer));   %
reduce input to required layer size

OPE = [zeros(nrows,1) OP zeros(nrows,1)];        
% pad OP with additional columns

OPE = [zeros(1,ncols+2); OPE;
zeros(1,ncols+2)];  % and rows

RRE = [RR(:,1) RR RR(:,end)];                     % pad RR
with additional columns

RRE = [RRE(1,:); RRE; RRE(end,:)];                % and rows

for iter = 1:nIterations

CompareWithNeighbor(-1, 0);                    
% North

CompareWithNeighbor(-1, 1);                    
% North-East

CompareWithNeighbor(0, 1);                     
% East

CompareWithNeighbor(1, 1);                     
% South-East

CompareWithNeighbor(1, 0);                     
% South

CompareWithNeighbor(1, -1);                    
% South-West

CompareWithNeighbor(0, -1);                    
% West

CompareWithNeighbor(-1, -1);                   
% North-West

end

NP = OPE(2:(end-1), 2:(end-1));

OP = NP(:, [fix(1:0.5:ncols) ncols]);            
%%% these two lines are equivalent with

OP = OP([fix(1:0.5:nrows) nrows], :);            
%%% OP = imresize(NP, 2) if using Image

nrows = 2*nrows; ncols = 2*ncols;                 % Processing
Toolbox in MATLAB

end

Retinex = NP;

function CompareWithNeighbor(dif_row, dif_col)

global OPE RRE Maximum

% Ratio-Product operation

IP = OPE(2+dif_row:(end-1+dif_row), 2+dif_col:(end-1+dif_col))
+ ...

RRE(2:(end-1),2:(end-1))
- RRE(2+dif_row:(end-1+dif_row), 2+dif_col:(end-1+dif_col));

IP(IP > Maximum) = Maximum;                          % The Reset step

% ignore the results obtained in the rows or columns for which the neighbors
are undefined

if (dif_col == -1) IP(:,1) = OPE(2:(end-1),2); end

if (dif_col == +1) IP(:,end) = OPE(2:(end-1),end-1); end

if (dif_row == -1) IP(1,:) = OPE(2, 2:(end-1)); end

if (dif_row == +1) IP(end,:) = OPE(end-1, 2:(end-1)); end

NP = (OPE(2:(end-1),2:(end-1))
+ IP)/2;              % The Averaging operation

OPE(2:(end-1), 2:(end-1))
= NP;

function Layers = ComputeLayers(nrows, ncols)

power = 2^fix(log2(gcd(nrows, ncols)));              %
start from the Greatest Common Divisor

while(power > 1 & ((rem(nrows, power) ~= 0) | (rem(ncols, power) ~= 0)))

power = power/2;                                  %
and find the greatest common divisor

end                                                  % that is a power of 2

Layers = log2(power);

function Result = ImageDownResolution(A, blocksize)

[rows, cols] = size(A);                              % the input matrix A is viewed as

result_rows = rows/blocksize;                        % a series of square blocks

result_cols = cols/blocksize;                        % of size = blocksize

Result = zeros([result_rows result_cols]);

for crt_row = 1:result_rows                          % then each pixel is computed as

for crt_col = 1:result_cols                       % the average of each such block

Result(crt_row, crt_col) = mean2(A(1+(crt_row-1)*blocksize:crt_row*blocksize,
...

1+(crt_col-1)*blocksize:crt_col*blocksize));

end

en

总结

在上述两个经典的估计算法之后经过反对数变换就可以恢复成原格式的图像。通过试验可以发现，这些算法都还是有一定缺陷的，对于照度的估计后续还有很多算法如：单尺度Retinex (SSR)、多尺度Retinex (MSR)、可变框架的Retinex等等；还有针对增强后的光晕现象先用进行照度分割，然后在再计算等等方法，本质上都大同小异。这些改进算法这里不再进行介绍，有兴趣的朋友可以去下载些论文看看。有不明白的或者本文有错误的地方也希望各位能够指出，以免误导后面的读者。

以上为参考的文章，代码如下：

主程序

clear all;

rgb = imread(‘2.jpg‘);%需要处理的图片

m=size(rgb,1);

n=size(rgb,2);

% 初始化矩阵

rr = zeros(m,n);

gg = zeros(m,n);

bb = zeros(m,n);

% eps的目的是防止分母出现0的时候产生正负无穷

% 如果反射率分量是乘性的，那需要变换到对数域

rr = log(double(rgb(:,:,1))+eps);

gg = log(double(rgb(:,:,2))+eps);

bb = log(double(rgb(:,:,3))+eps);

% 如果反射率分量是加性的，那只需要归一化就可以

% rr = double(rgb(:,:,1))+eps;

% gg = double(rgb(:,:,2))+eps;

% bb = double(rgb(:,:,3))+eps;

% 归一化

rr=rr/max(rr(:));

gg=gg/max(gg(:));

bb=bb/max(bb(:));

% Retinex算法

rrr = retinex_frankle_mccann(rr, 8);

ggg = retinex_frankle_mccann(gg, 8);

bbb = retinex_frankle_mccann(bb, 8);

% e^5.54约等于255，这里Retinex算法输出的是指数分量,每个像素亮度与该点计算结果x的关系为：I=255^x

rrr = round(exp(rrr.*5.54));

ggg = round(exp(ggg.*5.54));

bbb = round(exp(bbb.*5.54));

RGB = cat(3,uint8(rrr),uint8(ggg),uint8(bbb));

RGB = max(min(RGB,255),0);

subplot(2,2,1);imshow(rgb);title(‘原图像‘);

subplot(2,2,2),imhist(rgb2gray(rgb));title(‘原图像的直方图‘);

subplot(2,2,3);imshow(RGB);title(‘新图像‘);

subplot(2,2,4),imhist(rgb2gray(RGB));title(‘新图像的直方图‘);

调用函数：

function Retinex = retinex_frankle_mccann(L, nIterations)

% RETINEX_FRANKLE_McCANN:

%         Computes the raw Retinex output from an intensity image, based on the

%         original model described in:

%         Frankle, J. and McCann, J., "Method and Apparatus for Lightness Imaging"

%         US Patent #4,384,336, May 17, 1983

%

% INPUT:  L           - logarithmic single-channel intensity image to be processed

%         nIterations - number of Retinex iterations

%

% OUTPUT: Retinex     - raw Retinex output

%

% NOTES:  - The input image is assumed to be logarithmic and in the range [0..1]

%         - To obtain the retinex "sensation" prediction, a look-up-table needs to

%         be applied to the raw retinex output

%         - For colour images, apply the algorithm individually for each channel

%

% AUTHORS: Florian Ciurea, Brian Funt and John McCann.

%          Code developed at Simon Fraser University.

%

% For information about the code see: Brian Funt, Florian Ciurea, and John McCann

% "Retinex in Matlab," by Proceedings of the IS&T/SID Eighth Color Imaging

% Conference: Color Science, Systems and Applications, 2000, pp 112-121.

%

% paper available online at http://www.cs.sfu.ca/~colour/publications/IST-2000/

%

% Copyright 2000. Permission granted to use and copy the code for research and

% educational purposes only.  Sale of the code is not permitted. The code may be

% redistributed so long as the original source and authors are cited.

global RR IP OP NP Maximum

RR = L;

Maximum = max(L(:));                                 % maximum color value in the image

[nrows, ncols] = size(L);

shift = 2^(fix(log2(min(nrows, ncols)))-1);          % initial shift

OP = Maximum*ones(nrows, ncols);                     % initialize Old Product

while (abs(shift) >= 1)

for i = 1:nIterations

CompareWith(0, shift);                         % horizontal step

CompareWith(shift, 0);                         % vertical step

end

shift = -shift/2;                                 % update the shift

end

Retinex = NP;

function CompareWith(s_row, s_col)

global RR IP OP NP Maximum

IP = OP;

if (s_row + s_col > 0)

IP((s_row+1):end, (s_col+1):end) = OP(1:(end-s_row), 1:(end-s_col)) + ...

RR((s_row+1):end, (s_col+1):end) - RR(1:(end-s_row), 1:(end-s_col));

else

IP(1:(end+s_row), 1:(end+s_col)) = OP((1-s_row):end, (1-s_col):end) + ...

RR(1:(end+s_row),1:(end+s_col)) - RR((1-s_row):end, (1-s_col):end);

end

IP(IP > Maximum) = Maximum;                          % The Reset operation

NP = (IP + OP)/2;                                    % average with the previous Old Product

OP = NP;                                             % get ready for the next comparison

算法的主体思想是对照度的估计，mccan的算法思想是从外围的像素点作为估计初始值，不断的向内收敛，对当前估计值和选取点的像素值做平均后作为下一点的估计值。最终得到的估计值便是照度的估计值。

shift为距离中心的偏移，逐渐的向内收缩。

时间： 2024-12-10 13:32:02

Retinex去照度算法的相关文章

《Single Image Haze Removal Using Dark Channel Prior》一文中图像去雾算法的原理、实现、效果

本文完全转载:http://www.cnblogs.com/Imageshop/p/3281703.html,再次仅当学习交流使用.. <Single Image Haze Removal Using Dark Channel Prior>一文中图像去雾算法的原理.实现.效果(速度可实时) 本文算法合作联系QQ: 33184777, 非诚勿扰 邮件地址:   [email protected] 最新的效果见 :http://video.sina.com.cn/v/b/124538950-125

纯C++去雾算法

去雾算法 前言:经过不断的改进研究,该算法终于稳定,高效的问世了! 经过研究使该算法适应大雾环境,对该算法的内存优化,能够实时的高效的运行. 一.实时视频: 二.视频文件: 三.图片文件 追梦QQ:245656042 纯C++去雾算法,布布扣,bubuko.com

暗通道优先的图像去雾算法（下）

书接上文 http://blog.csdn.net/baimafujinji/article/details/27206237 我们已经了解了暗通道图像去雾算法的基本原理,下面我们来编程实现,然后对结果再做一些讨论. 上述代码中调用了几个函数,限于篇幅这里仅给出其中的暗通道处理函数,其余函数读者可以尝试自己写写看,当然其中最关键的就是暗通道处理函数,这也是算法的核心内容. 另外,代码里我们使用了导向滤波函数,导向滤波代码来自何恺明博士,读者可以访问他的网页获得源码,已经论文的原文,链接如下: h

高级图像去雾算法的快速实现（转载）

原文:http://blog.csdn.net/laviewpbt/article/details/11555877 最新的效果见 :http://video.sina.com.cn/v/b/124538950-1254492273.html 可处理视频的示例:视频去雾效果 在图像去雾这个领域,几乎没有人不知道<Single Image Haze Removal Using Dark Channel Prior>这篇文章,该文是2009年CVPR最佳论文.作者何凯明博士,2007年清华大学毕业

MATLAB图像处理_去雾算法

使用MATLAB进行图像的去雾操作,网上一搜,这方面的东西很多,貌似已然成为研究的一个方向,大牛辈出! 这里仅仅给出一个代码,能实现图像的去雾操作,详细的看后边有没有时间,想自己研究研究. function darktest(filename) %暗影去雾算法 %filename------文件名或文件绝对路径 %用法:darktest('7.png') close all clc w0=0.65; %0.65 乘积因子用来保留一些雾,1时完全去雾 t0=0.1; I=imread(filena

何恺明经典去雾算法

何恺明经典去雾算法 一:由简至美的最佳论文(作者:何恺明  视觉计算组) [视觉机器人:个人感觉学习他的经典算法固然很重要,但是他的解决问题的思路也是非常值得我们学习的] 那是2009年4月24日的早上,我收到了一封不同寻常的email.发信人是CVPR 2009的主席们,他们说我的文章获得了CVPR 2009的最佳论文奖(Best Paper Award).我反复阅读这封邮件以确认我没有理解错误.这真是一件令人难以置信的事情. 北京灰霾照片的去雾结果 CVPR的中文名是计算机视觉与模式识别会议

避免图像去雾算法中让天空部分出现过增强的一种简易方法。

在经典的几种去雾算法中,包括何凯明的暗通道去雾.Tarel的基于中值滤波的去雾以及一些基于其他边缘保留的方法中,都有一个普遍存在的问题:即对天空部分处理的不好,天空往往会出现较大的面积的纹理及分块现象.究其主要原因,还是因为天空部位基本上是不符合暗通道去雾先验这个前决条件的.目前,针对这一问题,我搜索到的主要有以下几篇文章进行了处理: 1. 改进的基于暗原色先验的图像去雾算法 作者: 蒋建国\侯天峰\齐美彬   合肥工业大学 2011. 2.Single image dehazing Algor

暗通道优先的图像去雾算法（上）

?? 11.1  暗通道优先的图像去雾算法 图像增强与图像修复二者之间有一定交叉,尽管它们一个强调客观标准,一个强调主观标准,但毕竟最终的结果都改善了图像的质量.图像去雾就是这两种技术彼此交叉领域中最典型的代表.如果将雾霾看作是一种噪声,那么去除雾霾的标准显然是非常客观的,也就是要将图像恢复至没有雾霾下所获取的情况.但是如果将在雾霾环境下拍摄的照片就看作是一种图像本来的面貌,那么去雾显然就是人们为了改善主观视觉质量而对图像所进行的一种增强.早期图像去雾的研究并没有得到应有的重视,很多人认为它的实

[论文复现]何恺明博士CVPR2009去雾算法(2)

一.前言 终于,简单实现了何博士论文去雾算法的基础部分.由于CVPR2009论文中的优化方法比较麻烦,速度比较慢,何博士于2010ECCV补充了一篇Guided Image Filtering优化求解速度,此处后面的优化我直接调用了何博士的函数. 主要参考文献: [1] He K, Jian S, Tang X. Single image haze removal using dark channel prior[C]// IEEE Conference on Computer Vision &