CLAHE算法的線性差值。

我們先來看一下沒有經(jīng)過線性差值的CLAHE算法是什么樣子的效果。

可以看到很明顯的圖片中都是一塊一塊的，這是因為在每一個塊里面都統(tǒng)計了相應(yīng)的直方圖數(shù)據(jù)，這樣就導(dǎo)致不同塊里面直方圖統(tǒng)計的映射表不一樣，所以就出現(xiàn)了一塊塊的斑點。

解決這個問題的方法就是線性插值。

可以將整幅圖像分為以下幾個部分：

整個8*8一共64個block，然后對于四個紅色的角點不進行線性插值，對于藍色的四條邊進行線性插值，對于中間的白色部分進行雙線性插值。

其中紅色正方形的邊長是block邊長的二分之一。

來放大一個局部看一下是怎樣進行計算的，比如將左上角放大得到一個3*3的block，以黑色實線來表示每一個block。然后用藍色虛線將每一個block的二分之一處進行連接，這樣將每一個block都分成了4*4的小塊。

最左上角的小塊不進行線性插值，相應(yīng)的代碼如下，判斷是不是在四個角點，如果是角點就直接進行直方圖均衡化。

if i <= bh // 2 and j <= bw // 2:
    he[i][j] = sk_list[0][img[i][j]]
elif i <= bh // 2 and j >= w - bw // 2:
    he[i][j] = sk_list[block - 1][img[i][j]]
elif i >= h - bh // 2 and j <= bw // 2:
    he[i][j] = sk_list[block * block - block][img[i][j]]
elif i >= h - bh // 2 and j >= w - bw // 2:
    he[i][j] = sk_list[block * block - 1][img[i][j]]

第一個位于藍色區(qū)域內(nèi)的點，他需要進行線性插值才能得到最終的結(jié)果。

可以看到這個點位于第一個block中，假定他距離第一個block中線的距離是P，那么第一個block占的權(quán)重就是1-P/block_width，在第二個block中占的權(quán)重就是P/block_width。假如這個點正好在第一個和第二個block的交界處，那么兩個block占的權(quán)重都是0.5。所以這個點的計算方法就是在第一個block中進行直方圖均衡化得到的結(jié)果乘以第一個block的權(quán)重，加上在第二個block中進行直方圖均衡化得到的結(jié)果乘以第二個block的權(quán)重。

比如下面的參考代碼，先計算這個點位于哪一個block，然后計算相應(yīng)的權(quán)重，最后分別進行直方圖均衡化后把結(jié)果相加。

num_j = (j - bw // 2) // bw
p?=?(j?-?num_j?*?bw?-?bw?//?2)?/?bw
q = 1 - p
he[i][j]?=?sk_list[num_j][img[i][j]]?*?q?+?sk_list[num_j?+?1][img[i][j]]?*?p

?

?

對于最后一種情況，也就是位于中間白色區(qū)域的點，他需要進行雙線性插值?？梢钥吹秸麄€點位于第四個block，所以他需要在第一個，第二個，第四個和第五個block上分別計算直方圖均衡化的結(jié)果，和相應(yīng)的權(quán)重，參考代碼如下：

num_i = (i - bh // 2) // bh
num_j = (j - bw // 2) // bw
m = (i - num_i * bh - bh // 2) / bh
v = 1 - m


p = (j - num_j * bw - bw // 2) / bw
q = 1 - p
he[i][j] = sk_list[num_i * block + num_j][img[i][j]] * q * v + 
               sk_list[(num_i * block) + block + num_j][


                img[i][j]] * q * m + sk_list[num_i * block + num_j + 1][img[i][j]] * p * v + 
                 sk_list[(num_i * block) + block + num_j + 1][img[i][j]] * p * m

對于verilog來說計算方法也是一樣的，通過不同的點來分別計算結(jié)果。

case (switch_ff[23])

            4'd0, 4'd1, 4'd2, 4'd3: begin
                cand_tx_pipe_1[0] <= cand_rd_data_1_ff[21];
                cand_tx_pipe_2[0] <= 28'd0;
                cand_tx_pipe_3[0] <= 28'd0;
                cand_tx_pipe_4[0] <= 28'd0;
            end
            4'd4, 4'd5: begin
                cand_tx_pipe_1[0] <= cand_rd_data_1_ff[21] * q_ff[2];
                cand_tx_pipe_2[0] <= cand_rd_data_2_ff[21] * p_ff[2];
                cand_tx_pipe_3[0] <= 28'd0;
                cand_tx_pipe_4[0] <= 28'd0;
            end
            4'd6, 4'd7: begin
                cand_tx_pipe_1[0] <= cand_rd_data_1_ff[21] * v_ff[2];
                cand_tx_pipe_2[0] <= cand_rd_data_2_ff[21] * m_ff[2];
                cand_tx_pipe_3[0] <= 28'd0;
                cand_tx_pipe_4[0] <= 28'd0;
            end
            4'd8: begin
                cand_tx_pipe_1[0] <= cand_rd_data_1_ff[21] * q_ff[2];
                cand_tx_pipe_2[0] <= cand_rd_data_2_ff[21] * q_ff[2];
                cand_tx_pipe_3[0] <= cand_rd_data_3_ff[21] * p_ff[2];
                cand_tx_pipe_4[0] <= cand_rd_data_4_ff[21] * p_ff[2];
            end
            default: begin
                cand_tx_pipe_1[0] <= 28'd0;
                cand_tx_pipe_2[0] <= 28'd0;
                cand_tx_pipe_3[0] <= 28'd0;
                cand_tx_pipe_4[0] <= 28'd0;
            end
endcase

這里使用了DSP自動推斷的方法，這些乘法都會被自動推斷為DSP。

在計算之前對數(shù)據(jù)進行了打拍的操作，一部分寄存器會被DSP單元所吸收，所以不用擔(dān)心這個乘法的時序問題。

always @(posedge clk ) begin
    cand_rd_data_1_ff[0] <= cand_rd_data_1;
    cand_rd_data_2_ff[0] <= cand_rd_data_2;
    cand_rd_data_3_ff[0] <= cand_rd_data_3;
    cand_rd_data_4_ff[0] <= cand_rd_data_4;
end
genvar b;
generate
    for (b = 1; b <= 22; b = b + 1) begin
        always @(posedge clk ) begin
            cand_rd_data_1_ff[b] <= cand_rd_data_1_ff[b - 1];
            cand_rd_data_2_ff[b] <= cand_rd_data_2_ff[b - 1];
            cand_rd_data_3_ff[b] <= cand_rd_data_3_ff[b - 1];
            cand_rd_data_4_ff[b] <= cand_rd_data_4_ff[b - 1];
        end        
    end
endgenerate

來看一下最后結(jié)果，沒有一塊一塊的斑點了。

CLAHE算法就是這些，一共分為下面幾步：

對整幅圖像進行分塊，然后在每一塊上面分別進行直方圖均衡化操作

在進行直方圖均衡化的時候進行CLIP操作

進行線性插值

審核編輯：黃飛

?