最近在用STM32H7这块板子做机器视觉的学习，在这里记录下学习心得与过程。有不对的地方欢迎大家指正。（stm32H7开发板，lcd9332显示屏）
7 @& }! ]$ C  o, `, r) G6 \(一）边缘检测概念
7 @) e3 }+ d% h8 k边缘是图像的基本特征，图像的边缘通常意味着一个区域的结束与另一个区域的开始，对于图像后续处理与检测有重要作用。
7 O, @8 E" ~, e, @在图像处理中，边缘通常被认为是周围的像素灰度发生阶跃变化或者屋顶变化的像素集合。
边缘的特征是沿边缘走向的像素变化平缓，垂直与边缘走向的像素变化剧烈。
边缘检测就是采用某种算法来提取出图像中灰度剧烈变化的区域边界，并且将其来接起来的方法。
; s9 R4 I: g; n9 N. A/ h$ Q（二）Canny边缘检测
Canny算子检测是目前使用较为广泛的边缘检测方法之一，本文也是通过canny算子来实现边缘检测的。
其主要步骤为：高斯滤波–>一阶差分算子计算梯度幅值及其方向–>对梯度幅值进行极大值抑制–>双阈值提取边缘。
' x; Z" O3 r7 b) d6 G3 y' r
8 x$ T0 y5 {2 x1. 基于全局阈值的二值化处理
& F6 T& T! ^+ q7 A' [假设某一副灰度图有如下的直方图，该图像由暗色背景下的较亮物体组成，从背景中提取这一物体时，将阈值T作为分割点，分割后的图像g(x, y)由下述公式给出，称为全局阈值处理

基本全局阈值处理方法

; J. P1 `) ^/ H  ~  g+ B  x为全局阈值T选择一个初始的估计值

用T分割图像，产生两组像素：G1由大于T的像素组成，G2由小于T的像素组成

4 U# B" J! G5 e对G1和G2的像素分别计算平均灰度值m1和m2

" w% c* q, R3 r' M9 O5 C9 J计算新的阈值T = 1/2 * (m1 + m2)
3 ]3 q3 J9 E$ k
8 t) s3 L( f  ?# j重复步骤2-4，直到连续迭代中的T值差小于一个预定义的参数ΔT
6 l' x  t8 B2 I1 M代码如下：

1. while(1){
   ' i$ c+ f& T8 f: z
2.                         T = 0.5 * (m1 + m2);
   
3.                         m1 = 0.0;
   $ g# @7 x7 i# ]$ _! }$ C
4.                         m2 = 0.0;
   0 n5 ]5 t0 X# {( ]% p4 p
5.                         m1_num = 0;
   
6.                         m2_num = 0;
   
7. 
   
8.                         for (i = 0; i < len; i++){
   ( e8 H! w) r# ~: M% C
9.                                 if (GetImageData<i> </i><= T){
   0 a( i) T4 ]2 d4 \
10.                                                 m1 += GetImageData;
    5 V3 W( c. H% `& ~) p0 J' M
11.                                                 m1_num++;
    
12.                                         }
    7 h- r( S( T, v' B! U/ K6 \
13.                                 else{
    ! n, h; Z# R5 G( u. I4 i" b
14.                                                 m2 += GetImageData;
    : Z9 g& e* C4 h" ?  U$ q
15.                                                 m2_num++;
    
16.                                                 }
    / j  y' ]( Q+ Z7 ~$ i6 E, Q
17. //                                GetImageData+=1;
    ) w% c6 s2 U, d9 F8 `+ V
18. //                                DataNum++;
    ( G# _; ?( o( t( [9 s' K) W/ x
19.                         }
    9 }1 o2 q) c1 i% D' O  y
20.                         if (m1_num != 0)
    2 y* v0 @1 M$ M6 s3 E
21.                                         m1 /= m1_num;
    6 X% ]/ _2 M$ i6 O
22.                         if (m2_num != 0)
    # B! Q% o: ]$ T; J% e2 X
23.                                         m2 /= m2_num;
    4 Z2 U  Z9 Y7 |5 O4 d5 J
24.                         if(fabs(T-(0.5*(m1 + m2)))<delt_t)
    
25.                                 break;
    1 |# J! K+ Z- y9 ?' V( X
26.         }
    2 X0 H$ B3 L- r: O6 {# A5 p
27.         GetImageData-=DataNum;
    
28.         for(j=0;j<len;j++)
    . Y9 y' R! P1 Q4 E# O
29.         {
    
30.                 if(GetImageData[j]<=T)
    
31.                         GetImageData[j]=0x00;
    1 e# z' k6 f8 M6 ]
32.                 else
    
33.                         GetImageData[j]=0xFF;        

复制代码

原图：

. u- [2 |6 [; ^# B, ]
二值化之后的图片：
* F/ v5 d( R8 [
, T3 T/ P& S* |1 S/ J6 b

我在刚开始做二值化的时候直接给定阈值进行处理，每张图片处理效果都不一样，很多时候会出现去不掉阴影的情况，此处通过参考阈值处理后达到所需要的效果。
, O- e2 N9 |% O. K& E7 l' b
2. 高斯滤波
! P, i7 T6 `% V, {; {进行简单的二值化处理之后开始Canny边缘检测的第一部分：高斯滤波。
滤波的主要目的是降噪，一般的图像处理算法都需要先进行降噪。而高斯滤波主要使图像变得平滑。
4 t/ j' u8 z, ^& \* y/ I/ v* |% n高斯函数是一个类似与正态分布的中间大两边小的函数。
对于一个位置（x,y）的像素点，其灰度值（这里只考虑二值图）为f(x,y)。
那么经过高斯滤波后的灰度值将变为：

& Z* G; R# h4 |) L) F

简单说就是用一个高斯矩阵乘以每一个像素点及其邻域，取其带权重的平均值作为最后的灰度值。

# ^/ }# K& u; S3 ~如下图3x3的像素区域为例，此矩阵中，我们选择的原点（0，0）周围的八个点为其领域：
, ^& `- U( G+ P, A8 x9 `' ~
/ k9 s7 K2 O* D, J) v' v* F( |
7 R5 U* T/ I1 {! k2 U
) ]# |! c9 ~( K' c. t我们设σ=1.5，将这个此区域的每个像素点做高斯变换之后就得到了以下的数据：



此矩阵为其权重矩阵，这个区域的权重总和为0.4787147，我们需要让他们的权重和为1，于是每个点的值在除以0.4787147，此时我们重新得到了一个3x3的矩阵：
" S1 L% S, ?% Z8 W% o! a


有了相应的3x3矩阵的权重值，我们再对原图像素点进行卷积运算，简单来说就是原图中的点附近的3x3大小区域乘以高斯模板区域。
代码如下：

1. for(i=widthG+1;i<((heightG-1)*widthG)-2;i++)
   
2.         {
   ! L9 U& s( U0 L* G
3.                         temp=(0.094*ImageNowg[i-widthG-1]+0.118*ImageNowg[i-widthG]+0.094*ImageNowg[i-widthG+1]
   
4.                 +0.118*ImageNowg[i-1]+0.147*ImageNowg+0.118*ImageNowg[i+1]+0.094*ImageNowg[i+widthG-1]
   4 f+ [/ x0 h* L* n
5.                 +0.118*ImageNowg[i+widthG]+0.094*ImageNowg[i+widthG+1]);
   
6.                         
   
7.                         gerytemp=(u8)temp;
   1 _7 S1 y6 T, C
8.         }
   
9.         for(j=widthG+1;j<((heightG-1)*widthG)-2;j++)
   
10.         {
    
11.                
    
12.                         if(gerytemp[j]>150)
      d# S5 _  [  ~
13.                         {
    ' q" F; K# R8 }* J
14.                                         gerytemp[j]=255;        
    
15.                         }
    
16.                         ImageNowg[j]=gerytemp[j];
    
17.                         
    $ C) ]. i' y" e! S6 R8 `! C
18.         }

复制代码

7 z; b3 f1 b* H高斯模糊后的图片（由于显示像素我没有进行色彩转换，高斯模糊的部分不是灰色），其中蓝色的部分为高斯模糊的像素。
8 D6 b4 Y- w7 J- \

, w& f) T, V, g6 V) N
8 }' v* N- \4 h/ l/ ^. E7 O3.Sobel算子与极大值抑制
Sobel算子是图像处理中的基本算子之一，他是一离散差分算子，用于计算图像亮度函数的梯度近似值。
6 A- j, q) U" U- Y: B4 uSobel算子有两个，一个是水平算子，一个是垂直算子。由于Sobel算子是滤波算子公式，用于提取边缘，可以利用快速卷积函数，简单有效，在Canny边缘检测被作为常用算子之一。
' @5 a6 R4 Q5 D6 oSobel算子也是一种梯度幅值，该算子包含两组3x3的矩阵，分别为横向与纵向，将之与 图像作平面卷积既可以得出横向及纵向的灰度差分近似值。假设原图像为I，横向边缘检测图像为G(x),纵向边缘检测图像为G(y)，模板卷积因子如下：

( e; f$ a. M! G; u5 G

有了模板卷积因子，我们计算出每个像素点的横向纵向梯度近似值之后，需要知道梯度的幅值大小以及梯度放向，梯度幅值由以下公式得出：
G=|G(x)+G(y)|
梯度方向公式：
2 P; C) b5 z; e+ ^: ~- J! U' PΘ=artan(G(y)/G(x))
; }% m6 s  f) P2 d8 X+ E; I; H/ J计算出梯度幅值之后，对图像进行门限处理，设定门限值为T，梯度幅值大于T时，规定该像素点的灰度值为0XFF，否则为0，即：
+ g! w, E( p( r- A1 k" m7 [, l


: I) r# L7 O' u) k9 G( T非极大值抑制
在Sobel算子对图像进行处理之后，图像的边缘不能作为最佳边缘，边缘有且应当只有一个准确的响应。非极大值抑制作用是对于梯度不是最大值的点进行抑制，对梯度图像中每个像素进行非极大值抑制的算法是：
  W& k5 v# x8 @2 |4 @
1.将当前像素的梯度强度与沿正负梯度方向上的两个像素进行比较。
: ~) q/ ?& J/ a# n2.如果当前像素的梯度强度与另外两个像素相比最大，则该像素点保留为边缘点，否则该像素点将被抑制。
如下图所示，其中P点为当前像素点，P1,P2为领域像素梯度幅值比较点，在这三点当中，如果P点的幅值是最大值，则保留，如果不是则抑制：

9 p; [% ~; f4 u) f& J; e

  {; ~2 \* x2 n" h6 v6 D( S, @
为了方便计算，通常会在俩个相邻像素（G(i+1,j-1),G(i+1,j))，之间采用线性插值的方法计算P1，P2的梯度幅值。
: L) |- ]( y: F+ D$ U具体计算方式如下：
) I$ r) v# X6 j3 e( W! D( c/ q/ S8 KP2=（1-tanΘ)xG(i+1,j)+tanΘxG(i+1,j-1);

( y$ s( T! [! j7 s) m# uP1=（1-tanΘ)xG(i-1,j)+tanΘxG(i-1,j+1);
代码如下：

1. for(i=widthS+1;i<((widthS-1)*(heightS-1))-2;i++)
   
2.         {
   
3.                
   
4.                 i00=ImageNow[i-widthS-1];
   , T2 j7 ?6 q. R! L, t; L  |
5.                 i01=ImageNow[i-widthS];
   & ^9 q1 G+ M. i, \# p3 P  y% ]2 f; [
6.                 i02=ImageNow[i-widthS+1];
   
7.                 i10=ImageNow[i-1];
   
8.                 i12=ImageNow[i+1];
   ) I, F% A7 b7 u6 v# ~! J2 t% a
9.                 i20=ImageNow[i+widthS-1];
   + Y* |, Z+ ?- u5 ?8 }1 [: p
10.                 i21=ImageNow[i+widthS];
    ) G& H' F2 D$ `4 x: @
11.                 i22=ImageNow[i+widthS+1];
    
12.                
    7 A/ h  }1 A2 m3 Z# D
13.                
    
14.                 V=-i00-2*i01-i02+i20+2*i21+i22;
    
15.                 H=-i00+i02-2*i10+2*i12-i20+i22;
    
16.                
    1 J$ @5 u- y$ V4 z" Y' Q- R# l0 y
17.                 grey=(u8)abs(H)+(u8)abs(V);
    : X- v  P- H- g* \. s9 P; `# D5 X8 x
18.                
    $ @3 M" W% a4 E/ _
19.                         if(grey==0)
    4 d% [% |( ], x  S
20.                 {
    
21.                         ImageOperation=0x00;
    
22.                         continue;
    
23.                 }
    
24.                 else
    0 p5 H; J+ F  _
25.                 {
    + z3 e7 e8 p' a1 b0 j  @& S- q
26.                         if(abs(H)>abs(V))///X///
    
27.                         {
    
28.                                 weight=abs(V)/abs(H);
    
29.                                 if(H*V>0)
    $ q/ @; d' o  c/ [: K, ^4 {( i/ f
30.                                 {
    
31.                                         comp1=grey[i+1]*(1-weight)+grey[i-widthS+1]*weight;
    
32.                                         comp2=grey[i-1]*(1-weight)+grey[i+widthS-1]*weight;
    
33.                                 }
    ( u. r/ G" @* z$ B+ F" A
34.                                 else
    ( Y( O' \! W( m0 C0 x; M7 y
35.                                 {
    
36.                                         comp1=grey[i+1]*(1-weight)+grey[i+widthS+1]*weight;
    
37.                                         comp2=grey[i-1]*(1-weight)+grey[i-widthS-1]*weight;
    
38.                                 }
    2 g. L: `4 y$ R$ @& a  q
39.                         }
    
40.                         else/Y/
    
41.                         {
    / K' \5 {- m  u0 f# _# Y/ p
42.                                 weight=abs(H)/abs(V);
    # W; r9 s* F8 `) d% H
43.                                 if(H*V>0)
    
44.                                 {
    . i; k/ @; N/ `- G% f3 _
45.                                         comp1=grey[i-widthS]*(1-weight)+grey[i-widthS+1]*weight;
    
46.                                         comp2=grey[i+widthS]*(1-weight)+grey[i+widthS-1]*weight;
    
47.                                 }
    
48.                                 else
    $ F; k- Q. ?! n/ i1 P6 [
49.                                 {
    
50.                                         comp1=grey[i+widthS]*(1-weight)+grey[i+widthS+1]*weight;
    1 b1 N! h2 l) `% ~2 a; O, S
51.                                         comp2=grey[i-widthS]*(1-weight)+grey[i-widthS-1]*weight;
    
52.                                 }
    
53.                         }
    
54. 
    - J& d6 n5 Y& N' J1 s
55.                                 if((grey>comp1)&&(grey>comp2))
    1 ^; b  I* k  d, f" `. K5 }. x
56.                                         ImageOperation=0xff;
    
57.                                 
    9 W& h5 U+ a2 f" [
58.                                 else
    
59.                                 ImageOperation=0x00;
    
60.                 }
    
61.                
    6 F- C6 m% x+ U
62.         }
    ! j' F' X$ F+ r- c/ U+ u+ z
63.         for(j=widthS+1;j<((widthS-1)*(heightS-1))-2;j++)
    ' V' c/ F& {) x) `: r, Z* j
64.         {
    
65.                         ImageNow[j]=ImageOperation[j];
    0 J3 ?& o8 P: h$ V
66.         }

复制代码

$ e0 p- Q- O8 d$ w代码中有判断当前像素梯度方向落在哪个象限的代码，具体看代码。
0 A3 x; g. z: l9 P* ?( `效果图：

# L5 Y( h# r: `& i! A

4.双阈值处理
在施加非极大值抑制之后，剩余的像素可以更准确地表示图像中的实际边缘。然而，仍然存在由于噪声和颜色变化引起的一些边缘像素。为了解决这些杂散响应，必须用弱梯度值过滤边缘像素，并保留具有高梯度值的边缘像素，可以通过选择高低阈值来实现。如果边缘像素的梯度值高于高阈值，则将其标记为强边缘像素；如果边缘像素的梯度值小于高阈值并且大于低阈值，则将其标记为弱边缘像素；如果边缘像素的梯度值小于低阈值，则会被抑制。阈值的选择取决于给定输入图像的内容。
具体实现代码如下：
* b) T; ^( T, T" [
6 H9 E, G5 z+ T: A" g

1. 
   # R, \7 a0 `) G5 f
2. nhist=(int*)malloc((400)*sizeof(int));
   % i' M% H4 N5 N9 F3 e, D
3.         
   
4.         for(i=0;i<400;i++)
   0 W9 \( Z% J. g9 g- \- X
5.                 nhist=0;
   + n  a3 s& m! ]4 w* j! A' @4 g) J
6.         for(i=0;i<widthS*heightS;i++)
   ! x* s' F- U! E, q( S" ]
7.                 if(ImageNow==0xff)
   
8.                         nhist[grey]++;
   
9.         sum=0;
   ) E- |6 R' t3 y
10.         for(i=0;i<400;i++)
    
11.                 sum+=nhist;
    # {* n' e) _0 C
12.         sum2=0;
    
13.         for(i=0;i<400;i++)
    
14.                 {
    1 |1 G5 N) f6 q% T+ e0 T
15.                         sum2+=nhist;
    3 V* P3 z$ B& r2 S
16.                         if(sum2>(0.7*sum+0.5))
    
17.                         {
    5 w5 o! M4 j" F9 o0 @9 Z
18.                                 high=i;                                                        //取出高阈值
    
19.                                 break;
    
20.                         }
    ) e2 ^/ J9 e: G+ u
21.                 }
    $ [4 P/ E- u$ ^+ X
22.         low=(int)(0.4*((float)high)+0.5);//取出低阈值
    : ]; h: c* H3 g' y
23.         free(nhist);
    
24.         
    
25.                 for(i=widthS+1;i<widthS*heightS;i++)双阈值检测处理
    
26.                 {
    / ?* v  _# h7 p; C  f1 e
27.                         if((grey>=high)&&(ImageNow==0xff))
    
28.                                                         ImageNow=0xff;
    0 u( B0 ?) O2 s1 x# C
29.                         else if(grey>low&&grey<0xff)
    $ [$ `2 @4 `9 l3 u! q
30.                         {
    9 N6 n) C, T3 K5 |* K6 ~/ B, O
31.                                 judge=1;
    
32.                                 while(judge)
    
33.                                 {
      R3 d0 E7 o: M0 j6 Q
34.                                         for(j=-widthS;j<widthS+1;j+=widthS)
    
35.                                         {
    " |# W1 C; t$ ?8 ], H/ G
36.                                                 for(k=-1;k<2;k++)
    ( N! Q; o; {7 `( U
37.                                                 {
    
38.                                                         if((grey[i+j+k-1]>low)&&(ImageNow==0xff))
    
39.                                                         {
    + |: S5 Z( G* a) t
40.                                                                 ImageNow[i+j+k-1]=0xff;
    3 @% h) W. t9 W: P8 O5 Z" ?
41.                                                                 i=i+j+k;
    
42.                                                                 cnt=0;
    3 L  R4 o4 ^( |# \* t
43.                                                                 break;
    
44.                                                         }
    
45.                                                         else
    3 q. s- |0 U6 P) l: C
46.                                                                 cnt++;
    
47.                                                         if(cnt>=8)
    
48.                                                         {
    - e0 @" }2 v# D- T
49.                                                                 cnt=0;
    5 _; a+ m. m/ v5 d2 |# |
50.                                                                 judge=0;
    
51.                                                                 break;
    
52.                                                         }
    
53.                                                 }
    
54.                                                 if(judge==0||cnt==0)
    
55.                                                         break;
    
56.                                         }
    ! n: X8 @5 F, {- X, d) C
57.                                         if(j>widthS+1||cnt==0)
    
58.                                                 judge=0;
    % W( C/ a: s. L
59.                                 }
    
60.                         }
    9 w4 {+ K0 b+ l# S1 D- E& j& F$ I. ]
61.                         else
    
62. <i>                                              </i>          ImageNow<span style="font-style: italic;"><span style="font-style: normal;">=0;</span>
    : B# {' C7 z% Z: F) n+ @3 j
63.                </span> }
    / ^, |6 M; g9 ]7 F7 _' B* [

复制代码

- |; `' J4 X0 D/ e& l+ V9 M处理效果图：
) G: z7 s7 M( g' P9 C* ^( B
* R2 }3 k' L+ c! R- k% K

+ ^6 y, x# ]2 `/ w  I( v
由于我的图片噪声较小，与上一步的处理结果看不出太大的差别。
1 K! M4 S6 L( a" X7 Y( ?
stm32h7的Canny边缘检测算法基本完毕，在32上运行起来和Matlab上的差距很大，我觉得应该是我图片存储方式的问题，我这里是用ImageLcd软件将图片直接转为一维数组进行操作显示的。建议使用SD卡存储图片在读取运算（由于我手头没有SD卡只能用这种方式）。

0 `: ^/ `. x+ @
, t# ]' D8 R$ X$ @9 x' {
6 r# D8 x6 C6 P: K