基于FPGA自動白平衡算法的實現(xiàn)

1 白平衡介紹

對于白平衡基本概念的詳細介紹請查看文章《白平衡初探》，白平衡算法主要的作用是將偏暖或者偏冷的色調(diào)自動恢復(fù)到正常色調(diào)，是圖像看起來更加色彩飽滿正常。

如上圖所示，左1色溫偏冷，中間色溫正常，右一色溫偏暖。上圖比較直觀的展示了色溫的概念。偏冷的色溫會給人一種還冷的感覺，偏暖的色溫會給人一種溫暖的感覺。

2 白平衡算法以及matlab實現(xiàn)

1）原始的灰度世界算法

灰度世界算法（Gray World）是以灰度世界假設(shè)為基礎(chǔ)的，該假設(shè)認為對于一幅有著大量色彩變化的圖像， R、 G、 B 三個分量的平均值趨于同一個灰度K。一般有兩種方法來確定該灰度。

（1）直接給定為固定值， 取其各通道最大值的一半，即取為127或128；

（2）令 K = （Raver+Gaver+Baver）/3，其中Raver，Gaver，Baver分別表示紅、 綠、 藍三個通道的平均值。

算法的第二步是分別計算各通道的增益：

Kr=K/Raver;

Kg=K/Gaver;

Kb=K/Baver;

算法第三步為根據(jù)Von Kries 對角模型，對于圖像中的每個像素R、G、B，計算其結(jié)果值：

Rnew = R * Kr;

Gnew = G * Kg;

Bnew = B * Kb;

對于上式，計算中可能會存在溢出（》255，不會出現(xiàn)小于0的）現(xiàn)象，處理方式有兩種。

a、 直接將像素設(shè)置為255，這可能會造成圖像整體偏白。

b、 計算所有Rnew、Gnew、Bnew的最大值，然后利用該最大值將將計算后數(shù)據(jù)重新線性映射到［0，255］內(nèi)。實踐證明這種方式將會使圖像整體偏暗，建議采用第一種方案。

2）完美反射算法

原理：完美全反射理論perfect Reflector假設(shè)圖像上最亮點就是白點，并以此白點為參考對圖像進行自動白平衡，最亮點定義為R+G+B的最大值，具體編碼步驟如下：

（1）計算每個像素的RGB之和，并保存到一臨時內(nèi)存塊中。

（2）按R+G+B值的大小計算出其前10%或其他Ratio的白色參考點的的閾值T。

（3）遍歷圖像中的每個點，計算其中R+G+B值大于T的所有點的RGB分量的累積和的平均值。

（4）對每個點將像素量化到［0，255］之間。

3）動態(tài)閾值法

（1）。 把圖像w*h從RGB空間轉(zhuǎn)換到Y(jié)CrCb空間。

（2）。 選擇參考白色點：

a. 把圖像分成寬高比為4:3個塊（塊數(shù)可選）。

b. 對每個塊，分別計算Cr，Cb的平均值Mr，Mb。

c. 對每個塊，根據(jù)Mr，Mb，用下面公式分別計算Cr，Cb的方差Dr，Db。

d. 判定每個塊的近白區(qū)域（near-white region）。

判別表達式為：

設(shè)一個“參考白色點”的亮度矩陣RL，大小為w*h。

若符合判別式，則作為“參考白色點”，并把該點（i，j）的亮度（Y分量）值賦給RL（i，j）；

若不符合，則該點的RL（i，j）值為0。

（3）。 選取參考“參考白色點”中最大的10%的亮度（Y分量）值，并選取其中的最小值Lu_min.

（4）。 調(diào)整RL，若RL（i，j）《Lu_min， RL（i，j）=0; 否則，RL（i，j）=1；

（5）。 分別把R，G，B與RL相乘，得到R2，G2，B2。 分別計算R2，G2，B2的平均值，Rav，Gav，Bav；

（6）。 得到調(diào)整增益：

Ymax=double（max（max（Y）））/5;

Rgain=Ymax/Rav;

Ggain=Ymax/Gav;

Bgain=Ymax/Bav;

（7）。 調(diào)整原圖像：

Ro= R*Rgain;

Go= G*Ggain;

Bo= B*Bgain;

FPGA的實現(xiàn)采用灰度世界算法。

Matlab代碼：

close allclear allclcI=imread（‘test1.jpg’）;［H，W，L］=size（I）;%得到圖像長寬高Rsum = 0;Gsum = 0;Bsum = 0;Rsum = double（Rsum）;Gsum = double（Gsum）;Bsum = double（Bsum）;for i = 1 ： H for j = 1 ：W Rsum = Rsum + double（I（i，j，1））; Gsum = Gsum + double（I（i，j，2））; Bsum = Bsum + double（I（i，j，3））; endendRaver = Rsum / （H*W）;Gaver = Gsum / （H*W）;Baver = Bsum / （H*W）;%K=128;%第一種K取值方法K = （Raver+Gaver+Baver）/3;%第二種方法Rgain = K / Raver;Ggain = K / Gaver;Bgain = K / Baver;Iwb（：，：，1） = I（：，：，1） * Rgain;Iwb（：，：，2） = I（：，：，2） * Ggain;Iwb（：，：，3） = I（：，：，3） * Bgain;imwrite（Iwb，‘Result1.jpg’）;figure（1），subplot（121），imshow（I），title（‘原始圖像’）;subplot（122），imshow（Iwb），title（‘自動白平衡圖像’）;

效果展示：

3 FPGA實現(xiàn)自動白平衡灰度世界法

灰度世界法Verilog代碼：

/**********************************copyright@FPGA OPEN SOURCE STUDIO微信公眾號：FPGA開源工作室Algorithm:Auto White balance Gray World 800X600X255=480000***********************************/`define XLEN 32`define N（n） ［（n）-1:0］module White_balance#（ parameter DW = 24 ）（ input pixelclk， input reset_n， input ［DW-1:0］ din， //rgb in input i_hsync， input i_vsync， input i_de，

output ［DW-1:0］ dout， //gray out output o_hsync， output o_vsync， output o_de ）; localparam STAGE_LIST = 32‘h0101_0101;//32’b00000000_00000000_00000000_00000000;localparam divisor = 32‘h0007_5300;//800*600localparam divisorK = 32’h0000_0003;//800*600 wire ［7:0］ R，G，B;reg ［27:0］ sumr，sumg，sumb;reg ［27:0］ sumr_r，sumg_r，sumb_r;wire ［9:0］ Kave;wire ［7:0］ K;

wire Rack;wire `N（`XLEN） Rquo，Rrem;

wire Gack;wire `N（`XLEN） Gquo，Grem;

wire Back;wire `N（`XLEN） Bquo，Brem;

wire Kack;wire `N（`XLEN） Kquo，Krem;

wire GRack;wire `N（`XLEN） GRquo，GRrem;

wire GGack;wire `N（`XLEN） GGquo，GGrem;

wire GBack;wire `N（`XLEN） GBquo，GBrem;

reg ［39:0］ R_r，G_r，B_r;wire ［7:0］ RO，GO，BO;

reg hsync_r1;reg vsync_r1;reg de_r1;

reg i_vsync_r;reg vsync_neg_r;

wire vsync_neg=（i_vsync_r&（~i_vsync））;

assign Kave=（Rquo+Gquo+Bquo）;assign K=Kquo［7:0］;

assign R=din［23:16］;assign G=din［15:8］;assign B=din［7:0］;

assign o_hsync = hsync_r1;assign o_vsync = vsync_r1;assign o_de = de_r1;

assign RO=（R_r［18:10］》255）？255:R_r［17:10］;assign GO=（G_r［18:10］》255）？255:G_r［17:10］;assign BO=（B_r［18:10］》255）？255:B_r［17:10］;assign dout={RO，GO，BO};

//synchronizationalways @（posedge pixelclk） begin hsync_r1 《= i_hsync; vsync_r1 《= i_vsync; de_r1 《= i_de;end

always @（posedge pixelclk or negedge reset_n）begin if（！reset_n）begin sumr《=28‘d0;《 span=“”》 sumg《=28’d0;《 span=“”》 sumb《=28‘d0;《 span=“”》 sumr_r《=28’d0;《 span=“”》 sumg_r《=28‘d0;《 span=“”》 sumb_r《=28’d0;《 span=“”》 i_vsync_r《=1‘b0;《 span=“”》 vsync_neg_r《=1’b0;《 span=“”》 R_r《=40‘b0;《 span=“”》 G_r《=40’b0;《 span=“”》 B_r《=40‘b0;《 span=“”》 end else begin i_vsync_r《=i_vsync;《 span=“”》 vsync_neg_r《=vsync_neg;《 span=“”》 R_r《=r*grquo;《 span=“”》 G_r《=g*ggquo;《 span=“”》 B_r《=b*gbquo;《 span=“”》 if（vsync_neg==1’b1） begin sumr_r《=sumr;《 span=“”》 sumg_r《=sumg;《 span=“”》 sumb_r《=sumb;《 span=“”》 end if（i_vsync==1‘b1） begin if（i_de==1’b1） begin sumr《=sumr+r;《 span=“”》 sumg《=sumg+g;《 span=“”》 sumb《=sumb+b;《 span=“”》 end else begin sumr《=sumr;《 span=“”》 sumg《=sumg;《 span=“”》 sumb《=sumb;《 span=“”》 end end else begin sumr《=28‘d0;《 span=“”》 sumg《=28’d0;《 span=“”》 sumb《=28‘d0;《 span=“”》 end endend

//Rave divfunc #（ .XLEN （ `XLEN ）， .STAGE_LIST （ STAGE_LIST ）

） i_divR （ .clk （ pixelclk ）， .rst （ ~reset_n ）， .a （ {4’b0，sumr_r} ）， .b （ divisor ）， .vld （ vsync_neg_r ）， .quo （ Rquo ）， .rem （ Rrem ）， .ack （ Rack ）

）;

//Gave divfunc #（ .XLEN （ `XLEN ）， .STAGE_LIST （ STAGE_LIST ）

） i_divG （ .clk （ pixelclk ）， .rst （ ~reset_n ）， .a （ {4‘b0，sumg_r} ）， .b （ divisor ）， .vld （ vsync_neg_r ）， .quo （ Gquo ）， .rem （ Grem ）， .ack （ Gack ）

）;

//Bave divfunc #（ .XLEN （ `XLEN ）， .STAGE_LIST （ STAGE_LIST ）

） i_divB （ .clk （ pixelclk ）， .rst （ ~reset_n ）， .a （ {4’b0，sumb_r} ）， .b （ divisor ）， .vld （ vsync_neg_r ）， .quo （ Bquo ）， .rem （ Brem ）， .ack （ Back ）

）;

//Kdivfunc #（ .XLEN （ `XLEN ）， .STAGE_LIST （ STAGE_LIST ）

） i_divK （ .clk （ pixelclk ）， .rst （ ~reset_n ）， .a （ {22‘b0，Kave} ）， .b （ divisorK ）， .vld （ Back ）， .quo （ Kquo ）， .rem （ Krem ）， .ack （ Kack ）

）;

//RGaindivfunc #（ .XLEN （ `XLEN ）， .STAGE_LIST （ STAGE_LIST ）

） i_divGR （ .clk （ pixelclk ）， .rst （ ~reset_n ）， .a （ {14’b0，K，10‘b0} ）， .b （ Rquo ）， .vld （ Kack ）， .quo （ GRquo ）， .rem （ GRrem ）， .ack （ GRack ）

）;

//GGaindivfunc #（ .XLEN （ `XLEN ）， .STAGE_LIST （ STAGE_LIST ）

） i_divGG （ .clk （ pixelclk ）， .rst （ ~reset_n ）， .a （ {14’b0，K，10‘b0} ）， .b （ Gquo ）， .vld （ Kack ）， .quo （ GGquo ）， .rem （ GGrem ）， .ack （ GGack ）

）;

//BGAINdivfunc #（ .XLEN （ `XLEN ）， .STAGE_LIST （ STAGE_LIST ）

） i_divGB （ .clk （ pixelclk ）， .rst （ ~reset_n ）， .a （ {14’b0，K，10‘b0} ）， .b （ Bquo ）， .vld （ Kack ）， .quo （ GBquo ）， .rem （ GBrem ）， .ack （ GBack ）

）;

endmodule

1）仿真效果

原始圖像

經(jīng)過灰度世界法的白平衡仿真效果

2）下板驗證模型以及實現(xiàn)效果

下板驗證圖像由筆記本電腦通過HDMI輸入到FPGA芯片，經(jīng)過FPGA算法處理后在通過HDMI將圖像送到顯示屏展示處理效果。

筆記本電腦顯示圖片

經(jīng)過FPGA處理后的顯示效果
編輯：lyn