关于图像处理和Python深度学习的教程：第二部分

2022-07-22 11:14

磐创AI

关注

我们将以对比度增强开始第二部分。

6、对比度增强

某些类型的图像（如医学分析结果）对比度较低，很难发现细节，如下所示：

xray ＝ imread（＂images／xray．jpg＂）
xray＿gray ＝ rgb2gray（xray）
compare（xray， xray＿gray）

在这种情况下，我们可以使用对比度增强使细节更加清晰。有两种对比度增强算法：

对比度拉伸

直方图均衡化

我们将在这篇文章中讨论直方图均衡化，它又有三种类型：

标准直方图均衡化

自适应直方图均衡化

对比度受限自适应直方图均衡化（CLAHE）

直方图均衡化将图像对比度最高的区域扩展到亮度较低的区域，使其均衡。

你可以通过从最高的像素值中减去最低的像素值来计算图像的对比度。

＞＞＞ xray．max（）－ xray．min（）
255

现在，让我们尝试exposure模块中的标准直方图均衡化：

from skimage．exposure import equalize＿hist
enhanced ＝ equalize＿hist（xray＿gray）
＞＞＞ compare（xray， enhanced）

我们已经可以更清楚地看到细节了。

from skimage．exposure import equalize＿hist
enhanced ＝ equalize＿hist（xray＿gray）
＞＞＞ compare（xray， enhanced）

接下来，我们将使用CLAHE，它为图像中的不同像素邻域计算许多直方图，即使在最暗的区域也会得到更详细的信息：

from skimage．exposure import equalize＿adapthist
       ＃ Adjust clip＿limit
       enhanced＿adaptive ＝ equalize＿adapthist（xray＿gray， clip＿limit＝0．4）
       compare（xray， enhanced＿adaptive，＂Image with contrast enhancement＂）

这个看起来好多了，因为它可以在背景中显示细节，在左下角显示更多缺失的肋骨。你可以调整clip＿limit以获得更多或更少的细节。

7、变换

数据集中的图像可能有几个相互冲突的特征，如不同的比例、未对齐的旋转等。ML和DL算法希望你的图片具有相同的形状和尺寸。因此，你需要学习如何修复它们。

旋转

要旋转图像，请使用“transform”模块中的“rotate”函数。

from skimage．transform import rotate
clock ＝ imread（＂images／clock．jpg＂）
clockwise ＝ rotate（clock， angle＝－60）
compare（clock， clockwise，＂Clockwise rotated image， use negative angles＂）

anti＿clockwise ＝ rotate（clock， angle＝33）
compare（clock， anti＿clockwise，＂Anticlockwise rotated image， use positive angles＂）

缩放

另一个标准操作是缩放图像。

我们对此操作使用rescale函数：

butterflies ＝ imread（＂images／butterflies．jpg＂）
       ＞＞＞ butterflies．shape
      （720， 1280， 3）
       from skimage．transform import rescale
       scaled＿butterflies ＝ rescale（butterflies， scale＝3 ／ 4， multichannel＝True）
       compare（
     butterflies，
     scaled＿butterflies，
     ＂Butterflies scaled down by a factor of 3／4＂，
     axis＝True，
        ）

当图像分辨率较高时，缩小可能会导致质量损失或像素不协调，从而产生意外的边或角。要考虑这种影响，可以将anti＿aliasing设置为True，它使用高斯平滑：

https：／／gist．github．com／f7ae272b6eb1bce408189d8de2b71656

与之前一样，平滑效果并不明显，但在更细粒度的级别上会更明显。

调整大小

如果希望图像具有特定的宽度和高度，而不是按系数缩放，可以通过提供output＿shape来使用resize函数：

from skimage．transform import resize
      puppies ＝ imread（＂images／puppies．jpg＂）
      ＃ Also possible to set anti＿aliasing
      puppies＿600＿800 ＝ resize（puppies， output＿shape＝（600， 800））
      compare（puppies， puppies＿600＿800，
＂Puppies image resized 600x800 （height， width）＂）

图像恢复和增强

在文件变换、错误下载或许多其他情况下，某些图像可能会失真、损坏或丢失。

在本节中，我们将讨论一些图像恢复技术，从修复开始。

1、修补

修复算法可以智能地填补图像中的空白。我找不到损坏的图片，因此我们将使用此鲸鱼图像并手动在其上放置一些空白：

whale＿image ＝ imread（＂images／00206a224e68de．jpg＂）
＞＞＞ show（whale＿image）

＞＞＞ whale＿image．shape
（428， 1916， 3）

以下函数创建四个变黑区域，以模拟图像上丢失的信息：

def make＿mask（image）：
      ＂＂＂Create a mask to artificially defect the image．＂＂＂
      mask ＝ np．zeros（image．shape［：－1］）
      ＃ Make 4 masks
      mask［250：300， 1400：1600］＝ 1
      mask［50：100， 300：433］＝ 1
      mask［300：380， 1000：1200］＝ 1
     mask［200：270， 750：950］＝ 1
     return mask．astype（bool）
        ＃ Create the mask
        mask ＝ make＿mask（whale＿image）
        ＃ Apply the defect mask on the whale＿image
        image＿defect ＝ whale＿image ＊～mask［．．．， np．newaxis］
        compare（whale＿image， image＿defect，＂Artifically damaged image of a whale＂）

我们将使用inpaint模块中的inpaint＿biharmonic函数来填充空白，并传递我们创建的掩码：

from skimage．restoration import inpaint
        restored＿image ＝ inpaint．inpaint＿biharmonic（
     image＝image＿defect， mask＝mask， multichannel＝True
        ）
        compare（
      image＿defect，
      restored＿image，
      ＂Restored image after defects＂，
      title＿original＝＂Faulty Image＂，
        ）

正如你所看到的，在看到故障图像之前，很难判断缺陷区域在哪里。

现在，让我们制造一些噪声

2、噪声

如前所述，噪声在图像增强和恢复中起着至关重要的作用。

有时，你可能会有意将其添加到如下图像中：

from skimage．util import random＿noise
        pup ＝ imread（＂images／pup．jpg＂）
        noisy＿pup ＝ random＿noise（pup）
        compare（pup， noisy＿pup，＂Noise puppy image＂）

我们使用random＿noise函数向图像喷洒随机的颜色斑点。因此，这种方法被称为“盐和胡椒（salt和 pepper）”技术。

3、降噪－去噪

但是，大多数情况下，你希望从图像中移除噪声，而不是添加噪声。有几种类型的去噪算法：

TV滤波器

双边去噪

小波降噪

非局部均值去噪

在本文中，我们将只看前两个。我们先试试TV滤波器

from skimage．restoration import denoise＿tv＿chambolle
        denoised＿pup＿tv ＝ denoise＿tv＿chambolle（noisy＿pup， weight＝0．2， multichannel＝True）
        compare（
      noisy＿pup，
     denoised＿pup＿tv，
     ＂Total Variation Filter denoising applied＂，
     title＿original＝＂Noisy pup＂，
        ）

图像的分辨率越高，去噪所需的时间就越长。可以使用权重参数控制去噪效果。

现在，让我们尝试denoise＿bilateral：

from skimage．restoration import denoise＿bilateral
denoised＿pup＿bilateral ＝ denoise＿bilateral（noisy＿pup， multichannel＝True）
compare（noisy＿pup， denoised＿pup＿bilateral，＂Bilateral denoising applied image＂）

它不如TV滤波器有效，如下所示：

compare（
      denoised＿pup＿tv，
      denoised＿pup＿bilateral，
      ＂Bilateral filtering＂，
      title＿original＝＂TV filtering＂，
        ）

4、分割

图像分割是图像处理中最基本和最日常的主题之一，它广泛应用于运动和目标检测、图像分类等许多领域。

我们已经看到了分割的一个实例—对图像进行阈值化以从前景中提取背景。

本节将学习更多内容，例如将图像分割为类似区域。

要开始分割，我们需要了解超级像素的概念。

一个像素本身只代表一小部分颜色，一旦与图像分离，单个像素将毫无用处。因此，分割算法使用对比度、颜色或亮度相似的多组像素，它们被称为超级像素。

一种试图找到超像素的算法是简单线性迭代聚类（SLIC），它使用k均值聚类。让我们看看如何在skimage库中提供的咖啡图像上使用它：

from skimage import data
coffee ＝ data．coffee（）
＞＞＞ show（coffee）

我们将使用segmentation模块中的slic函数：

from skimage．segmentation import slic
segments ＝ slic（coffee）
＞＞＞ show（segments）

默认情况下，slic会查找100个线段或标签。要将它们放回图像中，我们使用label2rgb函数：

from skimage．color import label2rgb
final＿image ＝ label2rgb（segments， coffee， kind＝＂avg＂）
＞＞＞ show（final＿image）

让我们将此操作包装在函数中，并尝试使用更多段：

from skimage．color import label2rgb
       from skimage．segmentation import slic
       def segment（image， n＿segments＝100）：
      ＃ Obtain superpixels ／ segments
      superpixels ＝ slic（coffee， n＿segments＝n＿segments）
      ＃ Put the groups on top of the original image
      segmented＿image ＝ label2rgb（superpixels， image， kind＝＂avg＂）
      return segmented＿image

        ＃ Find 500 segments
        coffee＿segmented＿2 ＝ segment（coffee， n＿segments＝500）
        compare（coffee， coffee＿segmented＿2，＂With 500 segments＂）

分割将使计算机视觉算法更容易从图像中提取有用的特征。

5、等高线

对象的大部分信息都存在于其形状中。如果我们能够检测出物体的线条或轮廓形状，我们就可以提取出有价值的数据。

让我们看看如何在实践中使用多米诺骨牌图像来寻找轮廓。

dominoes ＝ imread（＂images／dominoes．jpg＂）
＞＞＞ show（dominoes）

我们将看看是否可以使用skimage中的find＿contours函数来隔离瓷砖和圆。此函数需要一个二进制（黑白）图像，因此我们必须先对图像设置阈值。

from skimage．measure import find＿contours
        ＃ Convert to grayscale
       dominoes＿gray ＝ rgb2gray（dominoes）
       ＃ Find optimal threshold with treshold＿otsu
       thresh ＝ threshold＿otsu（dominoes＿gray）
      ＃ Binarize
       dominoes＿binary ＝ dominoes＿gray ＞ thresh
      domino＿contours ＝ find＿contours（dominoes＿binary）

生成的数组是（n，2）个数组的列表，表示等高线的坐标：

for contour in domino＿contours［：5］：
     print（contour．shape）
    ［OUT］：
    （371， 2）
    （376， 2）
    （4226， 2）
    （177， 2）
    （11， 2）

我们将把操作包装在一个名为mark＿contours的函数中：

from skimage．filters import threshold＿otsu
      from skimage．measure import find＿contours
       def mark＿contours（image）：
     ＂＂＂A function to find contours from an image＂＂＂
     gray＿image ＝ rgb2gray（image）
      ＃ Find optimal threshold
      thresh ＝ threshold＿otsu（gray＿image）
      ＃ Mask
      binary＿image ＝ gray＿image ＞ thresh
      contours ＝ find＿contours（binary＿image）
      return contours

要在图像上绘制等高线，我们将创建另一个名为plot＿image＿contours的函数，该函数使用上述函数：

def plot＿image＿contours（image）：
      fig， ax ＝ plt．subplots（）
      ax．imshow（image， cmap＝plt．cm．gray）
      for contour in mark＿contours（image）：
ax．plot（contour［：， 1］， contour［：， 0］， linewidth＝2， color＝＂red＂）
      ax．axis（＂off＂）
        ＞＞＞ plot＿image＿contours（dominoes）

正如我们所看到的，我们成功地检测到了大部分轮廓，但我们仍然可以看到中心的一些随机波动。

在将多米诺骨牌图像传递到轮廓查找函数之前，先进行去噪：

dominoes＿denoised ＝ denoise＿tv＿chambolle（dominoes， multichannel＝True）
plot＿image＿contours（dominoes＿denoised）

就是这样！我们消除了大部分噪声，这些噪声导致轮廓线不正确！

高级操作1、边缘检测

之前，我们使用Sobel算法来检测对象的边缘。在这里，我们将使用Canny算法，因为它更快、更准确，所以得到了更广泛的应用。一如既往，函数canny需要灰度图像。

这一次，我们将使用具有更多硬币的图像，因此需要检测更多边缘：

coins＿3 ＝ imread（＂images／coins＿3．jpg＂）
       ＃ Convert to gray
       coins＿3＿gray ＝ rgb2gray（coins＿3）
       compare（coins＿3， coins＿3＿gray）

要找到边缘，我们只需将图像传递给canny函数：

from skimage．feature import canny
       ＃ Find edges with canny
       canny＿edges ＝ canny（coins＿3＿gray）
       compare（coins＿3， canny＿edges，＂Edges detected with Canny algorithm＂）

该算法发现了几乎所有硬币的边缘，但由于硬币上的雕刻也被检测到，因此噪声非常大。我们可以通过调整sigma参数来降低canny的灵敏度：

canny＿edges＿sigma＿2 ＝ canny（coins＿3＿gray， sigma＝2．5）
compare（coins＿3， canny＿edges＿sigma＿2，＂Edges detected with less intensity＂）

正如你所见，Canny现在只找到了硬币的大致轮廓。

2、角点检测

另一种重要的图像处理技术是角点检测。角点可以是图像分类中对象的关键特征。

为了找到角点，我们将使用Harris角点检测算法。让我们加载一个示例图像并将其转换为灰度：

windows ＝ imread（＂images／windows．jpg＂）
windows＿gray ＝ rgb2gray（windows）
compare（windows， windows＿gray）

我们将使用corner＿harris函数生成一个测量图像，该图像屏蔽了角点所在的区域。

from skimage．feature import corner＿harris
measured＿image ＝ corner＿harris（windows＿gray）
＞＞＞ show（measured＿image）

现在，我们将此蒙版度量图像传递给corner＿peaks函数，该函数这次返回角点坐标：

from skimage．feature import corner＿peaks
       corner＿coords ＝ corner＿peaks（measured＿image， min＿distance＝50）
       ＞＞＞ len（corner＿coords）
       79

该函数找到79个角点。让我们将操作包装到函数中：

def find＿corner＿coords（image， min＿distance＝50）：

      ＃ Convert to gray

      gray＿image ＝ rgb2gray（image）

      ＃ Produce a measure image

      measure＿image ＝ corner＿harris（gray＿image）
     ＃ Find coords

      coords ＝ corner＿peaks（measure＿image， min＿distance＝min＿distance）
      return coords

现在，我们将创建另一个函数，该函数使用上述函数生成的坐标绘制每个角点：

def show＿image＿cornered（image）：
      ＃ Find coords
      coords ＝ find＿corner＿coords（image）
      ＃ Plot them on top of the image
      plt．imshow（image， cmap＝＂gray＂）
      plt．plot（coords［：， 1］， coords［：， 0］，＂＋b＂， markersize＝15）
      plt．axis（＂off＂）
       show＿image＿cornered（windows）