如何使用霍夫线检测来检测时钟指针

Question

我想从模拟时钟中获取时间。现在我有点卡住了，我设法得到了分割的图像(尽管我不能去掉它的底部...)，并做了Canny检测。我的问题是，底部的部分我不能去掉，还有对时钟指针的检测。我的目标是以一种可以计算角度的方式来检测手，然后从这些角度计算时间。我知道我需要Hough Line Transform，但我真的不知道它是如何工作的，如何设置参数。

原始的、分割的和Canny检测到的图片：

​

​

​

​

​

​

这是我用来实现这一点的代码：

img = cv2.imread('clock.jpg')
cv2.imshow('img', img)
cv2.waitKey(0)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blur = cv2.medianBlur(gray, 5)
cv2.imshow('blur', blur)
cv2.waitKey(0)

circles = cv2.HoughCircles(blur, cv2.HOUGH_GRADIENT, 1, 20, param1=20, param2=100, minRadius=0, maxRadius=0)
detected_cricles = np.uint16(np.around(circles))
circle = detected_cricles[0][0]

x = circle[0]
y = circle[1]
r = circle[2]

rect = (x - r, y - r, x+r, y+(r-10))
mask = np.zeros(img.shape[:2], dtype = np.uint8)
bgdModel = np.zeros((1,65), np.float64)
fgdModel = np.zeros((1,65), np.float64)

cv2.grabCut(img, mask, rect, bgdModel, fgdModel, 1, cv2.GC_INIT_WITH_RECT)
mask2 = np.where((mask == 1) + (mask == 3), 255, 0).astype('uint8')
segmented = cv2.bitwise_and(img, img, mask=mask2)
cv2.imshow('segmented', segmented)
cv2.waitKey(0)

blur = cv2.GaussianBlur(segmented, (11,11), 0)
cv2.imshow('blur2', blur)
cv2.waitKey(0)

canny = cv2.Canny(blur, 30, 150, None, 3)
cv2.imshow('canny', canny)
cv2.waitKey(0)

Answer 1

以下是在Python/OpenCV中使用HoughLinesP的一种方法。该方法在得到Hough Lines之前使用阈值、轮廓和细化。我将把从线端点计算角度的任务留给你。

输入：

​

​

import cv2
import numpy as np
from skimage.morphology import skeletonize

# Read image
img = cv2.imread('clock.jpg')
hh, ww = img.shape[:2]

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

# threshold
thresh = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY)[1]

# invert so shapes are white on black background
thresh = 255 - thresh

# get contours and save area
cntrs_info = []
contours = cv2.findContours(thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
contours = contours[0] if len(contours) == 2 else contours[1]
index=0
for cntr in contours:
    area = cv2.contourArea(cntr)
    cntrs_info.append((index,area))
    index = index + 1

# sort contours by area
def takeSecond(elem):
    return elem[1]
cntrs_info.sort(key=takeSecond, reverse=True)

# get third largest contour
arms = np.zeros_like(thresh)
index_third = cntrs_info[2][0]
cv2.drawContours(arms,[contours[index_third]],0,(1),-1)

#arms=cv2.ximgproc.thinning(arms)
arms_thin = skeletonize(arms)
arms_thin = (255*arms_thin).clip(0,255).astype(np.uint8)

# get hough lines and draw on copy of input
result = img.copy()
lineThresh = 15
minLineLength = 20
maxLineGap = 100
max
lines = cv2.HoughLinesP(arms_thin, 1, np.pi/180, lineThresh, None, minLineLength, maxLineGap)

for [line] in lines:
    x1 = line[0]
    y1 = line[1]
    x2 = line[2]
    y2 = line[3]
    cv2.line(result, (x1,y1), (x2,y2), (0,0,255), 2)   

# save results
cv2.imwrite('clock_thresh.jpg', thresh)
cv2.imwrite('clock_arms.jpg', (255*arms).clip(0,255).astype(np.uint8))
cv2.imwrite('clock_arms_thin.jpg', arms_thin)
cv2.imwrite('clock_lines.jpg', result)

cv2.imshow('thresh', thresh)
cv2.imshow('arms', (255*arms).clip(0,255).astype(np.uint8))
cv2.imshow('arms_thin', arms_thin)
cv2.imshow('result', result)
cv2.waitKey(0)
cv2.destroyAllWindows()

​

阈值图像：

​

​

手臂的轮廓：

​

​

精简(骨架)：

​

​

输入上的霍夫线段：

​

​

Answer 2

这是另一种可能的解决方案。我们将尝试分割时钟指针，并通过Hough的线变换运行它们来检测线。现在，这种检测将产生通过时钟指针像素的所有可能的直线-产生多条直线。您可以尝试使用线变换参数来将结果缩小到目标线，但最终可能会得到一簇线。我将尝试使用K-Means对这些行进行聚类，以便只得到两行，而不管Hough的行转换的输出是什么。以下是步骤：

1. 获取图像的二进制掩码以隔离钟针
2. 应用一些形态学以消除噪声
3. 通过霍夫行detection
4. Use E115K-means在多行上运行二进制掩模仅获得E117仅2行E218(平均)行(每个时钟指针一条)

让我们看看代码：

# Imports
import cv2
import numpy as np

# Read image
imagePath = "D://opencvImages//"
inputImage = cv2.imread(imagePath+"orFGl.jpg")

# Store deep copy for results:
originalImg = inputImage.copy()

# Convert BGR back to grayscale:
grayInput = cv2.cvtColor(inputImage, cv2.COLOR_BGR2GRAY)

# Threshold via Otsu + bias adjustment:
threshValue, binaryImage = cv2.threshold(grayInput, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)

第一位是微不足道的，并产生这个二进制掩码：

​

​

我们可以通过一些形态学来去除这些小的元素。让我们先应用一个erosion，然后再应用一个dilation来过滤除较大组件--时钟指针之外的所有组件：

# Set morph operation iterations:
opIterations = 1

# Get the structuring element:
structuringElement = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))

# Perform Erode:
erodeImg = cv2.morphologyEx(binaryImage, cv2.MORPH_ERODE, structuringElement, None, None, opIterations, cv2.BORDER_REFLECT101)
# Perform Dilate:
dilateImg = cv2.morphologyEx(erodeImg, cv2.MORPH_DILATE, structuringElement, None, None, opIterations, cv2.BORDER_REFLECT101)

这将生成以下图像：

​

​

非常好，几乎所有的噪音都消失了。让我们直接通过行检测来运行它，并检查我们得到了什么样的结果。此外，我还准备了一些列表来存储各行的每个开始(x1, y1)和结束(x2, y2)点：

# Set HoughLinesP parameters:
lineThresh = 50
minLineLength = 20
maxLineGap = 100
# Run the line detection:
lines = cv2.HoughLinesP(dilateImg, 1, np.pi/180, lineThresh, None, minLineLength, maxLineGap)

# Prepare some lists to store every coordinate of the detected lines:
X1 = []
X2 = []
Y1 = []
Y2 = []

# Store and draw the lines:
for [currentLine] in lines:

    # First point:
    x1 = currentLine[0]
    y1 = currentLine[1]
    X1.append(x1)
    Y1.append(y1)

    # Second point:
    x2 = currentLine[2]
    y2 = currentLine[3]
    X2.append(x2)
    Y2.append(y2)

    # Draw the lines:
    cv2.line(originalImg, (x1,y1), (x2,y2), (0,0,255), 2)
    cv2.imshow("Lines", originalImg)
    cv2.waitKey(0)

这就是结果：

​

​

如您所见，有多行代码。幸运的是，这些线聚集在两个非常清晰的组中:左手和右手。如果我们将四个坐标成两组，我们可以得到每只手的平均起点和终点。这可以通过应用聚类算法来完成，在本例中为K-Means。K-means将需要四个保存数据的阵列来生成两个集群中心。在将我们的数据提供给它之前，我们需要按照K-means期望的方式重塑它：

# Reshape the arrays for K-means
X1 = np.array(X1)
Y1 = np.array(Y1)
X2 = np.array(X2)
Y2 = np.array(Y2)

X1dash = X1.reshape(-1,1)
Y1dash = Y1.reshape(-1,1)
X2dash = X2.reshape(-1,1)
Y2dash = Y2.reshape(-1,1)

# Stack the data
Z = np.hstack((X1dash, Y1dash, X2dash, Y2dash))

# K-means operates on 32-bit float data:
floatPoints = np.float32(Z)

# Set the convergence criteria and call K-means:
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
# Set the desired number of clusters
K = 2
ret, label, center = cv2.kmeans(floatPoints, K, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)

结果在center数组中。这里我们给出了最后一对线。让我们遍历它并在原始图像上绘制它们：

# Loop through the center points
# and draw the lines:
for p in range(len(center)):

    # Get line points:
    print(center[p])
    x1 = int(center[p][0])
    y1 = int(center[p][1])
    x2 = int(center[p][2])
    y2 = int(center[p][3])

    cv2.line(originalImg, (x1, y1), (x2, y2), (0, 255, 0), 1)
    cv2.imshow("Lines", originalImg)
    cv2.waitKey(0)

这是最后一对线(绿色)：

​

​