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

    这是第一篇关于图像处理的文章的第二部分。第一部分链接如下：

    https://mp.weixin.qq.com/s?__biz=MzU2NTUwNjQ1Mw==&mid=2247512720&idx=1&sn=35beb32c1cbf9c2f70d2b4d1dfd727e8&chksm=fcb84a6acbcfc37c66d2009e9e8d2be0b65439db0ce98d0c48eb3fe9baf06b1d4daf9e15d426&token=1759968597&lang=zh_CN#rd

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

    6、对比度增强

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

    1. xray = imread("images/xray.jpg")
    2. xray_gray = rgb2gray(xray)
    3.  
    4. compare(xray, xray_gray)
    accb62dbbd42059a327f2b15fc4e5627.png

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

    1. 对比度拉伸

    2. 直方图均衡化

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

    1. 标准直方图均衡化

    2. 自适应直方图均衡化

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

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

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

    1. >>> xray.max() - xray.min()
    2.  
    3. 255

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

    1. from skimage.exposure import equalize_hist
    2.  
    3. enhanced = equalize_hist(xray_gray)
    4.  
    5. >>> compare(xray, enhanced)
    41d4d69fd1cd37840e2a38778229cef1.png

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

    1. from skimage.exposure import equalize_hist
    2.  
    3. enhanced = equalize_hist(xray_gray)
    4.  
    5. >>> compare(xray, enhanced)

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

    1. from skimage.exposure import equalize_adapthist
    2.  
    3. # Adjust clip_limit
    4. enhanced_adaptive = equalize_adapthist(xray_gray, clip_limit=0.4)
    5.  
    6. compare(xray, enhanced_adaptive, "Image with contrast enhancement")
    b6e74b01d297c28fa9e7f5a9b7297a88.png

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

    7、变换

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

    旋转

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

    1. from skimage.transform import rotate
    2.  
    3. clock = imread("images/clock.jpg")
    4.  
    5. clockwise = rotate(clock, angle=-60)
    6. compare(clock, clockwise, "Clockwise rotated image, use negative angles")
    c8bac79a7ff3121547ed59358540919d.png 
    1. anti_clockwise = rotate(clock, angle=33)
    2.  
    3. compare(clock, anti_clockwise, "Anticlockwise rotated image, use positive angles")
    c9818503fd12e3b647bfac1f8b6d3b2f.png

    缩放

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

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

    1. butterflies = imread("images/butterflies.jpg")
    2.  
    3. >>> butterflies.shape
    4. (720, 1280, 3)
    1. from skimage.transform import rescale
    2.  
    3. scaled_butterflies = rescale(butterflies, scale=3 / 4, multichannel=True)
    4.  
    5. compare(
    6.     butterflies,
    7.     scaled_butterflies,
    8.     "Butterflies scaled down by a factor of 3/4",
    9.     axis=True,
    10. )
    905af930a0f50ee834acd9afdb51ef15.png

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

    https://gist.github.com/f7ae272b6eb1bce408189d8de2b71656

    a4014db63a56ee62f5e399bc325dbd00.png

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

    调整大小

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

    1. from skimage.transform import resize
    2.  
    3. puppies = imread("images/puppies.jpg")
    4.  
    5. # Also possible to set anti_aliasing
    6. puppies_600_800 = resize(puppies, output_shape=(600, 800))
    7.  
    8. compare(puppies, puppies_600_800, 
    9.         "Puppies image resized 600x800 (height, width)")
    c636eebf44603a40cbccc0de0e1bd0ec.png

    图像恢复和增强

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

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

    1、修补

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

    1. whale_image = imread("images/00206a224e68de.jpg")
    2.  
    3. >>> show(whale_image)
    696ba33718e801b6a6139028542db7d0.png 
    1. >>> whale_image.shape
    2.  
    3. (428, 1916, 3)

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

    1. def make_mask(image):
    2.     """Create a mask to artificially defect the image."""
    3.  
    4.     mask = np.zeros(image.shape[:-1])
    5.  
    6.     # Make 4 masks
    7.     mask[250:300, 1400:1600] = 1
    8.     mask[50:100, 300:433] = 1
    9.     mask[300:380, 1000:1200] = 1
    10.     mask[200:270, 750:950] = 1
    11.  
    12.     return mask.astype(bool)
    13.  
    14.  
    15. # Create the mask
    16. mask = make_mask(whale_image)
    17.  
    18. # Apply the defect mask on the whale_image
    19. image_defect = whale_image * ~mask[..., np.newaxis]
    20.  
    21. compare(whale_image, image_defect, "Artifically damaged image of a whale")
    a06af6334b732c815b1daba4c786b5bf.png

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

    1. from skimage.restoration import inpaint
    2.  
    3. restored_image = inpaint.inpaint_biharmonic(
    4.     image=image_defect, mask=mask, multichannel=True
    5. )
    6.  
    7. compare(
    8.     image_defect,
    9.     restored_image,
    10.     "Restored image after defects",
    11.     title_original="Faulty Image",
    12. )
    9ad448af8658688783b41ee7c33acc40.png

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

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

    2、噪声

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

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

    1. from skimage.util import random_noise
    2.  
    3. pup = imread("images/pup.jpg")
    4.  
    5. noisy_pup = random_noise(pup)
    6.  
    7. compare(pup, noisy_pup, "Noise puppy image")
    4a77853d462ba8b9d1ee24bfa09f2738.png

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

    3、降噪-去噪

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

    1. TV滤波器

    2. 双边去噪

    3. 小波降噪

    4. 非局部均值去噪

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

    1. from skimage.restoration import denoise_tv_chambolle
    2.  
    3. denoised_pup_tv = denoise_tv_chambolle(noisy_pup, weight=0.2, multichannel=True)
    4.  
    5. compare(
    6.     noisy_pup,
    7.     denoised_pup_tv,
    8.     "Total Variation Filter denoising applied",
    9.     title_original="Noisy pup",
    10. )
    bc34c77b705eb3046b551d56bcaf8e99.png

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

    现在，让我们尝试denoise_bilateral：

    1. from skimage.restoration import denoise_bilateral
    2.  
    3. denoised_pup_bilateral = denoise_bilateral(noisy_pup, multichannel=True)
    4.  
    5. compare(noisy_pup, denoised_pup_bilateral, "Bilateral denoising applied image")
    37af846c86ee9dae536a0d42d602feff.png

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

    1. compare(
    2.     denoised_pup_tv,
    3.     denoised_pup_bilateral,
    4.     "Bilateral filtering",
    5.     title_original="TV filtering",
    6. )
    e06a51e8ac116073a021be2d5d022680.png

    4、分割

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

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

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

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

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

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

    1. from skimage import data
    2.  
    3. coffee = data.coffee()
    4.  
    5. >>> show(coffee)
    6c7736dae8dfb3270f1425c68b58c18e.png

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

    1. from skimage.segmentation import slic
    2.  
    3. segments = slic(coffee)
    4.  
    5. >>> show(segments)
    4020c0b6071f1ed72f139de75900c194.png

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

    1. from skimage.color import label2rgb
    2.  
    3. final_image = label2rgb(segments, coffee, kind="avg")
    4.  
    5. >>> show(final_image)
    8feb8eda45a7357642cdb1a370cc2278.png

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

    1. from skimage.color import label2rgb
    2. from skimage.segmentation import slic
    3.  
    4. def segment(image, n_segments=100):
    5.     # Obtain superpixels / segments
    6.     superpixels = slic(coffee, n_segments=n_segments)
    7.  
    8.     # Put the groups on top of the original image
    9.     segmented_image = label2rgb(superpixels, image, kind="avg")
    10.  
    11.     return segmented_image
    12.     
    13. # Find 500 segments
    14. coffee_segmented_2 = segment(coffee, n_segments=500)
    15.  
    16. compare(coffee, coffee_segmented_2, "With 500 segments")
    ba6de0d3c811b8f02494ee4ea7121a60.png

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

    5、等高线

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

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

    1. dominoes = imread("images/dominoes.jpg")
    2.  
    3. >>> show(dominoes)
    6e910d5bd90065b5b7d5817b4f6133ad.png

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

    1. from skimage.measure import find_contours
    2.  
    3. # Convert to grayscale
    4. dominoes_gray = rgb2gray(dominoes)
    5. # Find optimal threshold with treshold_otsu
    6. thresh = threshold_otsu(dominoes_gray)
    7. # Binarize
    8. dominoes_binary = dominoes_gray > thresh
    9.  
    10. domino_contours = find_contours(dominoes_binary)

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

    1. for contour in domino_contours[:5]:
    2.     print(contour.shape)
    3.  
    4. [OUT]: 
    5.  
    6. (371, 2)
    7. (376, 2)
    8. (4226, 2)
    9. (177, 2)
    10. (11, 2)

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

    1. from skimage.filters import threshold_otsu
    2. from skimage.measure import find_contours
    3.  
    4. def mark_contours(image):
    5.     """A function to find contours from an image"""
    6.     gray_image = rgb2gray(image)
    7.     # Find optimal threshold
    8.     thresh = threshold_otsu(gray_image)
    9.     # Mask
    10.     binary_image = gray_image > thresh
    11.  
    12.     contours = find_contours(binary_image)
    13.  
    14.     return contours

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

    1. def plot_image_contours(image):
    2.     fig, ax = plt.subplots()
    3.  
    4.     ax.imshow(image, cmap=plt.cm.gray)
    5.  
    6.     for contour in mark_contours(image):
    7.         ax.plot(contour[:, 1], contour[:, 0], linewidth=2, color="red")
    8.  
    9.     ax.axis("off")
    10.  
    11. >>> plot_image_contours(dominoes)
    b89e4b6ddc12c88a4efa37183159db43.png

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

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

    1. dominoes_denoised = denoise_tv_chambolle(dominoes, multichannel=True)
    2.  
    3. plot_image_contours(dominoes_denoised)
    aca900a24e2f3adb1ca086997637bbd8.png

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

    高级操作

    1、边缘检测

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

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

    1. coins_3 = imread("images/coins_3.jpg")
    2.  
    3. # Convert to gray
    4. coins_3_gray = rgb2gray(coins_3)
    5.  
    6. compare(coins_3, coins_3_gray)
    0166de0408abb08a63f5ffd5e6d5d8c2.png

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

    1. from skimage.feature import canny
    2.  
    3. # Find edges with canny
    4. canny_edges = canny(coins_3_gray)
    5.  
    6. compare(coins_3, canny_edges, "Edges detected with Canny algorithm")
    e71b8619aa30ca9ad95ad85d86e0ad75.png

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

    1. canny_edges_sigma_2 = canny(coins_3_gray, sigma=2.5)
    2.  
    3. compare(coins_3, canny_edges_sigma_2, "Edges detected with less intensity")
    aba42a1c1dcb5607a5418030abdacad4.png

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

    2、角点检测

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

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

    1. windows = imread("images/windows.jpg")
    2.  
    3. windows_gray = rgb2gray(windows)
    4.  
    5. compare(windows, windows_gray)
    0265ec134bdd02a64284a58a629c488b.png

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

    1. from skimage.feature import corner_harris
    2.  
    3. measured_image = corner_harris(windows_gray)
    4.  
    5. >>> show(measured_image)
    fc8e4733ba473b6997f3e09d7fcd5791.png

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

    1. from skimage.feature import corner_peaks
    2.  
    3. corner_coords = corner_peaks(measured_image, min_distance=50)
    4.  
    5. >>> len(corner_coords)
    6.  
    7. 79

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

    1. def find_corner_coords(image, min_distance=50):
    2.     
    3.     # Convert to gray
    4.     
    5.     gray_image = rgb2gray(image)
    6.     
    7.     # Produce a measure image
    8.     
    9.     measure_image = corner_harris(gray_image)
    10.  
    11.     # Find coords
    12.     
    13.     coords = corner_peaks(measure_image, min_distance=min_distance)
    14.  
    15.     return coords

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

    1. def show_image_cornered(image):
    2.     # Find coords
    3.     coords = find_corner_coords(image)
    4.  
    5.     # Plot them on top of the image
    6.     plt.imshow(image, cmap="gray")
    7.     plt.plot(coords[:, 1], coords[:, 0], "+b", markersize=15)
    8.     plt.axis("off")
    9.  
    10. show_image_cornered(windows)
    d433defac06b89fca2bf936a503a1fbc.png

    不幸的是，该算法没有按预期工作。标记放置在砖的交叉处，而不是找到窗角。

    这些是噪音，使它们毫无用处。让我们对图像进行去噪处理，并再次将其传递给函数：

    1. windows_denoised = denoise_tv_chambolle(windows, multichannel=True, weight=0.3)
    2.  
    3. show_image_cornered(windows_denoised)
    11185a5eb121fed4271a1e6fd3bcc56c.png

    现在，这好多了！它找到了大部分窗户角。

    结论

    在真正的计算机视觉问题中，你不会同时使用所有这些。正如你可能已经注意到的，我们今天学到的东西并不复杂，最多需要几行代码。棘手的部分是将它们应用于实际问题，并实际提高模型的性能。

    感谢阅读！

    ☆ END ☆

    如果看到这里，说明你喜欢这篇文章，请转发、点赞。微信搜索「uncle_pn」，欢迎添加小编微信「 woshicver」，每日朋友圈更新一篇高质量博文。

    ↓扫描二维码添加小编↓

    c163809676318c35b94af50415e82611.jpeg

  • 相关阅读:
    P1036 [NOIP2002 普及组] 选数
    上周热点回顾（10.31-11.6）
    【错误记录】安装 Hadoop 运行环境报错 ( Error: JAVA_HOME is incorrectly set. Please update xxx\hadoop-env.cmd )
    Rabbitmq----分布式场景下的应用
    代码随想录第14天 | ● 300.最长递增子序列 ● 674. 最长连续递增序列 ● 718. 最长重复子数组
    十八、字符串（1）
    2022年全国大学生数学建模竞赛E题目-小批量物料生产安排详解+思路+Python代码时序预测模型(二)
    Element封装Table和Pagination
    ConcurrentHashMap
    他们在学校里不会教你的编程原则
  • 原文地址：https://blog.csdn.net/woshicver/article/details/125924018