图像分割恢复方法

weixin_45734021

已于 2024-10-07 22:28:21 修改

阅读量812

点赞数 6

文章标签： opencv 计算机视觉人工智能

于 2024-10-07 22:02:55 首次发布

本文链接：https://blog.csdn.net/weixin_45734021/article/details/142746027

版权

传统的图像分割方法主要依赖于图像的灰度值、纹理、颜色等特征，通过不同的算法将图像分割成多个区域。这些方法通常可以分为以下几类：
1.基于阈值的方法
2.基于边缘的方法
3.基于区域的方法
4.基于聚类的方法
下面详细介绍这些方法及其示例代码。

1. 基于阈值的方法

基于阈值的方法是最简单的图像分割方法之一，通过设定一个或多个阈值，将图像分为前景和背景。

示例代码（全局阈值）

import cv2
import numpy as np
from matplotlib import pyplot as plt

# 读取灰度图像
image = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

# 应用全局阈值分割
_, thresh = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

# 显示结果
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image, cmap='gray')

plt.subplot(1, 2, 2)
plt.title('Global Thresholding')
plt.imshow(thresh, cmap='gray')

plt.show()

示例代码（Otsu’s 阈值）

_, otsu_thresh = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image, cmap='gray')

plt.subplot(1, 2, 2)
plt.title('Otsu Thresholding')
plt.imshow(otsu_thresh, cmap='gray')

plt.show()

2. 基于边缘的方法

基于边缘的方法通过检测图像中的边缘，将图像分割成不同的区域。
示例代码（Canny 边缘检测）

edges = cv2.Canny(image, 100, 200)

plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image, cmap='gray')

plt.subplot(1, 2, 2)
plt.title('Edge Detection')
plt.imshow(edges, cmap='gray')

plt.show()

3. 基于区域的方法

基于区域的方法通过区域生长、区域合并等算法，根据像素相似性将图像分割成不同的区域。
示例代码（区域生长）

import cv2
import numpy as np
from matplotlib import pyplot as plt

def region_growing(img, seed):
    h, w = img.shape
    segmented_img = np.zeros_like(img)
    stack = [seed]
    while len(stack) > 0:
        x, y = stack.pop()
        if segmented_img[x, y] == 0 and img[x, y] > 128:
            segmented_img[x, y] = 255
            if x > 0:
                stack.append((x - 1, y))
            if x < h - 1:
                stack.append((x + 1, y))
            if y > 0:
                stack.append((x, y - 1))
            if y < w - 1:
                stack.append((x, y + 1))
    return segmented_img

# 读取灰度图像
image = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

seed = (100, 100)  # 种子点
segmented_img = region_growing(image, seed)

plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image, cmap='gray')
plt.subplot(1, 2, 2)
plt.title('Region Growing')
plt.imshow(segmented_img, cmap='gray')
plt.show()

4. 基于聚类的方法

基于聚类的方法通过聚类算法（如K均值聚类）将图像中的像素分为不同的簇，从而实现图像分割。
示例代码（K均值聚类）

import cv2
import numpy as np
from matplotlib import pyplot as plt

# 读取图像并转换为二维数据
image = cv2.imread('image.jpg')
Z = image.reshape((-1, 3))
Z = np.float32(Z)

# 定义K均值参数
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
K = 3
ret, label, center = cv2.kmeans(Z, K, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)

# 转换回uint8数据类型，并重塑回原始图像
center = np.uint8(center)
res = center[label.flatten()]
segmented_image = res.reshape((image.shape))

# 显示结果
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))

plt.subplot(1, 2, 2)
plt.title('Segmented Image (K = 3)')
plt.imshow(cv2.cvtColor(segmented_image, cv2.COLOR_BGR2RGB))

plt.show()

5. 基于图论的方法

基于图论的方法通过将图像看作一个图，其中像素是图的节点，边的权重表示像素之间的相似性。常见的图论方法有图割算法（Graph Cut）和分水岭算法（Watershed）。

分水岭算法步骤

预处理：为了减小噪声影响，通常对图像进行平滑处理。
计算梯度：使用梯度运算子（如Sobel算子）计算图像的梯度，得到梯度幅值图。
标记前景和背景：通过一些方法（如阈值分割或形态学操作）对前景和背景进行标记。
应用分水岭算法：基于标记的前景和背景，对图像应用分水岭算法进行分割。

详细代码实现
以下是一个详细的Python代码示例，展示如何使用OpenCV实现分水岭算法进行图像分割：

import cv2
import numpy as np
from matplotlib import pyplot as plt

# 读取图像
image = cv2.imread('image.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 1. 预处理：平滑图像，减小噪声
blurred = cv2.GaussianBlur(gray, (5, 5), 0)

# 2. 计算梯度
grad_x = cv2.Sobel(blurred, cv2.CV_64F, 1, 0, ksize=3)
grad_y = cv2.Sobel(blurred, cv2.CV_64F, 0, 1, ksize=3)
gradient = cv2.addWeighted(grad_x, 0.5, grad_y, 0.5, 0)

# 3. 二值化
_, binary = cv2.threshold(gradient, 50, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)

# 4. 形态学操作，去除小块噪声
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
closed = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel, iterations=2)

# 5. 距离变换
dist_transform = cv2.distanceTransform(closed, cv2.DIST_L2, 5)
_, sure_fg = cv2.threshold(dist_transform, 0.7 * dist_transform.max(), 255, 0)
sure_fg = np.uint8(sure_fg)
unknown = cv2.subtract(closed, sure_fg)

# 6. 标记前景和背景
_, markers = cv2.connectedComponents(sure_fg)

# 增加1，以便背景为1
markers = markers + 1

# 未知区域标记为0
markers[unknown == 255] = 0

# 7. 应用分水岭算法
markers = cv2.watershed(image, markers)
image[markers == -1] = [0, 0, 255]

# 显示结果
plt.subplot(2, 2, 1), plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)), plt.title('Original Image')
plt.subplot(2, 2, 2), plt.imshow(gradient, cmap='gray'), plt.title('Gradient')
plt.subplot(2, 2, 3), plt.imshow(closed, cmap='gray'), plt.title('Closed')
plt.subplot(2, 2, 4), plt.imshow(markers, cmap='gray'), plt.title('Markers')
plt.show()

代码解释
1.读取图像和预处理：

读取图像并转换为灰度图。
使用高斯模糊平滑图像，减小噪声。

2.计算梯度：

使用Sobel算子计算图像的梯度。
将x方向和y方向的梯度组合在一起，得到梯度幅值图。

3.二值化：

使用全局阈值（Otsu方法）对梯度图进行二值化。

4.形态学操作：

使用闭运算去除小块噪声，填补前景对象中的小孔。

5.距离变换：

计算前景对象的距离变换。
根据距离变换结果，确定前景对象的中心区域。

6.标记前景和背景：

使用连通组件标记前景区域。
增加1，使背景标记为1，前景标记为2，3，4，……

7.应用分水岭算法：

将未标记的未知区域标记为0。
应用分水岭算法进行图像分割，标记边缘区域为-1。

显示结果：

使用Matplotlib显示原始图像、梯度图、形态学处理结果和分水岭标记结果。

通过以上步骤，可以实现对图像的分水岭分割。该方法在处理复杂形状和具有噪声的图像时表现较好。
另外一个分水岭分割代码:


import cv2
import numpy as np
from matplotlib import pyplot as plt

#获取背景 
# 1. 通过二值法得到黑白图片
# 2. 通过形态学获取背景

img = cv2.imread('water_coins.jpeg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

ret, thresh =cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

#开运算
kernel = np.ones((3,3), np.int8)
open1 = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations = 2)

#膨胀
bg = cv2.dilate(open1, kernel, iterations = 1)

#获取前景物体
dist = cv2.distanceTransform(open1, cv2.DIST_L2, 5)

ret, fg = cv2.threshold(dist,0.7*dist.max(), 255, cv2.THRESH_BINARY)

# plt.imshow(dist, cmap='gray')
# plt.show()
# exit()

#获取未知区域
fg = np.uint8(fg)
unknow = cv2.subtract(bg, fg)

#创建连通域
ret, marker = cv2.connectedComponents(fg)

marker = marker + 1
marker[unknow==255] = 0

#进行图像分割
result = cv2.watershed(img, marker)

img[result == -1] = [0, 0, 255]

cv2.imshow("img", img)
cv2.imshow("unknow", unknow)
cv2.imshow("fg", fg)
cv2.imshow("bg", bg)
cv2.imshow("thresh", thresh)
cv2.waitKey()

下面是图片：

6. 基于直方图的方法

基于直方图的方法利用图像的灰度或颜色直方图进行分割，如图像分割中的Mean-Shift算法。
示例代码（直方图均衡化）

import cv2
from matplotlib import pyplot as plt

# 读取灰度图像
image = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

# 应用直方图均衡化
equalized_image = cv2.equalizeHist(image)

# 显示结果
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image, cmap='gray')

plt.subplot(1, 2, 2)
plt.title('Histogram Equalization')
plt.imshow(equalized_image, cmap='gray')

plt.show()

7. 基于pyrMeanShiftFiltering分割

pyrMeanShiftFiltering示例代码

import cv2
import numpy as np

img = cv2.imread('key.png')

mean_img = cv2.pyrMeanShiftFiltering(img, 20, 30)

imgcanny = cv2.Canny(mean_img, 150, 300)

contours, _ = cv2.findContours(imgcanny, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

cv2.drawContours(img, contours, -1, (0, 0, 255), 2)

cv2.imshow('img', img)
cv2.imshow('mean_img', mean_img)
cv2.imshow('canny', imgcanny)
cv2.waitKey()

7. 基于GrabCut算法进行前景分割

GrabCut示例代码

import cv2
import numpy as np

class App:

    flag_rect = False
    rect=(0, 0, 0, 0)
    startX = 0
    startY = 0

    def onmouse(self, event, x, y, flags, param):

        if event == cv2.EVENT_LBUTTONDOWN:
            self.flag_rect = True
            self.startX = x
            self.startY = y
            print("LBUTTIONDOWN")
        elif event == cv2.EVENT_LBUTTONUP:
            self.flag_rect = False
            cv2.rectangle(self.img, 
                            (self.startX, self.startY),
                            (x, y),
                            (0, 0, 255), 
                            3)
            self.rect = (min(self.startX, x), min(self.startY, y), 
                        abs(self.startX - x), 
                        abs(self.startY -y))

            print("LBUTTIONUP")
        elif event == cv2.EVENT_MOUSEMOVE:
            if self.flag_rect == True:
                self.img = self.img2.copy()
                cv2.rectangle(self.img, 
                                (self.startX, self.startY),
                                (x, y),
                                (255, 0, 0), 
                                3)
            print("MOUSEMOVE")  

        print("onmouse")

    def run(self):
        print("run...")

        cv2.namedWindow('input')
        cv2.setMouseCallback('input', self.onmouse)

        self.img = cv2.imread('./flower.png')
        self.img2 = self.img.copy()
        self.mask = np.zeros(self.img.shape[:2], dtype=np.uint8)
        self.output = np.zeros(self.img.shape, np.uint8)

        while(1):
            cv2.imshow('input', self.img)
            cv2.imshow('output', self.output)
            k = cv2.waitKey(100)
            if k == 27:
                break

            if k == ord('g'):
                bgdmodel = np.zeros((1, 65), np.float64)
                fgdmodel = np.zeros((1, 65), np.float64)
                cv2.grabCut(self.img2, self.mask, self.rect,
                            bgdmodel, fgdmodel,
                            1, 
                            cv2.GC_INIT_WITH_RECT)
            mask2 = np.where((self.mask==1)|(self.mask==3), 255, 0).astype('uint8')
            self.output = cv2.bitwise_and(self.img2, self.img2, mask=mask2)   
           
App().run()

这段代码允许用户通过鼠标在图像上绘制矩形框，并通过GrabCut算法进行前景分割。在运行过程中，用户可以通过鼠标操作绘制矩形，并通过按下g键触发分割算法。

8.视频背景分割：

视频背景分割有三种方法：

cv2.bgsegm.createBackgroundSubtractorMOG()
cv2.createBackgroundSubtractorMOG2()
cv2.bgsegm.createBackgroundSubtractorGMG()

1.cv2.bgsegm.createBackgroundSubtractorMOG()基于高斯混合模型（Mixture of Gaussians, MOG）的背景减法器。它是OpenCV中的一个较早实现版本。
特点：

使用高斯混合模型来表示背景。
对于每个像素，使用多个高斯分布来建模。
更适合静态背景和较慢的场景变化。
特点：
使用高斯混合模型来表示背景。
对于每个像素，使用多个高斯分布来建模。
更适合静态背景和较慢的场景变化。

2.cv2.createBackgroundSubtractorMOG2()这个函数创建了MOG2背景减法器，是对MOG的改进版本。它是OpenCV中默认和推荐的背景减法方法。
特点：

改进的高斯混合模型，能够自动调整模型中的高斯分布数量。
更加鲁棒，能够更好地处理光照变化和场景中的噪声。
提供阴影检测功能。

3.cv2.bgsegm.createBackgroundSubtractorGMG()这个函数创建了基于统计渐变的背景减法器（GMG）。
特点：

使用逐像素贝叶斯分段和统计渐变。
需要一定数量的初始帧来建立背景模型。
对于处理动态背景和复杂场景非常有效，但初始化较慢。

import cv2
import numpy as np

cap = cv2.VideoCapture('./vtest.avi')
#mog = cv2.bgsegm.createBackgroundSubtractorMOG()
# mog = cv2.createBackgroundSubtractorMOG2()
mog = cv2.bgsegm.createBackgroundSubtractorGMG()

while(True):
    ret, frame = cap.read()
    fgmask = mog.apply(frame)

    cv2.imshow('img',fgmask)

    k = cv2.waitKey(10) 
    if k ==27:
        break

cap.release()
cv2.destroyAllWindows()

9.图像恢复算法

图像恢复算法用于从损坏或降质的图像中恢复原始图像。常用的方法包括：

区域增长法（Region Growing）：基于区域扩展修复缺失部分。
纹理合成法（Texture Synthesis）：使用相邻区域的纹理填补缺失部分。
深度学习方法：如基于GAN的图像修复方法。

代码示例

import cv2
import numpy as np
img = cv2.imread('inpaint.png')
mask = cv2.imread('inpaint_mask.png', 0)
dst = cv2.inpaint(img, mask, 5, cv2.INPAINT_TELEA)
cv2.imshow('dst', dst)
cv2.imshow('img', img)
cv2.waitKey()