Python+opencv学习记录21:膨胀与腐蚀

1.原理

腐蚀与膨胀是最基本的两个形态学操作,它们的作用有:
1.消除噪声;
2.分割独立的图像元素,以及连接相邻的元素;
3.寻找图像中的明显的极大值区域或极小值区域。

1.1膨胀

膨胀将图像A与任意形状的内核B(通常为正方形或圆形)进行卷积,内核B有一个可定义的锚点,通常定义为内核中心点,在进行此操作时,将内核 B 划过图像,将内核 B 覆盖区域的最大相素值提取,并代替锚点位置的相素。显然,这一最大化操作将会导致图像中的亮区开始”扩展” (因此有了术语膨胀 dilation )。

1.2腐蚀

腐蚀在形态学操作家族里是膨胀操作的孪生姐妹,它提取的是内核覆盖下的相素最小值,进行此操作时,将内核 B 划过图像,将内核 B 覆盖区域的最小相素值提取,并代替锚点位置的相素。这一操作会导致图像中的亮区“缩小”(因此有了术语腐蚀erosion)。

2.相应的代码

在进行腐蚀与膨胀时,我们会用到erode和dilate两个API。

2.1腐蚀操作

进行腐蚀操作的步骤为:
1.将图像转换为灰度图像;
2.将灰度图像转换为二值化图像;
3.获取图像结构元素;
4.进行腐蚀;
其对应代码如下:

def erode_demo(image):
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU)  # 用大律法、全局自适应阈值方法进行图像二值化
    cv.imshow("binary_image", binary)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))        # 获取图像结构元素
    dst = cv.erode(binary, kernel)      # 腐蚀
    cv.imshow("erode_demo", dst)

原图为:
在这里插入图片描述
经过二值化后:
在这里插入图片描述
经过腐蚀操作后:
在这里插入图片描述
可以明显地看出,经过腐蚀后,图像的黑色区域扩展了很多。

2.2膨胀操作

进行膨胀操作的步骤为:
1.将图像转换为灰度图像;
2.将灰度图像转换为二值化图像;
3.获取图像结构元素;
4.进行膨胀;
其代码如下:

def dilate_demo(image):
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU)
    cv.imshow("binary_image", binary)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
    dst = cv.dilate(binary, kernel)         # 膨胀
    cv.imshow("dilate_dmeo", dst)

经过膨胀操作后的结果为:
在这里插入图片描述
由图可以看出经过膨胀后的图像黑色区域缩减了很多。

3.彩色图像的膨胀与腐蚀

除了二值化图像以外,彩色图像也可以进行腐蚀与膨胀。
其代码为:

kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
dst = cv.dilate(src, kernel)         # 膨胀
# dst = cv.erode(src, kernel)          # 腐蚀
cv.imshow("output_image", dst)

原图为:
在这里插入图片描述
经过腐蚀后:
在这里插入图片描述
经过膨胀后:
在这里插入图片描述
可以看出,彩色图像经过腐蚀后整体的亮度变暗,而经过膨胀后整体亮度变亮。

完整代码

import cv2 as cv  # 导入opencv模块
import numpy as np  # 导入数学函数库


def erode_demo(image):
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU)  # 用大律法、全局自适应阈值方法进行图像二值化
    cv.imshow("binary_image", binary)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))        # 获取图像结构元素
    dst = cv.erode(binary, kernel)      # 腐蚀
    cv.imshow("erode_demo", dst)


def dilate_demo(image):
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU)
    cv.imshow("binary_image", binary)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
    dst = cv.dilate(binary, kernel)         # 膨胀
    cv.imshow("dilate_dmeo", dst)


print("------------hello python!------------")

src = cv.imread("D:/opencv3/image/mds.jpg")
cv.namedWindow("input_image", cv.WINDOW_AUTOSIZE)
cv.imshow("input_image", src)
# erode_demo(src)
# dilate_demo(src)
# 彩色图像的腐蚀或膨胀
kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
dst = cv.dilate(src, kernel)         # 膨胀
# dst = cv.erode(src, kernel)          # 腐蚀
cv.imshow("output_image", dst)

cv.waitKey(0)
cv.destroyAllWindows()  # 释放所有窗口

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
要将迷宫图片数字化,您需要执行以下步骤: 1. 使用OpenCV加载迷宫图像并将其转换为灰度图像。 2. 对图像进行二值化,以便仅包含黑色和白色像素。 3. 使用形态学转换(例如膨胀腐蚀)来填充迷宫中的空隙并消除不必要的噪声。 4. 找到迷宫的入口和出口。这可以通过查找外轮廓并选择最长的两个轮廓来完成。 5. 使用霍夫线变换找到迷宫中的所有水平和垂直线。 6. 使用线段交点检测找到所有交点。 7. 将交点与入口和出口相匹配。 8. 创建一个表示迷宫的矩阵,其中表示墙壁的像素被设置为1,表示通道的像素被设置为0。 9. 根据找到的交点和线段,将墙壁添加到矩阵中。 10. 使用路径搜索算法(例如广度优先搜索或Dijkstra算法)找到从入口到出口的最短路径。 以下是一个示例代码,演示了如何实现这些步骤: ``` python import cv2 import numpy as np # Load the maze image and convert it to grayscale maze = cv2.imread('maze.png') gray = cv2.cvtColor(maze, cv2.COLOR_BGR2GRAY) # Threshold the image to get a binary image thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1] # Apply morphological transformations to fill gaps and remove noise kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)) thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel) # Find the contours of the maze and select the two longest contours contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) contours = sorted(contours, key=cv2.contourArea, reverse=True)[:2] # Find the entrance and exit points of the maze entrance, exit = None, None for contour in contours: x, y, w, h = cv2.boundingRect(contour) if w > 2 * h: if entrance is None or x < entrance[0]: entrance = (x, y) if exit is None or x > exit[0]: exit = (x, y) elif h > 2 * w: if entrance is None or y < entrance[1]: entrance = (x, y) if exit is None or y > exit[1]: exit = (x, y) # Detect horizontal and vertical lines in the maze edges = cv2.Canny(thresh, 50, 150) lines = cv2.HoughLines(edges, 1, np.pi / 180, 150) horizontal_lines, vertical_lines = [], [] for line in lines: rho, theta = line[0] a, b = np.cos(theta), np.sin(theta) x0, y0 = a * rho, b * rho if abs(a) < 0.1: # Vertical line vertical_lines.append((int(x0), int(y0))) elif abs(b) < 0.1: # Horizontal line horizontal_lines.append((int(x0), int(y0))) # Find the intersection points of the lines intersections = [] for hl in horizontal_lines: for vl in vertical_lines: x, y = int(vl[0]), int(hl[1]) intersections.append((x, y)) # Match the entrance and exit points to the nearest intersection point entrance = min(intersections, key=lambda p: np.linalg.norm(np.array(p) - np.array(entrance))) exit = min(intersections, key=lambda p: np.linalg.norm(np.array(p) - np.array(exit))) # Create a matrix representation of the maze maze_matrix = np.zeros(gray.shape[:2], dtype=np.uint8) for hl in horizontal_lines: x0, y0 = hl for vl in vertical_lines: x1, y1 = vl if x1 <= x0 + 5 and x1 >= x0 - 5 and y1 <= y0 + 5 and y1 >= y0 - 5: # This is an intersection point maze_matrix[y1, x1] = 0 elif x1 < x0: # This is a vertical wall maze_matrix[y1, x1] = 1 elif y1 < y0: # This is a horizontal wall maze_matrix[y1, x1] = 1 # Find the shortest path from the entrance to the exit using BFS queue = [(entrance[1], entrance[0])] visited = np.zeros(maze_matrix.shape[:2], dtype=np.bool) visited[entrance[1], entrance[0]] = True prev = np.zeros(maze_matrix.shape[:2], dtype=np.int32) while queue: y, x = queue.pop(0) if (y, x) == exit: # We have found the shortest path break for dy, dx in [(1, 0), (-1, 0), (0, 1), (0, -1)]: ny, nx = y + dy, x + dx if ny >= 0 and ny < maze_matrix.shape[0] and nx >= 0 and nx < maze_matrix.shape[1] \ and maze_matrix[ny, nx] == 0 and not visited[ny, nx]: queue.append((ny, nx)) visited[ny, nx] = True prev[ny, nx] = y * maze_matrix.shape[1] + x # Reconstruct the shortest path path = [] y, x = exit while (y, x) != entrance: path.append((y, x)) p = prev[y, x] y, x = p // maze_matrix.shape[1], p % maze_matrix.shape[1] path.append((y, x)) path.reverse() # Draw the shortest path on the maze image output = maze.copy() for i in range(len(path) - 1): cv2.line(output, path[i][::-1], path[i + 1][::-1], (0, 0, 255), 2) # Display the output image cv2.imshow('Output', output) cv2.waitKey(0) cv2.destroyAllWindows() ``` 此示例代码假定您的迷宫是一个黑色的正方形,并且在其中只有一个入口和一个出口。如果您的迷宫有其他形状或有多个入口/出口,则需要根据需要进行修改。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值