前言

本文基于FPGA实现了一种图像缺陷自适应阈值分割算法,选用经典的OTSU算法作为分割基础。OTSU算法通过分析图像灰度直方图,计算出最佳阈值,从而实现图像的自动二值化。

工程环境:Quartus Prime Version 18.1
硬件环境:AWC_C4 FPGA开发套件(青春版)
FPGA芯片:Intel Cyclone IV

本工程包含ov5640图像采集、SDRAM读写控制,与Otsu大津法实现图像分割构成完整系统,在本文中将重点聚焦于如何使用Verilog实现Otsu算法。

一、Otsu算法

OTSU算法由大津久雄于1979年提出,是一种基于最大类间方差的自动阈值选择方法,广泛应用于图像分割中。

该算法的目标是通过分析图像的灰度直方图,自动找到一个最佳的灰度阈值,将图像分为前景和背景。OTSU算法的核心思想是最大化类间方差,这意味着我们希望通过选择一个阈值,使得背景和前景之间的灰度差异尽可能大,从而实现最优的图像分割。

在 OTSU 算法中,首先需要统计图像中各灰度级的像素分布。假设灰度范围为 [ 0 , L − 1 ] [0, L-1] [0,L−1],每个灰度级 i i i 的像素出现概率为 p ( i ) p(i) p(i)。
当设定阈值 t t t 后,像素会被分为两类:

  • 背景类:灰度值 ≤ t \leq t ≤t 的像素;
  • 前景类:灰度值 > t > t >t 的像素。

背景类和前景类的权重(即像素比例)分别为:

ω 0 ( t ) = ∑ i = 0 t p ( i ) , ω 1 ( t ) = ∑ i = t + 1 L − 1 p ( i ) \omega_0(t) = \sum_{i=0}^{t} p(i), \quad \omega_1(t) = \sum_{i=t+1}^{L-1} p(i) ω0​(t)=i=0∑t​p(i),ω1​(t)=i=t+1∑L−1​p(i)

对应的类均值(即类内平均灰度)为:

μ 0 = ∑ i = 0 t i ⋅ p ( i ) ω 0 , μ 1 = ∑ i = t + 1 L − 1 i ⋅ p ( i ) ω 1 \mu_0 = \frac{\sum_{i=0}^{t} i \cdot p(i)}{\omega_0}, \quad \mu_1 = \frac{\sum_{i=t+1}^{L-1} i \cdot p(i)}{\omega_1} μ0​=ω0​∑i=0t​i⋅p(i)​,μ1​=ω1​∑i=t+1L−1​i⋅p(i)​

OTSU 算法通过 类间方差 来衡量前景和背景的区分度,其表达式为:

σ b 2 = ω 0 ( μ 0 − μ T ) 2 + ω 1 ( μ 1 − μ T ) 2 (1.1) \sigma_b^2 = \omega_0(\mu_0 - \mu_T)^2 + \omega_1(\mu_1 - \mu_T)^2 \tag{1.1} σb2​=ω0​(μ0​−μT​)2+ω1​(μ1​−μT​)2(1.1)

其中, μ T \mu_T μT​ 为全局平均灰度:

μ T = ω 0 μ 0 + ω 1 μ 1 (1.2) \mu_T = \omega_0 \mu_0 + \omega_1 \mu_1 \tag{1.2} μT​=ω0​μ0​+ω1​μ1​(1.2)

将公式 (1.2) 代入 (1.1) 并化简,可得:

σ b 2 = ω 0 ω 1 ( μ 0 − μ 1 ) 2 (1.3) \sigma_b^2 = \omega_0 \omega_1 (\mu_0 - \mu_1)^2 \tag{1.3} σb2​=ω0​ω1​(μ0​−μ1​)2(1.3)

公式 (1.3) 是 OTSU 算法的核心。它表明,当类间方差 σ b 2 \sigma_b^2 σb2​ 最大时,前景与背景的灰度差异也最大,分割效果最佳。
因此,OTSU 的目标就是遍历所有可能的阈值 t t t,计算对应的类间方差,并选取使 σ b 2 \sigma_b^2 σb2​ 最大的阈值作为最优阈值。

二、硬件算法实现

该系统以 OV5640 摄像头为图像采集前端,采集到的原始数据首先进入 FIFO 缓冲,实现速率匹配后送入 FPGA 内部处理模块。

在 FPGA 内部,图像经过 灰度化处理 转换为单通道灰度图,再通过 直方图统计与 OTSU 算法 计算最优阈值,以完成 图像二值化。

处理后的图像数据通过 PIN MUX 进行路径选择,可送往 WR FIFO 并由 SDRAM 写入控制器存储至 SDRAM,也可在需要时通过 RD FIFO 与 SDRAM 读取控制器读出,最终经 VGA 接口显示在屏幕上。

系统架构图

2.1 灰度直方图处理

在图像预处理阶段,OTSU 算法的核心依赖之一是灰度直方图的准确构建。灰度直方图反映了图像中各灰度级别出现的频次,是判断亮度分布并确定分割阈值的重要依据。

注:本设计中使用的双端口RAM为Quartus EDA工具提供的存储IP,若将本工程移植到AMD芯片需要替换该IP,同时在逻辑上需要做一定修改,具体差别可以移步使用Verilog实现灰度直方图相关文章,了解intel和amd两端BRAM的差别

在 FPGA 的实现过程中,系统需要实时统计输入图像的灰度直方图。具体来说,摄像头模块输出的灰度数据直接作为 双端口 RAM 的 A 口地址,实现像素频率的高效统计。其工作机制如下:

  1. 当新像素到达时,首先从 RAM 中读出当前灰度地址的计数值;
  2. 将该计数值加 1;
  3. 把更新后的结果重新写回相同地址。

这样,在整帧扫描过程中,各灰度级的像素数 n i n_i ni​ 会逐步累加,直到一帧结束时构建出完整的灰度直方图。设图像总像素数为 N N N,灰度范围为 [ 0 , L − 1 ] [0, L-1] [0,L−1],则第 i i i 个灰度级出现的概率为:

p ( i ) = n i N , i ∈ [ 0 , L − 1 ] p(i) = \frac{n_i}{N}, \quad i \in [0, L-1] p(i)=Nni​​,i∈[0,L−1]

其中, n i n_i ni​ 为 RAM 中对应灰度级 i i i 的累积像素数。

为了进一步支持 OTSU 的全局平均灰度计算,代码中还设计了一个 灰度累加器 (gray_sum),在像素输入过程中不断累加灰度值,得到整帧的灰度总和:

μ T = 1 N ∑ i = 0 L − 1 i ⋅ n i (2.1) \mu_T = \frac{1}{N} \sum_{i=0}^{L-1} i \cdot n_i \tag{2.1} μT​=N1​i=0∑L−1​i⋅ni​(2.1)

当一帧结束(din_eop 有效)时,控制逻辑会切换至 RAM 的 B 口,对存储的直方图数据逐一读出,并在同一周期将对应地址清零,为下一帧的统计做好准备。整个过程由时钟驱动的顺序逻辑控制,保证了 像素采集、直方图更新与数据清零互不干扰。

这种设计使 FPGA 在图像输入的同时即可并行完成直方图的构建,而无需等待帧结束后再进行集中处理,从而显著提升了处理效率与实时响应能力。最终生成的直方图不仅反映了当前帧的灰度分布,还为 OTSU 算法的类间方差计算提供了输入条件:

σ b 2 ( t ) = ω 0 ( t ) ⋅ ω 1 ( t ) ⋅ ( μ 0 ( t ) − μ 1 ( t ) ) 2 (2.2) \sigma_b^2(t) = \omega_0(t) \cdot \omega_1(t) \cdot \big(\mu_0(t) - \mu_1(t)\big)^2 \tag{2.2} σb2​(t)=ω0​(t)⋅ω1​(t)⋅(μ0​(t)−μ1​(t))2(2.2)

其中:

  • ω 0 ( t ) \omega_0(t) ω0​(t) 和 ω 1 ( t ) \omega_1(t) ω1​(t) 分别对应 Verilog 代码中 sum_forword 与 sum_backend 的归一化结果,表示在阈值 t t t 下背景类和前景类像素比例;
  • μ 0 ( t ) \mu_0(t) μ0​(t) 和 μ 1 ( t ) \mu_1(t) μ1​(t) 分别对应 aver_gray_forword 与 aver_gray_backend,即背景类与前景类的平均灰度值。

//main code
//摄像头输入的灰度数据有效时,会先进行读ram操作,然后将读出的数据加1后,再次写入相同地址,
//读操作需要一个时钟周期,因此“写使能”直接将输入的vaild信号延迟一个时钟周期即可
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			wr_en	<=	1'd0;
		else	
			wr_en	<=	din_vld;
	end
//总灰度计数
	reg	[27:0]	gray_sum;
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			gray_sum	<=	28'd0;
		else if(din_sop)
			gray_sum	<=	28'd0;
		else if(din_vld)
			gray_sum	<=	gray_sum	+	din;
	end
		
//双端口ram ,用于统计一帧图像的灰度直方图
ram_2port u_ram_2port(
//端口a:摄像头输出的灰度数据作为RAM地址,先将该地址中的数据读出来,然后加1再写入RAM中
	.clock_a ( clk ),
	.aclr_a ( !rst_n ),
	.address_a ( din ),
	.data_a ( rd_data+1 ),//直方图统计阶段,写入ram的数据为当前地址的数据加1
	.rden_a ( din_vld ),//读端口
	.wren_a ( wr_en ),
	.q_a ( rd_data ),
	
//端口b:一帧结束后读出RAM中数据进行寄存,下一帧开始前将RAM初始化为0
	.aclr_b ( 1'b0 ),
	.address_b ( ram_addr_b ),
	.clock_b ( clk ),
	.data_b ( 20'd0 ),
	.rden_b ( ram_rd_b ),
	.wren_b ( ram_wr_b ),
	.q_b ( ram_rd_q_b )
	);	
		  
	//读出逻辑
    always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			ram_rd_b	<=	1'b0	;
		else begin
			if(eop[1])	//一帧结束开始读取直方图数据
				ram_rd_b	<=	1'b1;
			else if(ram_addr_b==8'd255)
				ram_rd_b	<=	1'b0;
		end
	end
	
	//清零逻辑,每读出一个数据,同一个时钟该地址数据数据清零
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			ram_wr_b	<=	1'b0	;
		else  begin
			if(eop[1])	
				ram_wr_b	<=	1'b1;
			else if(ram_addr_b==8'd255)
				ram_wr_b	<=	1'b0;
		end
	end
		
	//结算逻辑,遍历整个地址
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)	
			ram_addr_b	<=	8'd0;
		else if(ram_rd_b)
			ram_addr_b	<=	ram_addr_b + 1'b1;
		else 
			ram_addr_b	<=	8'd0;
	end
	

2.2 第一级流水:像素统计与灰度累加

在遍历直方图的过程中,系统依次读取灰度级 ( i i i) 的像素数 ( n i n_i ni​)。若 ( i ≤ t i \le t i≤t),则累加至前景部分,否则归入背景。由于代码中背景部分采用总量减前景量的方式实现,因此只需对前景进行逐步累加:

N 0 ( t ) = ∑ i = 0 t n i , S 0 ( t ) = ∑ i = 0 t i ⋅ n i N_0(t) = \sum_{i=0}^{t} n_i, \quad S_0(t) = \sum_{i=0}^{t} i \cdot n_i N0​(t)=i=0∑t​ni​,S0​(t)=i=0∑t​i⋅ni​

背景部分通过差值获得:

N 1 ( t ) = N − N 0 ( t ) , S 1 ( t ) = S T − S 0 ( t ) N_1(t) = N - N_0(t), \quad S_1(t) = S_T - S_0(t) N1​(t)=N−N0​(t),S1​(t)=ST​−S0​(t)

其中:

  • ( N N N) 为总像素数,代码中 sum_backend 初值即为 ( N N N);
  • ( S T S_T ST​) 为全局灰度总和,对应寄存器 gray_sum。
//实现ostu算法
	//g=nk_forword*nk_backend*(前景平均灰度-后景平均灰度)²
	//采用5级流水实现
	reg	[3:0]	ostu_flow;	
	 always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            ostu_flow <= 4'b0;     
        end
		else begin
            ostu_flow <= {ostu_flow[2:0],ram_rd_b};      
        end
    end
	//第一级流水获得前景后景像素点个数与累计灰度数
	reg	[19:0]	sum_forword;	//前景像素点
	reg	[19:0]	sum_backend;
	reg	[27:0]	sum_gray_forword;	//前景累计灰度值
	reg	[27:0]	sum_gray_backend;
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
			sum_forword			<=	20'd0;
			sum_gray_forword	<=	28'd0;
		end
		else if(din_sop)begin
			sum_forword			<=	20'd0;
			sum_gray_forword	<=	28'd0;
		end
		else if(ram_rd_b)begin
			sum_forword			<=	sum_forword			+	ram_rd_q_b;
			sum_gray_forword	<=	sum_gray_forword	+	ram_addr_b*ram_rd_q_b;
		end
	end
	
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
			sum_backend			<=	20'd921_600;
			sum_gray_backend	<=	28'd0;
		end
		else if(din_sop)begin
			sum_backend			<=	20'd921_600;
			sum_gray_backend	<=	28'd0;
		end
		else if(din_eop)
			sum_gray_backend	<=	gray_sum;
		else if(ram_rd_b)begin
			sum_backend			<=	sum_backend	-	ram_rd_q_b;
			sum_gray_backend	<=	sum_gray_backend	-	ram_addr_b*ram_rd_q_b;
		end
	end

2.3 第二级流水:平均灰度与像素乘积

前景与背景的平均灰度由下式给出:

μ 0 ( t ) = S 0 ( t ) N 0 ( t ) , μ 1 ( t ) = S 1 ( t ) N 1 ( t ) \mu_0(t) = \frac{S_0(t)}{N_0(t)}, \quad \mu_1(t) = \frac{S_1(t)}{N_1(t)} μ0​(t)=N0​(t)S0​(t)​,μ1​(t)=N1​(t)S1​(t)​

Verilog 中通过左移近似实现除法,减少运算开销。与此同时,系统计算前景与背景像素数量的乘积:

M ( t ) = N 0 ( t ) ⋅ N 1 ( t ) M(t) = N_0(t) \cdot N_1(t) M(t)=N0​(t)⋅N1​(t)

该值将在类间方差的计算中直接使用。

//第二级流水获得前景平均灰度和后景平均灰度,以及前景后像素点的乘积
	reg	[7:0]	aver_gray_forword;	
	reg	[7:0]	aver_gray_backend;
	reg	[37:0]	mult_pixel;
	
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
			aver_gray_forword	 <=	8'd0;
			aver_gray_backend    <=	8'd0;
		end
		else if(din_sop)begin
			aver_gray_forword	 <=	8'd0;
			aver_gray_backend    <=	8'd0;
		end
		else if(ostu_flow[0])begin
			if(sum_forword==0)begin
			aver_gray_forword	 <=	8'd0;
			aver_gray_backend    <= (sum_gray_backend<<8/sum_backend)>>8	;
			end
			else if(sum_backend==0)begin
			aver_gray_forword	 <=	(sum_gray_forword<<8/sum_forword)>>8	;
			aver_gray_backend    <= 8'd0;
			end
			else begin
			aver_gray_forword	 <=	(sum_gray_forword<<8/sum_forword)>>8	;
	        aver_gray_backend    <= (sum_gray_backend<<8/sum_backend)>>8	;
			end
		end
	end
	
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			mult_pixel	<=	38'd0;
		else if(din_sop)begin
			mult_pixel	<=	38'd0;
		end
		else if(ostu_flow[0])begin
			mult_pixel	<=	sum_backend*sum_forword	;
		end
	end
	

2.4 第三级流水:灰度差平方

本阶段对两个区域的平均灰度求差,并计算平方:

Δ μ ( t ) = μ 0 ( t ) − μ 1 ( t ) , D ( t ) = ( Δ μ ( t ) ) 2 \Delta \mu(t) = \mu_0(t) - \mu_1(t), \quad D(t) = \big(\Delta \mu(t)\big)^2 Δμ(t)=μ0​(t)−μ1​(t),D(t)=(Δμ(t))2

在硬件实现中,通过条件判断保证输入为非负数,避免逻辑错误。该结果与 ( M ( t ) ) (M(t)) (M(t)) 同步缓存,为下一阶段使用。

//第三级流水进行平均灰度差的平方
	reg	[15:0]	sq_value;	//平方值
	reg	[37:0]	mult_pixel_t;
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			sq_value	<=	16'd0;
		else if(din_sop)begin
			sq_value	<=	16'd0;
		end
		else if(ostu_flow[1])begin
			if(aver_gray_backend>=aver_gray_forword)
				sq_value	<=	(aver_gray_backend-aver_gray_forword)*(aver_gray_backend-aver_gray_forword);
			else 
				sq_value	<=	(aver_gray_forword-aver_gray_backend)*(aver_gray_forword-aver_gray_backend);
		end
	end
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			mult_pixel_t	<=	38'd0;
		else if(din_sop)begin
			mult_pixel_t	<=	38'd0;
		end
		else if(ostu_flow[1])begin
			mult_pixel_t	<=	mult_pixel	;
		end
	end	
	

2.5 第四级流水:类间方差计算

根据 OTSU 原理,类间方差的表达式为:

σ b 2 ( t ) = M ( t ) ⋅ D ( t ) \sigma_b^2(t) = M(t) \cdot D(t) σb2​(t)=M(t)⋅D(t)

在代码中,该值由 mult_pixel_t 和 sq_value 相乘得到,并存储于高位宽寄存器 var_value 中,以保证精度和避免溢出。

//第四级流水进行最终结果的计算
	reg	[50:0]	var_value;	//最终方差值	
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			var_value	<=	51'd0;
		else if(din_sop)begin
			var_value	<=	51'd0;
		end
		else if(ostu_flow[2])
			var_value	<= mult_pixel_t*sq_value;
	end

2.6 第五级流水:最优阈值搜索

系统在逐步遍历阈值的过程中,实时比较当前类间方差与历史最大值:

σ b 2 ( t ∗ ) = max ⁡ t ∈ [ 0 , L − 1 ] σ b 2 ( t ) \sigma_b^2(t^*) = \max_{t \in [0, L-1]} \sigma_b^2(t) σb2​(t∗)=t∈[0,L−1]max​σb2​(t)

对应的阈值 ( t ∗ ) (t^*) (t∗) 被记录为最终的分割阈值。在 Verilog 实现中,var_value_max 保存最大方差,thre_result 保存最佳阈值。

	//第五级流水记录最大方差和当前阈值,以及采用冒泡排序找到最大阈值
	reg [7:0]	thre_value;//当前遍历阈值
	reg [7:0]	thre_result;//最终阈值结果
	reg	[50:0]	var_value_max;//最大方差值
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			thre_value	<=	8'd0;
		else if(din_sop)
			thre_value	<=	8'd0;
		else if(ostu_flow[3])
			thre_value	<=	thre_value + 1'b1;
	end
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			var_value_max	<=	51'd0;
		else if(din_sop)begin
			var_value_max	<=	51'd0;
		end
		else if(ostu_flow[3])begin
			if(var_value_max<var_value)
			var_value_max	<=	var_value	;
		end
	end	
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			thre_result	<=	8'd0;
		else if(din_sop)
			thre_result	<=	8'd0;
		else if(ostu_flow[3])begin
			if(var_value_max<var_value)
				thre_result	<=	thre_value;
		end
	end
	
	//以上ostu算法已经实现
	reg [7:0]	thre_run_value;//阈值比较数值
	always  @(posedge clk or negedge rst_n)begin
        if(~rst_n)
			thre_run_value	<=	8'd0;
		else if(din_sop)
			thre_run_value	<=	thre_result;
	end
		
			
	always@(posedge clk or negedge rst_n)begin
        if(~rst_n)begin
            dout <= 0 ;
        end
        else if(vld[0])begin
            dout <= (din>=thre_run_value) ;//二值化thre_run_value
        end
    end

三、总结

通过上述五级流水设计,OTSU 算法被分解为:

  1. 前景累加,背景差分:(N_0, S_0, N_1, S_1);
  2. 均值与乘积计算:( μ 0 , μ 1 , M \mu_0, \mu_1, M μ0​,μ1​,M);
  3. 灰度差平方:(D);
  4. 类间方差计算:( σ b 2 \sigma_b^2 σb2​);
  5. 最大方差搜索:( t ∗ t^* t∗);

这种分级处理方式充分利用 FPGA 并行与流水特性,实现了高效、实时的图像分割,适用于对响应速度和准确性要求较高的工业视觉。

在笔者实际上板中发现,由于每一帧结束都会计算该阈值,非常容易由于光线绕动造成频闪,可以在阈值比较那一块代码之前加一个均值处理,取几十帧(看情况而定)计算出的阈值加和再求平均,以这个平均值作为上板中的图像分割阈值。

工程链接: https://pan.baidu.com/s/1xygb-5q0iFj9pHe4FKdt3w?pwd=syy6
提取码: syy6

写在最后

第一次写博客,难免稚嫩,欢迎大家轻拍指正!
祝好

Logo

DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐