如何在 OpenCV 中检测线条？

问题描述：

我正在尝试检测停车场的线，如下所示。

我希望得到的是清晰的线条和交叉线中的 (x,y) 位置。但是结果并不理想。

我猜主要有两个原因：

1. 有些线条非常断或缺失。甚至人眼也能清楚地识别它们。尽管 HoughLine 可以帮助连接一些缺失的线条，但由于 HoughLine 有时会将不必要的线条连接在一起，所以我宁愿手动完成。

2. 有一些重复的行。

该工作的总体流程如下：

1. 选择一些特定的颜色（白色或黄色）

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

# white color mask
img = cv2.imread(filein)
#converted = convert_hls(img)
image = cv2.cvtColor(img,cv2.COLOR_BGR2HLS)
lower = np.uint8([0, 200, 0])
upper = np.uint8([255, 255, 255])
white_mask = cv2.inRange(image, lower, upper)
# yellow color mask
lower = np.uint8([10, 0,   100])
upper = np.uint8([40, 255, 255])
yellow_mask = cv2.inRange(image, lower, upper)
# combine the mask
mask = cv2.bitwise_or(white_mask, yellow_mask)
result = img.copy()
cv2.imshow("mask",mask) 

1. 重复膨胀和腐蚀，直到图像无法改变（参考）

height,width = mask.shape
skel = np.zeros([height,width],dtype=np.uint8)      #[height,width,3]
kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3,3))
temp_nonzero = np.count_nonzero(mask)
while(np.count_nonzero(mask) != 0 ):
    eroded = cv2.erode(mask,kernel)
    cv2.imshow("eroded",eroded)   
    temp = cv2.dilate(eroded,kernel)
    cv2.imshow("dilate",temp)
    temp = cv2.subtract(mask,temp)
    skel = cv2.bitwise_or(skel,temp)
    mask = eroded.copy()
 
cv2.imshow("skel",skel)
#cv2.waitKey(0)

1. 应用 canny 过滤线条，并使用 HoughLinesP 获取线条

edges = cv2.Canny(skel, 50, 150)
cv2.imshow("edges",edges)
lines = cv2.HoughLinesP(edges,1,np.pi/180,40,minLineLength=30,maxLineGap=30)
i = 0
for x1,y1,x2,y2 in lines[0]:
    i+=1
    cv2.line(result,(x1,y1),(x2,y2),(255,0,0),1)
print i

cv2.imshow("res",result)
cv2.waitKey(0)

我想知道为什么在选择某种颜色的第一步之后，线条会断开并带有噪音。我认为在这一步我们应该做一些事情来使断线成为一条完整、噪音较少的线。然后尝试应用一些东西来做 Canny 和 Hough 线。有什么想法吗？

解决方案 1：

这是我的管道，也许它可以给你一些帮助。

首先，获取灰度图像并进行高斯模糊处理。

img = cv2.imread('src.png')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

kernel_size = 5
blur_gray = cv2.GaussianBlur(gray,(kernel_size, kernel_size),0)

其次，利用Canny进行边缘检测。

low_threshold = 50
high_threshold = 150
edges = cv2.Canny(blur_gray, low_threshold, high_threshold)

然后使用 HoughLinesP 获取直线。您可以调整参数以获得更好的性能。

rho = 1  # distance resolution in pixels of the Hough grid
theta = np.pi / 180  # angular resolution in radians of the Hough grid
threshold = 15  # minimum number of votes (intersections in Hough grid cell)
min_line_length = 50  # minimum number of pixels making up a line
max_line_gap = 20  # maximum gap in pixels between connectable line segments
line_image = np.copy(img) * 0  # creating a blank to draw lines on

# Run Hough on edge detected image
# Output "lines" is an array containing endpoints of detected line segments
lines = cv2.HoughLinesP(edges, rho, theta, threshold, np.array([]),
                    min_line_length, max_line_gap)

for line in lines:
    for x1,y1,x2,y2 in line:
        cv2.line(line_image,(x1,y1),(x2,y2),(255,0,0),5)

最后，在 srcImage 上画出线条。

# Draw the lines on the  image
lines_edges = cv2.addWeighted(img, 0.8, line_image, 1, 0)

这是我的最后一次表演。

最终图像：

解决方案 2：

我不确定您到底在问什么，因为您的帖子中没有任何问题。

检测线段的一种优秀且强大的技术是 LSD（线段检测器），自 openCV 3 开始便可在 openCV 中使用。

以下是一些简单的基本 C++ 代码，可以轻松转换为 python：

int main(int argc, char* argv[])
{
    cv::Mat input = cv::imread("C:/StackOverflow/Input/parking.png");
    cv::Mat gray;
    cv::cvtColor(input, gray, CV_BGR2GRAY);


    cv::Ptr<cv::LineSegmentDetector> det;
    det = cv::createLineSegmentDetector();



    cv::Mat lines;
    det->detect(gray, lines);

    det->drawSegments(input, lines);

    cv::imshow("input", input);
    cv::waitKey(0);
    return 0;
}

给出这个结果：

与你的图像相比，它看起来更适合进一步处理（没有重复的线条等）。

附加信息（感谢@Ivan）：

“由于原始代码许可证冲突，OpenCV 版本 3.4.6 至 3.4.15 和版本 4.1.0 至 4.5.3 中的实现已被删除。在 MIT 许可证下发布的 NFA 代码计算后再次恢复。”

解决方案 3：

这里对你问题的第一部分有一些很好的答案，但对于第二部分（寻找线交叉点），我并没有看到很多。

我建议你看看Bentley-Ottmann算法。

这里和这里有一些该算法的 python 实现。

编辑：使用 VeraPoseidon 的 Houghlines 实现和此处链接的第二个库，我设法获得了以下交叉点检测结果。感谢 Vera 和库作者的出色工作。绿色方块表示检测到的交叉点。有一些错误，但对我来说这似乎是一个很好的起点。似乎您真正想要检测交叉点的大多数位置都检测到了多个交叉点，因此您可能可以在图像上运行适当大小的窗口来查找多个交叉点，并将激活该窗口的交叉点视为真正的交叉点。

下面是我用来产生该结果的代码：

import cv2
import numpy as np
import isect_segments_bentley_ottmann.poly_point_isect as bot


img = cv2.imread('parking.png')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

kernel_size = 5
blur_gray = cv2.GaussianBlur(gray,(kernel_size, kernel_size),0)

low_threshold = 50
high_threshold = 150
edges = cv2.Canny(blur_gray, low_threshold, high_threshold)

rho = 1  # distance resolution in pixels of the Hough grid
theta = np.pi / 180  # angular resolution in radians of the Hough grid
threshold = 15  # minimum number of votes (intersections in Hough grid cell)
min_line_length = 50  # minimum number of pixels making up a line
max_line_gap = 20  # maximum gap in pixels between connectable line segments
line_image = np.copy(img) * 0  # creating a blank to draw lines on

# Run Hough on edge detected image
# Output "lines" is an array containing endpoints of detected line segments
lines = cv2.HoughLinesP(edges, rho, theta, threshold, np.array([]),
                    min_line_length, max_line_gap)
print(lines)
points = []
for line in lines:
    for x1, y1, x2, y2 in line:
        points.append(((x1 + 0.0, y1 + 0.0), (x2 + 0.0, y2 + 0.0)))
        cv2.line(line_image, (x1, y1), (x2, y2), (255, 0, 0), 5)

lines_edges = cv2.addWeighted(img, 0.8, line_image, 1, 0)
print(lines_edges.shape)
#cv2.imwrite('line_parking.png', lines_edges)

print points
intersections = bot.isect_segments(points)
print intersections

for inter in intersections:
    a, b = inter
    for i in range(3):
        for j in range(3):
            lines_edges[int(b) + i, int(a) + j] = [0, 255, 0]

cv2.imwrite('line_parking.png', lines_edges)

您可以使用类似这样的代码块来制定策略来移除小区域内的多个交叉点：

for idx, inter in enumerate(intersections):
    a, b = inter
    match = 0
    for other_inter in intersections[idx:]:
        if other_inter == inter:
            continue
        c, d = other_inter
        if abs(c-a) < 15 and abs(d-b) < 15:
            match = 1
            intersections[idx] = ((c+a)/2, (d+b)/2)
            intersections.remove(other_inter)

    if match == 0:
        intersections.remove(inter)

输出图像：

不过你必须使用窗口功能。

解决方案 4：

我是初学者。我有一些可能对这个问题有帮助的东西。

检测图像中的线条的简单方法。

输出：

以下是在 google colab 中执行的代码

import cv2
import numpy as np
from google.colab.patches import cv2_imshow
!wget  https://i.sstatic.net/sDQLM.png
#read image 
image = cv2.imread( "/content/sDQLM.png")

#convert to gray
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

#performing binary thresholding
kernel_size = 3
ret,thresh = cv2.threshold(gray,200,255,cv2.THRESH_BINARY)  

#finding contours 
cnts = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
cnts = cnts[0] if len(cnts) == 2 else cnts[1]

#drawing Contours
radius =2
color = (30,255,50)
cv2.drawContours(image, cnts, -1,color , radius)
# cv2.imshow(image) commented as colab don't support cv2.imshow()
cv2_imshow(image)
# cv2.waitKey()

解决方案 5：

如果您调整 maxLineGap 或侵蚀内核的大小，会发生什么情况。或者，您可以找到线条之间的距离。您必须经过多对线，例如 ax1、ay1 到 ax2、ay2 cf bx1、by1 到 bx2、by2，您可以找到与 a 成直角的梯度（线的梯度为 -1）与线 b 相交的点。基础学校几何和联立方程，例如：

x = (ay1 - by1) / ((by2 - by1) / (bx2 - bx1) + (ax2 - ax1) / (ay2 - ay1))
# then
y = by1 + x * (by2 - by1) / (bx2 - bx1)

并将 x,y 与 ax1,ay1 进行比较

PS 您可能需要添加对 ax1、ay1 和 bx1、by1 之间距离的检查，因为您的某些线看起来是其他线的延续，而这些线可能会被最近点技术消除。