《Adaptive Local Tone Mapping Based on Retinex for High Dynamic Range Images  》的文章提出的主要內容時這對高動態影象的顯示問題，他結合傳統的Retinex技術提出了全域性自適應和區域性自適應的HDR實現過程，我也實現了整個的程式碼，但感覺前面的全域性適應方案特別對於低照度影象有著非常明顯的調節作用，因此，我重點談下整個。

直接應用原文的英文算了：

　Global adaptation takes place like an early stage of the human visual system [4]. The human visual system senses rightness as an approximate logarithmic function according o the Weber-Fechner law [5]. To globally compress the ynamic range of a HDR scene, we use the following function n (4) presented in [5].

　　用中文解釋下上面的公式，也是本文最重要的一個公式。

　 是全自適應輸出的結果，我們這裡就是需要得到他，表示輸入影象的luminance值（亮度值），表示輸入影象亮度值對的最大值，表示輸入亮度對數的平均值，如下式所示：

　　其中N表示畫素的總數，而δ一般是個很小的值，其作用主要是為了避免對純黑色畫素進行log計算時數值溢位，這個問題在影象處理時非常常見。

　　在log域進行計算，這個HDR演算法中基本是個定律了。 

　　直接應用原文的話，上述算式的主要作用是：

      The input world luminance values and the maximum luminance values are divided by the log-average luminance of he scene. This enables (4) to adapt to each scene. As the log-verage luminance converges to the high value, the function c

 　　特別注意的是 scenes of the low log-average luminance reboosted more than scenes with high values. 這句話，他的意思是說低照度的亮度部分比高照度的部分要能得到更大程度的提升，所以對於低照度圖，上述公式能起到很好的增強作用。而算式中使用了全域性的對數平均值，這就有了一定的自適應性。

　　我貼一段稍微修改了的作者共享的matlab程式碼作為本演算法的參考程式碼：

function outval = ALTM_Retinex(I)
II = im2double(I);
Ir=double(II(:,:,1)); Ig=double(II(:,:,2)); Ib=double(II(:,:,3));
% Global Adaptation
Lw = 0.299 * Ir + 0.587 * Ig + 0.114 * Ib;% input world luminance values
Lwmax = max(max(Lw));% the maximum luminance value
[m, n] = size(Lw);
Lwaver = exp(sum(sum(log(0.001 + Lw))) / (m * n));% log-average luminance
Lg = log(Lw / Lwaver + 1) / log(Lwmax / Lwaver + 1);
gain = Lg ./ Lw;
gain(find(Lw == 0)) = 0;
outval = cat(3, gain .* Ir, gain .* Ig, gain .* Ib);
figure;
imshow(outval)

改寫成python程式碼為：

#simple color balance
def simple_color_balance(input_img,out_img,s1,s2):
    h,w = input_img.shape[:2]
    sort_img = input_img.copy()
    one_dim_array = sort_img.flatten()#轉化為一維陣列
    sort_array = sorted(one_dim_array)#對一維陣列按升序排序

    per1 = int((h*w)*s1/100)
    minvalue = sort_array[per1]

    per2 = int((h*w)*s2/100)
    maxvalue = sort_array[(h*w)-1-per2]

    #實施簡單白平衡演算法
    if(maxvalue<=minvalue):
        for i in range(h):
            for j in range(w):
                out_img[i,j] = maxvalue
    else:
        scale = 255.0/(maxvalue-minvalue)
        for m in range(h):
            for n in range(w):
                if(input_img[m,n] < minvalue):
                    out_img[m,n] = 0
                elif(input_img[m,n] > maxvalue):
                    out_img[m, n] = 255
                else:
                    out_img[m, n] = scale*(input_img[m,n]-minvalue)#對映中間段的影象畫素

def ALTM(img):
    h,w = img.shape[:2]
    DouImg = array(img,dtype=float32)
    Lw = zeros(img.shape[:2],dtype = float32)
    log_Lw = zeros(img.shape[:2],dtype = float32)
    Img_out = zeros(img.shape,dtype=uint8)
    B = img[:,:,0]
    G = img[:,:,1]
    R = img[:,:,2]
    Dou_B = array(B, dtype=float32)
    Dou_G = array(G, dtype=float32)
    Dou_R = array(R, dtype=float32)


    Lw = 0.299*R+0.587*G+0.114*B

    Lwmax = Lw.max()
    log_Lw = log(0.001+Lw)
    Lw_sum = log_Lw.sum()
    Lwaver = exp(Lw_sum/(h*w))
    Lg = log(Lw/Lwaver+1)/log(Lwmax/Lwaver+1)

    #simple_color_balance(Lg, Lg, 2, 3)
    gain = Lg/Lw

    Dou_B = gain * Dou_B
    Dou_G = gain * Dou_G
    Dou_R = gain * Dou_R

##對於某些影象來說可能這個效果會好些
    simple_color_balance(Dou_B,Dou_B,2,3)
    simple_color_balance(Dou_G, Dou_G, 2, 3)
    simple_color_balance(Dou_R, Dou_R, 2, 3)


    DouImg = cv2.merge([Dou_B,Dou_G,Dou_R])
    Img_out=cv2.convertScaleAbs(DouImg)

    return Img_out

執行結果：

參考文獻：