創作不易，如果對您有幫助，幫忙點贊哦！

一. 霍夫變換理解：

二. 霍夫變換簡介：

霍夫變換，是將坐標由直角坐標系變換到極坐標系，然后再根據數學表達式檢測某些形狀(如直線和圓)的方法。當 l1直線 上的某些點變換到極坐標系下時，表現為某些線(和前面點數量一致)，這些線交于一點，通過該點的坐標就能表示原先的 l1直線。

三. 霍夫變換用于檢測圖像直線算法實現：

① 提取圖像邊緣(可使用Canny算法等)[我也實現了它，前面Canny算法有問題可以參考我的另一篇文章：https://www.cnblogs.com/wojianxin/p/12533526.html]

② 實現二值圖像霍夫變換

1. 求出圖像對角線長：r_max

2. 在邊緣點 (x,y) 處，t 取[0,180)，步長設為1，根據下式進行霍夫變換

霍夫變換，(r_ho,t) 表示極坐標，(x,y) 表示直角坐標 ↑

3. 做一個大小為 r_max * 180 的表，變換后一個值落在表內某坐標，就將該坐標表內值 + 1，簡言之，就是在進行投票，統計通過哪個點的直線的數量最多(即在原圖像上越趨近于一條直線)。

③ 進行非極大值抑制(NMS)操作，使找出的直線落在不同的地點

NMS 的算法如下：

1. 遍歷該表，如果遍歷到的像素的投票數大于其8近鄰的像素投票值，則它不變。

2. 如果遍歷到的像素的投票數小于其8近鄰的像素投票值，則將其設置為0。

④ 找到20個投票數最多的點(即：直角坐標系下20條直線)準備進行輸出

1. np.ravel? ?將多維數組降為1維

2. np.argsort? ?將數組元素從小到大排序，返回索引值

3. [::-1]? ?數組反序 -> 得到從大到小索引值

4. [:20]? ?前20個最大投票值的索引

5. 根據索引得到坐標(r，t)

⑤ 霍夫反變換后，畫出原圖中的20條直線，輸出圖像

霍夫逆變換公式 ↑

四. 純手工實現 ——> 利用霍夫變換檢測圖像中的直線

1 importcv22 importnumpy as np3 importmatplotlib.pyplot as plt4

5 #Canny算法：提取圖像邊緣

6 defCanny(img):7

8 #Gray scale

9 defBGR2GRAY(img):10 b =img[:, :, 0].copy()11 g = img[:, :, 1].copy()12 r = img[:, :, 2].copy()13

14 #Gray scale

15 out = 0.2126 * r + 0.7152 * g + 0.0722 *b16 out =out.astype(np.uint8)17

18 returnout19

20

21 #Gaussian filter for grayscale

22 def gaussian_filter(img, K_size=3, sigma=1.3):23

24 if len(img.shape) == 3:25 H, W, C =img.shape26 gray =False27 else:28 img = np.expand_dims(img, axis=-1)29 H, W, C =img.shape30 gray =True31

32 ## Zero padding

33 pad = K_size // 2

34 out = np.zeros([H + pad * 2, W + pad * 2, C], dtype=np.float)35 out[pad : pad + H, pad : pad + W] =img.copy().astype(np.float)36

37 ## prepare Kernel

38 K = np.zeros((K_size, K_size), dtype=np.float)39 for x in range(-pad, -pad +K_size):40 for y in range(-pad, -pad +K_size):41 K[y + pad, x + pad] = np.exp( - (x ** 2 + y ** 2) / (2 * sigma *sigma))42 #K /= (sigma * np.sqrt(2 * np.pi))

43 K /= (2 * np.pi * sigma *sigma)44 K /=K.sum()45

46 tmp =out.copy()47

48 #filtering

49 for y inrange(H):50 for x inrange(W):51 for c inrange(C):52 out[pad + y, pad + x, c] = np.sum(K * tmp[y : y + K_size, x : x +K_size, c])53

54 out = np.clip(out, 0, 255)55 out = out[pad : pad + H, pad : pad +W]56 out =out.astype(np.uint8)57

58 ifgray:59 out =out[..., 0]60

61 returnout62

63

64 #sobel filter

65 def sobel_filter(img, K_size=3):66 if len(img.shape) == 3:67 H, W, C =img.shape68 else:69 H, W =img.shape70

71 #Zero padding

72 pad = K_size // 2

73 out = np.zeros((H + pad * 2, W + pad * 2), dtype=np.float)74 out[pad : pad + H, pad : pad + W] =img.copy().astype(np.float)75 tmp =out.copy()76

77 out_v =out.copy()78 out_h =out.copy()79

80 ## Sobel vertical

81 Kv = [[1., 2., 1.],[0., 0., 0.], [-1., -2., -1.]]82 ## Sobel horizontal

83 Kh = [[1., 0., -1.],[2., 0., -2.],[1., 0., -1.]]84

85 #filtering

86 for y inrange(H):87 for x inrange(W):88 out_v[pad + y, pad + x] = np.sum(Kv * (tmp[y : y + K_size, x : x +K_size]))89 out_h[pad + y, pad + x] = np.sum(Kh * (tmp[y : y + K_size, x : x +K_size]))90

91 out_v = np.clip(out_v, 0, 255)92 out_h = np.clip(out_h, 0, 255)93

94 out_v = out_v[pad : pad + H, pad : pad +W]95 out_v =out_v.astype(np.uint8)96 out_h = out_h[pad : pad + H, pad : pad +W]97 out_h =out_h.astype(np.uint8)98

99 returnout_v, out_h100

101

102 defget_edge_angle(fx, fy):103 #get edge strength

104 edge = np.sqrt(np.power(fx.astype(np.float32), 2) + np.power(fy.astype(np.float32), 2))105 edge = np.clip(edge, 0, 255)106

107 fx = np.maximum(fx, 1e-10)108 #fx[np.abs(fx) <= 1e-5] = 1e-5

109

110 #get edge angle

111 angle = np.arctan(fy /fx)112

113 returnedge, angle114

115

116 defangle_quantization(angle):117 angle = angle / np.pi * 180

118 angle[angle < -22.5] = 180 + angle[angle < -22.5]119 _angle = np.zeros_like(angle, dtype=np.uint8)120 _angle[np.where(angle <= 22.5)] =0121 _angle[np.where((angle > 22.5) & (angle <= 67.5))] = 45

122 _angle[np.where((angle > 67.5) & (angle <= 112.5))] = 90

123 _angle[np.where((angle > 112.5) & (angle <= 157.5))] = 135

124

125 return_angle126

127

128 defnon_maximum_suppression(angle, edge):129 H, W =angle.shape130 _edge =edge.copy()131

132 for y inrange(H):133 for x inrange(W):134 if angle[y, x] ==0:135 dx1, dy1, dx2, dy2 = -1, 0, 1, 0136 elif angle[y, x] == 45:137 dx1, dy1, dx2, dy2 = -1, 1, 1, -1

138 elif angle[y, x] == 90:139 dx1, dy1, dx2, dy2 = 0, -1, 0, 1

140 elif angle[y, x] == 135:141 dx1, dy1, dx2, dy2 = -1, -1, 1, 1

142 if x ==0:143 dx1 =max(dx1, 0)144 dx2 =max(dx2, 0)145 if x == W-1:146 dx1 =min(dx1, 0)147 dx2 =min(dx2, 0)148 if y ==0:149 dy1 =max(dy1, 0)150 dy2 =max(dy2, 0)151 if y == H-1:152 dy1 =min(dy1, 0)153 dy2 =min(dy2, 0)154 if max(max(edge[y, x], edge[y + dy1, x + dx1]), edge[y + dy2, x + dx2]) !=edge[y, x]:155 _edge[y, x] =0156

157 return_edge158

159 def hysterisis(edge, HT=100, LT=30):160 H, W =edge.shape161

162 #Histeresis threshold

163 edge[edge >= HT] = 255

164 edge[edge <= LT] =0165

166 _edge = np.zeros((H + 2, W + 2), dtype=np.float32)167 _edge[1 : H + 1, 1 : W + 1] =edge168

169 ## 8 - Nearest neighbor

170 nn = np.array(((1., 1., 1.), (1., 0., 1.), (1., 1., 1.)), dtype=np.float32)171

172 for y in range(1, H+2):173 for x in range(1, W+2):174 if _edge[y, x] < LT or _edge[y, x] >HT:175 continue

176 if np.max(_edge[y-1:y+2, x-1:x+2] * nn) >=HT:177 _edge[y, x] = 255

178 else:179 _edge[y, x] =0180

181 edge = _edge[1:H+1, 1:W+1]182

183 returnedge184

185 #grayscale

186 gray =BGR2GRAY(img)187

188 #gaussian filtering

189 gaussian = gaussian_filter(gray, K_size=5, sigma=1.4)190

191 #sobel filtering

192 fy, fx = sobel_filter(gaussian, K_size=3)193

194 #get edge strength, angle

195 edge, angle =get_edge_angle(fx, fy)196

197 #angle quantization

198 angle =angle_quantization(angle)199

200 #non maximum suppression

201 edge =non_maximum_suppression(angle, edge)202

203 #hysterisis threshold

204 out = hysterisis(edge, 100, 30)205

206 returnout207

208 #霍夫變換實現檢測圖像中的20條直線

209 defHough_Line(edge, img):210 ## Voting

211 defvoting(edge):212 H, W =edge.shape213

214 drho = 1

215 dtheta = 1

216

217 #get rho max length

218 rho_max = np.ceil(np.sqrt(H ** 2 + W ** 2)).astype(np.int)219

220 #hough table

221 hough = np.zeros((rho_max, 180), dtype=np.int)222

223 #get index of edge

224 #ind[0] 是 符合條件的縱坐標，ind[1]是符合條件的橫坐標

225 ind = np.where(edge == 255)226

227 ## hough transformation

228 #zip函數返回元組

229 for y, x in zip(ind[0], ind[1]):230 for theta in range(0, 180, dtheta):231 #get polar coordinat4s

232 t = np.pi / 180 *theta233 rho = int(x * np.cos(t) + y *np.sin(t))234

235 #vote

236 hough[rho, theta] += 1

237

238 out =hough.astype(np.uint8)239

240 returnout241

242 #non maximum suppression

243 defnon_maximum_suppression(hough):244 rho_max, _ =hough.shape245

246 ## non maximum suppression

247 for y inrange(rho_max):248 for x in range(180):249 #get 8 nearest neighbor

250 x1 = max(x-1, 0)251 x2 = min(x+2, 180)252 y1 = max(y-1, 0)253 y2 = min(y+2, rho_max-1)254 if np.max(hough[y1:y2, x1:x2]) == hough[y,x] and hough[y, x] !=0:255 pass

256 #hough[y,x] = 255

257 else:258 hough[y,x] =0259

260 returnhough261

262 definverse_hough(hough, img):263 H, W, _=img.shape264 rho_max, _ =hough.shape265

266 out =img.copy()267

268 #get x, y index of hough table

269 #np.ravel 將多維數組降為1維

270 #argsort 將數組元素從小到大排序，返回索引

271 #[::-1] 反序->從大到小

272 #[:20] 前20個

273 ind_x = np.argsort(hough.ravel())[::-1][:20]274 ind_y =ind_x.copy()275 thetas = ind_x % 180

276 rhos = ind_y // 180

277

278 #each theta and rho

279 for theta, rho inzip(thetas, rhos):280 #theta[radian] -> angle[degree]

281 t = np.pi / 180. *theta282

283 #hough -> (x,y)

284 for x inrange(W):285 if np.sin(t) !=0:286 y = - (np.cos(t) / np.sin(t)) * x + (rho) /np.sin(t)287 y =int(y)288 if y >= H or y <0:289 continue

290 out[y, x] = [0,255,255]291 for y inrange(H):292 if np.cos(t) !=0:293 x = - (np.sin(t) / np.cos(t)) * y + (rho) /np.cos(t)294 x =int(x)295 if x >= W or x <0:296 continue

297 out[y, x] = [0,0,255]298

299 out =out.astype(np.uint8)300

301 returnout302

303

304 #voting

305 hough =voting(edge)306

307 #non maximum suppression

308 hough =non_maximum_suppression(hough)309

310 #inverse hough

311 out =inverse_hough(hough, img)312

313 returnout314

315

316 #Read image

317 img = cv2.imread("../paojie.jpg").astype(np.float32)318

319 #Canny

320 edge =Canny(img)321

322 #Hough

323 out =Hough_Line(edge, img)324

325 out =out.astype(np.uint8)326

327 #Save result

328 cv2.imwrite("out.jpg", out)329 cv2.imshow("result", out)330 cv2.waitKey(0)331 cv2.destroyAllWindows()

View Code

五. 實驗結果：

原圖 ↑

霍夫變換檢測到的直線 ↑

六. 參考內容：

七. 版權聲明：

未經作者允許，請勿隨意轉載抄襲，抄襲情節嚴重者，作者將考慮追究其法律責任，創作不易，感謝您的理解和配合！

總結

以上是生活随笔為你收集整理的python 图像变化检测_霍夫变换检测图像直线算法python实现的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。