python 简单图像处理（11） 空间域图像锐化(边缘检测)

在图像识别中，需要有边缘鲜明的图像，即图像锐化。

图象锐化的目的是为了突出图像的边缘信息，加强图像的轮廓特征，以便于人眼的观察和机器的识别。

在空间域进行图象锐化主要有以下方法

1. 梯度算子
2. 其他锐化算子
3. 拉普拉斯算子

（1）梯度空间算子

图像的边缘最直观的表现就是边缘两侧的灰度值相差比较大，在微积分中我们学过梯度的概念

梯度是一个列向量，可表示为：

而某点处梯度的模很好的反应了该点两侧的变化大小

所以，梯度值很大的点也就代表了图像的边缘

而在实际计算中，为了降低运算量，一般用一下两种方法来代替模运算

由于数字图像处理中处理的是数字离散信号

所以，我们用差分来等同于连续信号中的微分运算

典型的梯度运算有

而另一种称为Roberts梯度的差分运算可由下来表示

 

我们来编写程序来实现上面计算

  
  

   
   import
   
    cv
    

   
   def
   
    Sharp(image,flag1
   
   =
   
   0,flag2
   
   =
   
   0):
    w 
   
   =
   
    image.width
    h 
   
   =
   
    image.height
    size 
   
   =
   
    (w,h)
    iSharp 
   
   =
   
    cv.CreateImage(size,
   
   8
   
   ,
   
   1
   
   )
    
   
   for
   
    i 
   
   in
   
    range(h
   
   -
   
   1
   
   ):
        
   
   for
   
    j 
   
   in
   
    range(w
   
   -
   
   1
   
   ):
            
   
   if
   
    flag2 
   
   ==
   
    0:
                x 
   
   =
   
    abs(image[i,j
   
   +
   
   1
   
   ]
   
   -
   
   image[i,j])
                y 
   
   =
   
    abs(image[i
   
   +
   
   1
   
   ,j]
   
   -
   
   image[i,j])
            
   
   else
   
   :
                x 
   
   =
   
    abs(image[i
   
   +
   
   1
   
   ,j
   
   +
   
   1
   
   ]
   
   -
   
   image[i,j])
                y 
   
   =
   
    abs(image[i
   
   +
   
   1
   
   ,j]
   
   -
   
   image[i,j
   
   +
   
   1
   
   ])
            
   
   if
   
    flag1 
   
   ==
   
    0:
                iSharp[i,j] 
   
   =
   
    max(x,y)
            
   
   else
   
   :
                iSharp[i,j] 
   
   =
   
    x
   
   +
   
   y
    
   
   return
   
    iSharp 
 

 
image 
   
   =
   
    cv.LoadImage(
   
   '
   
   lena.jpg
   
   '
   
   ,0)
iMaxSharp 
   
   =
   
    Sharp(image)
iAddSharp 
   
   =
   
    Sharp(image,
   
   1
   
   )
iRMaxSharp 
   
   =
   
    Sharp(image,0,
   
   1
   
   )
iRAddSharp 
   
   =
   
    Sharp(image,
   
   1
   
   ,
   
   1
   
   )
cv.ShowImage(
   
   '
   
   iMaxSharp
   
   '
   
   ,iMaxSharp)
cv.ShowImage(
   
   '
   
   image
   
   '
   
   ,image)
cv.ShowImage(
   
   '
   
   iAddSharp
   
   '
   
   ,iAddSharp)
cv.ShowImage(
   
   '
   
   iRAddSharp
   
   '
   
   ,iRAddSharp)
cv.ShowImage(
   
   '
   
   iRMaxSharp
   
   '
   
   ,iRMaxSharp)
cv.WaitKey(0)
  
  

我们来看看运行结果

下面是Roberts梯度

可以比较下两种方法的效果

 

（2）其他锐化算子

利用梯度和差分原理可以组成以下锐化算子

1.Sobel算子

2.Prewitt算子

3.Isotropic算子

好啦，我们还是写程序吧

 

  
  

   
   import
   
    cv


   
   def
   
    SuanSharp(image,arrayX,arrayY):
    w 
   
   =
   
    image.width
    h 
   
   =
   
    image.height
    size 
   
   =
   
    (w,h)
    iSuanSharp 
   
   =
   
    cv.CreateImage(size,
   
   8
   
   ,
   
   1
   
   )
    tmpX 
   
   =
   
    [0]
   
   *
   
   9
   
   
    tmpY 
   
   =
   
    [0]
   
   *
   
   9
   
   
    
   
   for
   
    i 
   
   in
   
    range(
   
   1
   
   ,h
   
   -
   
   1
   
   ):
        
   
   for
   
    j 
   
   in
   
    range(
   
   1
   
   ,w
   
   -
   
   1
   
   ):
            
   
   for
   
    k 
   
   in
   
    range(
   
   3
   
   ):
                
   
   for
   
    l 
   
   in
   
    range(
   
   3
   
   ):
                    tmpX[k
   
   *
   
   3
   
   +
   
   l] 
   
   =
   
    image[i
   
   -
   
   1
   
   +
   
   k,j
   
   -
   
   1
   
   +
   
   l]
   
   *
   
   arrayX[k
   
   *
   
   3
   
   +
   
   l]
                    tmpX[k
   
   *
   
   3
   
   +
   
   l] 
   
   =
   
    image[i
   
   -
   
   1
   
   +
   
   k,j
   
   -
   
   1
   
   +
   
   l]
   
   *
   
   arrayX[k
   
   *
   
   3
   
   +
   
   l]
            iSuanSharp[i,j] 
   
   =
   
    sum(tmpX)
   
   +
   
   sum(tmpY)
    
   
   return
   
    iSuanSharp
    
    
image 
   
   =
   
    cv.LoadImage(
   
   '
   
   lena.jpg
   
   '
   
   ,0)
SobelX 
   
   =
   
    [
   
   1
   
   ,0,
   
   -
   
   1
   
   ,
   
   2
   
   ,0,
   
   -
   
   2
   
   ,
   
   1
   
   ,0,
   
   -
   
   1
   
   ]
SobelY 
   
   =
   
    [
   
   -
   
   1
   
   ,
   
   -
   
   2
   
   ,
   
   -
   
   1
   
   ,0,0,0,
   
   1
   
   ,
   
   2
   
   ,
   
   1
   
   ]
PrewittX 
   
   =
   
    [
   
   1
   
   ,0,
   
   -
   
   1
   
   ,
   
   1
   
   ,0,
   
   -
   
   1
   
   ,
   
   1
   
   ,0,
   
   -
   
   1
   
   ]
PrewittY 
   
   =
   
    [
   
   -
   
   1
   
   ,
   
   -
   
   1
   
   ,
   
   -
   
   1
   
   ,0,0,0,
   
   1
   
   ,
   
   1
   
   ,
   
   1
   
   ]
IsotropicX 
   
   =
   
    [
   
   1
   
   ,0,
   
   -
   
   1
   
   ,
   
   1.414
   
   ,0,
   
   -
   
   1.414
   
   ,
   
   1
   
   ,0,
   
   -
   
   1
   
   ]
IsotropicY 
   
   =
   
    [
   
   -
   
   1
   
   ,
   
   -
   
   1.414
   
   ,
   
   -
   
   1
   
   ,0,0,0,
   
   1
   
   ,
   
   1.414
   
   ,
   
   1
   
   ]
iSobelSharp 
   
   =
   
    SuanSharp(image,SobelX,SobelY)
iPrewittSharp 
   
   =
   
    SuanSharp(image,PrewittX,PrewittY)
iIsotropicSharp 
   
   =
   
    SuanSharp(image,IsotropicX,IsotropicY)
cv.ShowImage(
   
   '
   
   image
   
   '
   
   ,image)
cv.ShowImage(
   
   '
   
   iPrewittSharp
   
   '
   
   ,iPrewittSharp)
cv.ShowImage(
   
   '
   
   iSobelSharp
   
   '
   
   ,iSobelSharp)
cv.ShowImage(
   
   '
   
   iIsotropicSharp
   
   '
   
   ,iIsotropicSharp)
cv.WaitKey(0)
  
  

 

看看运行效果吧

 

好吧，这三个图的运算花了好几秒的时间，循环太多了，其实可以用numpy做矩阵运算

我们在这里主要学习图像处理原理，不是学习编程

 

（3）拉普拉斯运算

拉普拉斯运算比较适合于改善因为光线的漫反射而造成的图像模糊，拉普拉斯算子法是常用的边缘增强处理算子

它是各向同性的二阶导数

对于连续二元函数有：

整理后有：

可以得到拉普拉斯算子模板：

看看运行效果

而对于Photoshop这类软件来说，锐化和我这里所说的锐化不同

它是在原图基础上，加强边缘效果

我们只要把模板适当改动就能实现这样的效果

 

还有一种思路，我们在前面讲了图像的平滑，我们用原图减去平滑后的图像

得到的就是锐化边缘了

第四幅图我们对轮廓线做了对数灰度变换，前面讲过的

不过，效果没有前面直接锐化清晰

我们还可以在原图上乘以一个大于1的因子再减去模糊后的图像

得到如下结果