数字图像处理之图像增强

    所谓图像增强，就是对图像的某些特征,比如：边缘，轮廓，对比度等进行强调突出或锐化，以便于显示、观察或进一步分析与处理。

    图像增强的研究内容有很多，其中下表表示了一部分：

   

    这儿我简单的谈谈区域运算的平滑和锐化：

    平滑：

    平滑的算法有很多：平均值法，中值滤波和一些其他的平滑算法。

    这儿以简单的平均值法为例讲解：

    对于每一个像素点(边缘不含在内)和其相邻的一些点会组成一个矩阵，这儿我以3x3的矩阵为例：

   

   新的像素矩阵的(m,n)点的像素值就是这个矩阵的平均值。

   那么，对每一个像素点做一次这样的变换，即可以得到平滑后的图像。

   对于那些可减弱的小颗粒噪声，与周围的图像相比应该有比较明显的不同，那么通过这样的方法就可以减小这些噪声的影响。

   而中值滤波的大体思路还是和这个方法差不多，需要从原图中提取出矩阵，在对这个矩阵排个序，取中位数做个这个点的像素值。

   而还有很多的平滑算法是通过做卷积来实现平滑的，常用的模板如下:

  

   如下：

  

   以下是一个简单的样例，用其中一个模板做卷积运算的平滑：

#平滑
def Filter():
    fil = [ 0.1 , 0.1 , 0.1 ,
            0.1 , 0.2 , 0.1 ,
            0.1 , 0.1 , 0.1 ]
    image = originalImage.convert('L');
    h,w = image.size
    opix = image.load()
    processImage = Image.new('L' , (h , w))
    npix = processImage.load()
    for i in range(h):
        for j in range (w):
            f11 = opix[abs(i - 1) , abs(j - 1)]
            f12 = opix[abs(i - 1) , j]
            if j != w - 1:
                f13 = opix[abs(i - 1) , j + 1]
            else:
                f13 = opix[abs(i - 1) , j]
            f21 = opix[i , abs(j - 1)]
            f22 = opix[i , j]
            if j != w - 1:
                f23 = opix[i , j + 1]
            else :
                f23 = opix[i , j]
            if i != h - 1:
                f31 = opix[i + 1 , abs(j - 1)]
            else:
                f31 = opix[i , abs(j - 1)]
            if i != h - 1:
                f32 = opix[i + 1 , j]
            else:
                f32 = opix[i , j]
            if i != h - 1 and j != w - 1:
                f33 = opix[i + 1 , j + 1]
            else :
                f33 = opix[i , j]
            temp = f11 * fil[0] + f12 * fil[1] + f13 * fil[2] + f21 * fil[3] + f22 * fil[4] + f23 * fil[5] + f31 * fil[6] + f32 * fil[7] + f33 * fil[8]
            temp = int(temp)
            if temp >= 255:
                temp = 255
            if temp <= 0:
                temp = 0
            npix[i,j] = temp

    做法也比较简单，注意边缘点的处理就好，我这个边缘点处理得不太好。

    效果图是从别的地方找来比较明显的图，我的处理达不到这样的效果。

　

   

    锐化：

     锐化大概是指强化图像中物体的边缘或者轮廓的方法。由于边缘轮廓常常位于图像突变的交界处，所以可以使用灰度差分的方法来得到边缘。

     锐化的算法也很多，比如梯度锐化法，罗伯茨差分，拉普拉斯算子，高通滤波，prewitt算子，lsotropic算子算子等。

     这儿我以简单的拉普拉斯算子为例讲解。

     对于一个连续的二元函数f(x,y),其拉普拉斯算子定义为：

 

     对于离散的数字图像，可以表示为：

     那么就相当于与下面这个模板做一次卷积：

  

     以下是一个简单的拉普拉斯算子的锐化代码：

#锐化
def sharpening1():
    lap = [  0 ,  -1  ,  0 ,
            -1 ,   4  , -1 ,
             0 ,  -1  ,  0 ]
    image = originalImage.convert('L');
    h,w = image.size
    opix = image.load()
    processImage = Image.new('L' , (h,w))
    npix = processImage.load()
    for i in range(h):
        for j in range(w):
            f22 = opix[i , j]
            f12 = opix[abs(i - 1) , j]
            f21 = opix[i , abs(j - 1)]
            if (j != w - 1):
                f23 = opix[i , j + 1]
            else:
                f23 = 0
            if (i != h - 1 and j != w - 1):
                f32 = opix[i + 1 , j + 1]
            else:
                f32 = 0
            temp = (f22 * lap[4]) + (f12 * lap[1]) + (f21 * lap[3]) + (f23 * lap[5]) + (f32 * lap[7])
            if temp >= 255:
                temp = 255
            if temp <= 0:
                temp = 0
            npix[i,j] = temp;

    以下是效果图：