使用 OpenCV 霍​​夫变换在 2D 点云中进行线检测

Question

I have tried my best to find out how to use OpenCV for line detection. However, I cannot find the examples that I'm looking for. I want to use it to find lines in simple 2-d point clouds. As a test I want to use the following points:

import random
import numpy as np
import matplotlib.pyplot as plt

a = np.random.randint(1,101,400)  # Random points.
b = np.random.randint(1,101,400)  # Random points.

for i in range(0, 90, 2):  # A line to detect
    a = np.append(a, [i+5])
    b = np.append(b, [0.5*i+30])

plt.plot(a, b, '.')
plt.show()

I have found a lot of initial examples of how the Hough Tranform works. However, when it comes to code examples, I can only find that images have been used.

Is there a way to use the OpenCV Hough Transform to detect the line in a set of points, or can you recommend any other methods or libraries?

---- Edit ----

After reading some great ansewers I feel like I scould discribe what i intent to use it for a little bit better. I have a high resolution 2D LiDAR and need to extract walls from the data. A typicle scan can look like this:

Where the "correct output" would look something like this:

After I have done some more research I suspect that the Hough transform is less than optimal to use in this case. Any tips on what i should look for?

(If anyone is interested, the LiDAR and wall extraction is used to generate a map and navigate a robot.)

Thanks, Jakob

Answer 1

One way would be to implement Hough Transformation yourself following these slides skipping the Edge Detection part.

Alternatively you could create an image from your list of points such as

#create an image from list of points
x_shape = int(np.max(a) - np.min(a))
y_shape = int(np.max(b) - np.min(b))

im = np.zeros((x_shape+1, y_shape+1))

indices = np.stack([a-1,b-1], axis =1).astype(int)
im[indices[:,0], indices[:,1]] = 1

plt.imshow(im)

#feed to opencv as usual

following the answer to this question

EDIT: Do not feed to OpenCV but use instead skimage such as described here in the documentation :

import numpy as np

from skimage.transform import (hough_line, hough_line_peaks,
                               probabilistic_hough_line)
from skimage.feature import canny
from skimage import data

import matplotlib.pyplot as plt
from matplotlib import cm


# Constructing test image
#image = np.zeros((100, 100))
#idx = np.arange(25, 75)
#image[idx[::-1], idx] = 255
#image[idx, idx] = 255

image = im

# Classic straight-line Hough transform
h, theta, d = hough_line(image)

# Generating figure 1
fig, axes = plt.subplots(1, 3, figsize=(15, 6))
ax = axes.ravel()

ax[0].imshow(image, cmap=cm.gray)
ax[0].set_title('Input image')
ax[0].set_axis_off()

ax[1].imshow(np.log(1 + h),
             extent=[np.rad2deg(theta[-1]), np.rad2deg(theta[0]), d[-1], d[0]],
             cmap=cm.gray, aspect=1/1.5)
ax[1].set_title('Hough transform')
ax[1].set_xlabel('Angles (degrees)')
ax[1].set_ylabel('Distance (pixels)')
ax[1].axis('image')

ax[2].imshow(image, cmap=cm.gray)
for _, angle, dist in zip(*hough_line_peaks(h, theta, d)):
    y0 = (dist - 0 * np.cos(angle)) / np.sin(angle)
    y1 = (dist - image.shape[1] * np.cos(angle)) / np.sin(angle)
    ax[2].plot((0, image.shape[1]), (y0, y1), '-r')
ax[2].set_xlim((0, image.shape[1]))
ax[2].set_ylim((image.shape[0], 0))
ax[2].set_axis_off()
ax[2].set_title('Detected lines')

plt.tight_layout()
plt.show()

# Line finding using the Probabilistic Hough Transform
image = data.camera()
edges = canny(image, 2, 1, 25)
lines = probabilistic_hough_line(edges, threshold=10, line_length=5,
                                 line_gap=3)

# Generating figure 2
fig, axes = plt.subplots(1, 3, figsize=(15, 5), sharex=True, sharey=True)
ax = axes.ravel()

ax[0].imshow(image, cmap=cm.gray)
ax[0].set_title('Input image')

ax[1].imshow(edges, cmap=cm.gray)
ax[1].set_title('Canny edges')

ax[2].imshow(edges * 0)
for line in lines:
    p0, p1 = line
    ax[2].plot((p0[0], p1[0]), (p0[1], p1[1]))
ax[2].set_xlim((0, image.shape[1]))
ax[2].set_ylim((image.shape[0], 0))
ax[2].set_title('Probabilistic Hough')

for a in ax:
    a.set_axis_off()

plt.tight_layout()
plt.show()

Answer 2

Here's an approach

• Convert image to grayscale
• Threshold to obtain binary image
• Perform morphological operations to connect contours and smooth image
• Find lines

---

After converting to grayscale, we threshold image to obtain a binary image

import cv2
import numpy as np

image = cv2.imread('1.png')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(gray, 0, 255,cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]

Next we perform morphological operations to connect contours

kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9,9))
close = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel, iterations=3)

Finally we find the line using cv2.HoughLinesP()

minLineLength = 550
maxLineGap = 70
lines = cv2.HoughLinesP(close,1,np.pi/180,100,minLineLength,maxLineGap)
for line in lines:
    for x1,y1,x2,y2 in line:
        cv2.line(image,(x1,y1),(x2,y2),(36,255,12),3)

Instead of using cv2.HoughLinesP() , an alternative method is to find contours and filter using cv2.contourArea() . The largest contour will be our line.

---

Full code

import cv2
import numpy as np

image = cv2.imread('1.png')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(gray, 0, 255,cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]

kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9,9))
close = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel, iterations=3)

minLineLength = 550
maxLineGap = 70
lines = cv2.HoughLinesP(close,1,np.pi/180,100,minLineLength,maxLineGap)
for line in lines:
    for x1,y1,x2,y2 in line:
        cv2.line(image,(x1,y1),(x2,y2),(36,255,12),3)

cv2.imshow('thresh', thresh)
cv2.imshow('close', close)
cv2.imshow('image', image)
cv2.waitKey()

Answer 3

You most likely won't be able to use Hough transform to detect lines in a set of points. Hough transform works with images. Better yet, binarized images with edges marked as 1 and background stays as 0 . So, forget about the Hough transform.

For your particular case I'd suggest some kind of RANSAC algorithm, which looks for specific points following some rules, ignoring everything else. Though, in your case you have a lot (=too much) noise. If you can keep the noise points below 50%, RANSAC will do the trick. You may read the details here: OpenCV - Ransac fitting line

Or here's the Wiki with the most generic explanation: https://en.wikipedia.org/wiki/RANSAC

Answer 4

After spending some (alot) of time with the problem I eventually reached a solution that I was sattisfied with.

My solution is to go through the scan data as it is read (as a revolving scanner) and iteratively look at smalles sections of the data, then running a custom ransac algorithm to fit a line to the current segment.

Then if the segment satisfies the critera for a possible line the segment is extended and checked again. This is then repeated for all small segments of data in different ways. In short, I used a custom, self written from scratch, iterative ransac line fit.

If we take a similar example to what I initially gave:

The following result is now generated by the algorith:

And comparing to the actual (wall) map of the enviroment we can see the following comparison:

Which I would say is good enough. Another important note is that the algorith can be run for multiple scans of data with the enviroment naturally chaning slightly inbetween all of the scans (taking quite some time to execute):

As can bee seen there are some extra walls that are not a part of the map, which is to be expected and also some faulty findings that can be filtered since they are clear outliers.

Now for the code.... The final solution is a 300 lines long python script converted though a .pyx file and compiled using Cython in order to improve time complexity. If the code or maybe more importantly a psuedo code (since my implementation is tweeked to my specfic need) is wanted I can provide it given that someone will enjoy using/reading it :)